commit - 77a0a5b5194d4441c86de097f2aae297cb75e2c2
commit + fa325e9b42b0bdfb48857d1958d9fb7ceac55151
blob - 9cae9582985a9610dd9fdbaa8ecb05be5d46a90b
blob + c7d72848441a5c38887e384d79783b756f193c14
--- src/cmd/9660/boot.c
+++ src/cmd/9660/boot.c
55 aa - magic
0000020 88 - 88 = bootable
- 03 - 3 = 2.88MB diskette
+ 03 - 3 = 2.88MB diskette
00 00 - load segment 0 means default 0x7C0
00 - system type (byte 5 of boot image)
00 - unused (0)
1+0 records out
0000000 eb 3c 00 00 00 00 00 00 00 00 00 00 02 00 00 00
0000010 00 00 00 00 00 00 00 00 12 00 02 00 00 00 00 00
-0000020 00 00 00 00 00 16 1f 66 6a 00 51 50 06 53
+0000020 00 00 00 00 00 16 1f 66 6a 00 51 50 06 53
31 c0
FREEBSD
0000000 eb 3c 00 00 00 00 00 00 00 00 00 00 02 00 00 00
0000010 00 00 00 00 00 00 00 00 12 00 02 00 00 00 00 00
-0000020 00 00 00 00 00 16 1f 66 6a 00 51 50 06 53
+0000020 00 00 00 00 00 16 1f 66 6a 00 51 50 06 53
31 c0
DOS 5
Cputc(cd, 0); /* unused */
Cputnl(cd, 1, 2); /* 512-byte sector count for load */
Cputnl(cd, cd->bootdirec->block, 4); /* ptr to disk image */
- Cwseek(cd, o);
+ Cwseek(cd, o);
}
void
blob - 757bfcd930cc65189251c9f3562597f243f96b0b
blob + 786b798f21994b13de14be4d7a7aaa3ea38406d3
--- src/cmd/9660/cdrdwr.c
+++ src/cmd/9660/cdrdwr.c
}
/* lowercase because of isostring */
- if(strstr(cd->iso.systemid, "iso9660") == nil
+ if(strstr(cd->iso.systemid, "iso9660") == nil
&& strstr(cd->iso.systemid, "utf8") == nil) {
werrstr("unknown systemid %s", cd->iso.systemid);
free(cd);
close(xfd);
return nil;
}
-
+
if(strstr(cd->iso.systemid, "plan 9"))
cd->flags |= CDplan9;
if(strstr(cd->iso.systemid, "iso9660"))
v->biblio = string(cv->biblio, sizeof cv->biblio);
v->notice = string(cv->notice, sizeof cv->notice);
}
-
+
static int
readisodesc(Cdimg *cd, Voldesc *v)
{
{
return Blinelen(&cd->brd);
}
-
blob - 8185f680611259cea5531245bb7f16dfb9e5e21e
blob + e67f0cb766e86396a43d044f4d64d9ef9398e06e
--- src/cmd/9660/direc.c
+++ src/cmd/9660/direc.c
* Add the file ``name'' with attributes d to the
* directory ``root''. Name may contain multiple
* elements; all but the last must exist already.
- *
+ *
* The child lists are kept sorted by utfname.
- */
+ */
Direc*
adddirec(Direc *root, char *name, XDir *d)
{
return nd;
}
-/*
+/*
* Copy the tree src into dst.
*/
void
for(i=0; i<n; i++)
dsort(&d->child[i], cmp);
}
-
blob - d3504ff946585bf8d1bc893856fcc60d8afc00c1
blob + ad762f2175f6dcbff6568956fa634866de15238d
--- src/cmd/9660/dump.c
+++ src/cmd/9660/dump.c
Tm tm;
tm = *localtime(now);
-
+
sprint(buf, "%d", tm.year+1900);
if((dyear = walkdirec(root, buf)) == nil) {
dyear = adddirec(root, buf, dir);
}
return 0;
}
-
+
Direc
readdumpdirs(Cdimg *cd, XDir *dir, char *(*cvt)(uchar*, int))
{
if(tokenize(p, f, 2) != 2 || (f[0][0] != 'D' && f[0][0] != 'F')
|| strlen(f[0]) != 7 || !isalldigit(f[0]+1))
break;
-
+
addtx(atom(f[1]), atom(f[0]));
}
}
blob - 4e66bd78a91d2166848dcc0a6926cb0365f7ff03
blob + 59ee31c0e52af37e39ae792b881e9b90829f1aa3
--- src/cmd/9660/dump9660.c
+++ src/cmd/9660/dump9660.c
Cwseek(cd, cd->nextblock*Blocksize);
goto Dofix;
}
-
+
dumpname = adddumpdir(&idumproot, now, &dir);
/* note that we assume all names are conforming and thus sorted */
if(cd->flags & CDjoliet) {
findbootimage(cd, &iroot);
Cupdatebootcat(cd);
}
-
+
/* create Joliet tree */
if(cd->flags & CDjoliet)
copydirec(&jroot, &iroot);
* Write incremental _conform.map block.
*/
wrconform(cd, cd->nconform, &cblock, &clength);
-
+
/* jump here if we're just fixing up the cd */
Dofix:
/*
- * Write null dump header block; everything after this will be
+ * Write null dump header block; everything after this will be
* overwritten at the next dump. Because of this, it needs to be
* reconstructable. We reconstruct the _conform.map and dump trees
- * from the header blocks in dump.c, and we reconstruct the path
+ * from the header blocks in dump.c, and we reconstruct the path
* tables by walking the cd.
*/
newnull = Cputdumpblock(cd);
dir.mode = 0444;
if(cd->flags & (CDconform|CDjoliet)) {
if(!mk9660 && cd->nconform == 0){
- block = cblock;
+ block = cblock;
length = clength;
}else
wrconform(cd, 0, &block, &length);
- if(mk9660)
+ if(mk9660)
{
idumproot = iroot;
jdumproot = jroot;
copybutname(r, &jroot);
}
}
-
+
writedumpdirs(cd, &idumproot, Cputisodir);
if(cd->flags & CDjoliet)
writedumpdirs(cd, &jdumproot, Cputjolietdir);
-
+
/*
* Patch in new root directory entry.
*/
setvolsize(cd, cd->jolietsvd, cd->nextblock*Blocksize);
}
}
- writepathtables(cd);
+ writepathtables(cd);
if(!mk9660){
/*
if(cd->nulldump && maxsize && Cwoffset(cd) > maxsize){
fprint(2, "too big; writing old tree back\n");
status = "cd too big; aborted";
-
+
rmdumpdir(&idumproot, dumpname);
rmdumpdir(&jdumproot, dumpname);
-
+
cd->nextblock = cd->nulldump+1;
cd->nulldump = 0;
Cwseek(cd, cd->nextblock*Blocksize);
goto Dofix;
}
-
+
/*
* Write old null header block; this commits all our changes.
*/
free(name);
}
-
blob - 3b2b5367faa608b691c1937cbec7fd02507291aa
blob + ef2944ce687473dbe2e363ecb2ab44d08ef552e3
--- src/cmd/9660/ichar.c
+++ src/cmd/9660/ichar.c
return q;
}
-int
+int
isisofrog(char c)
{
if(c >= '0' && c <= '9')
/*
* ISO9660 name comparison
- *
+ *
* The standard algorithm is as follows:
* Take the filenames without extensions, pad the shorter with 0x20s (spaces),
* and do strcmp. If they are equal, go on.
strcat(buf, "iso9660");
else
strcat(buf, "utf8");
-
+
struprcpy(buf, buf);
Cputs(cd, buf, 32);
blob - b5131a27c1cb2e566b7ebcce97f705c17cc27639
blob + c08b2caa7052e9d456536d08c69fa93507eeed39
--- src/cmd/9660/iso9660.h
+++ src/cmd/9660/iso9660.h
ulong mpathloc;
/* root of file tree */
- Direc root;
+ Direc root;
};
/*
ulong bootimageptr;
Direc *bootdirec;
char *bootimage;
-
+
Biobuf brd;
Biobuf bwr;
int Cputjolietdir(Cdimg*, Direc*, int, int, int);
void Cputendvd(Cdimg*);
-enum {
+enum {
Blocksize = 2048,
Ndirblock = 16, /* directory blocks allocated at once */
blob - ccd3b6db72f93b08ce6412bc5e834ceacf4786b5
blob + fbabf26d2575153ff464b77259694c684e6b3074
--- src/cmd/9660/jchar.c
+++ src/cmd/9660/jchar.c
}
/*
- * Joliet name validity check
- *
+ * Joliet name validity check
+ *
* Joliet names have length at most 128 bytes (64 runes),
* and cannot contain '*', '/', ':', ';', '?', or '\'.
*/
int
isjolietfrog(Rune r)
{
- return r=='*' || r=='/' || r==':'
+ return r=='*' || r=='/' || r==':'
|| r==';' || r=='?' || r=='\\';
}
* The standard algorithm is the ISO9660 algorithm but
* on the encoded Runes. Runes are encoded in big endian
* format, so we can just use runecmp.
- *
+ *
* Padding is with zeros, but that still doesn't affect us.
*/
Cputc(cd, 1); /* file structure version */
Cpadblock(cd);
}
-
blob - f2757dba93f6ec5f6f325d0491b8cb64ce546434
blob + effc44b189296e327c7664541ac18fc92e03b7fa
--- src/cmd/9660/path.c
+++ src/cmd/9660/path.c
* Add the requisite path tables to the CD image.
* They get put on the end once everything else is done.
* We use the path table itself as a queue in the breadth-first
- * traversal of the tree.
+ * traversal of the tree.
*
* The only problem with this is that the path table does not
* store the lengths of the directories. So we keep an explicit
blob - 3a436f4a320ad05a22b0a584832ab7d95f79d4f5
blob + 8b03f28232c96e989fcd42e3f9b4553ba95f3e93
--- src/cmd/9660/rune.c
+++ src/cmd/9660/rune.c
s++, t++;
return *s - *t;
}
-
blob - 78716524380f573a5f74436130ab7948f33d30ec
blob + 3039b3607fcf2bc99d3399a764d6923fecf4d2d7
--- src/cmd/9660/sysuse.c
+++ src/cmd/9660/sysuse.c
* Rock Ridge data is put into little blockettes, which can be
* at most 256 bytes including a one-byte length. Some number
* of blockettes get packed together into a normal 2048-byte block.
- * Blockettes cannot cross block boundaries.
+ * Blockettes cannot cross block boundaries.
*
- * A Cbuf is a blockette buffer. Len contains
+ * A Cbuf is a blockette buffer. Len contains
* the length of the buffer written so far, and we can
- * write up to 254-28.
+ * write up to 254-28.
*
* We only have one active Cbuf at a time; cdimg.rrcontin is the byte
* offset of the beginning of that Cbuf.
/*
* the current blockette is full; update cd->rrcontin and then
- * write a CE record to finish it. Unfortunately we need to
+ * write a CE record to finish it. Unfortunately we need to
* figure out which block will be next before we write the CE.
*/
end = Cwoffset(cd)+28;
return cn;
}
-
+
/*
* Put down the name, but we might need to break it
* into chunks so that each chunk fits in 254-28-5 bytes.
* What a crock.
*
- * The new Plan 9 format uses strings of this form too,
+ * The new Plan 9 format uses strings of this form too,
* since they're already there.
*/
Cbuf*
what |= RR_SL;
m = CputsuspRR(cd, what, 0);
- cp = ensurespace(cd, m, cp, &cn, dowrite);
+ cp = ensurespace(cd, m, cp, &cn, dowrite);
CputsuspRR(cd, what, dowrite);
if(what & RR_PX) {
/*
* Put down the symbolic link. This is even more of a crock.
- * Not only are the individual elements potentially split,
+ * Not only are the individual elements potentially split,
* but the whole path itself can be split across SL blocks.
* To keep the code simple as possible (really), we write
* only one element per SL block, wasting 6 bytes per element.
{
assert(cd!=0);
- if(dowrite) {
+ if(dowrite) {
chat("writing SUSP SP record\n");
Cputc(cd, 'S'); /* SP field marker */
Cputc(cd, 'P');
Cputc(cd, 'S'); /* ST field marker */
Cputc(cd, 'T');
Cputc(cd, 4); /* Length */
- Cputc(cd, 1); /* Version */
+ Cputc(cd, 1); /* Version */
}
return 4;
}
Cputc(cd, 'X');
Cputc(cd, 36); /* Length */
Cputc(cd, 1); /* Version */
-
+
Cputn(cd, mode(d, dot), 4); /* POSIX File mode */
Cputn(cd, nlink(d), 4); /* POSIX st_nlink */
Cputn(cd, d?d->uidno:0, 4); /* POSIX st_uid */
Cputc(cd, 5+7*length); /* Length */
Cputc(cd, 1); /* Version */
Cputc(cd, type); /* Flags (types) */
-
+
if (type & TFcreation)
Cputdate(cd, d?d->ctime:0);
if (type & TFmodify)
Cputdate(cd, d?d->atime:0);
if (type & TFattributes)
Cputdate(cd, d?d->ctime:0);
-
+
/* if (type & TFbackup) */
/* Cputdate(cd, 0); */
/* if (type & TFexpiration) */
mode(Direc *d, int dot)
{
long mode;
-
+
if (!d)
return 0;
mode = S_IFDIR | (0755);
mode &= POSIXMODEMASK;
-
+
/* Botch: not all POSIX types supported yet */
assert(mode & (S_IFDIR|S_IFREG));
-chat("writing PX record mode field %ulo with dot %d and name \"%s\"\n", mode, dot, d->name);
+chat("writing PX record mode field %ulo with dot %d and name \"%s\"\n", mode, dot, d->name);
- return mode;
+ return mode;
}
static long
return n;
}
-
blob - ebf944e2041452864aec725c656783aff39f4c6c
blob + d3182775ea6090516cdbc231e5dc196f9b868fa7
--- src/cmd/9660/util.c
+++ src/cmd/9660/util.c
{
uint h;
Stringtab *tab;
-
+
h = hash(str) % nelem(stab);
for(tab=stab[h]; tab; tab=tab->link)
if(strcmp(str, tab->str) == 0)
blob - 94405317625ff4d8cbad8d229e65a4ad469218d8
blob + 652927ca8accb26f599c9bdc2d481315d2f52493
--- src/cmd/9660/write.c
+++ src/cmd/9660/write.c
assert(start != 0);
Cwseek(cd, start*Blocksize);
-
+
s = md5(nil, 0, nil, nil);
length = 0;
while((n = Bread(b, buf, sizeof buf)) > 0) {
}
/*
- * Write a directory tree. We work from the leaves,
+ * Write a directory tree. We work from the leaves,
* and patch the dotdot pointers afterward.
*/
static void
blob - 01acd06aaaad92d47edeb889a6c393d956d8c5f1
blob + a0b934c091bc96765765245f1e39fbe181906602
--- src/cmd/9660srv/iobuf.c
+++ src/cmd/9660srv/iobuf.c
* tarring up a Plan 9 distribution CD, we now use 16 128kb
* buffers. This works for ISO9660 because data is required
* to be laid out contiguously; effectively we're doing agressive
- * readahead. Because the buffers are so big and the typical
+ * readahead. Because the buffers are so big and the typical
* disk accesses so concentrated, it's okay that we have so few
* of them.
*
blob - 44fdc5124c09996755f9d75d15955d01abc629e5
blob + d4c32b8f3c0ace5a37f1b97c8c4f1a015cfc3b51
--- src/cmd/9660srv/main.c
+++ src/cmd/9660srv/main.c
open("/dev/null", OWRITE);
if(pipe(pipefd) < 0)
panic(1, "pipe");
-
+
if(post9pservice(pipefd[0], srvname, mtpt) < 0)
sysfatal("post9pservice: %r");
close(pipefd[0]);
}
srvfd = pipefd[1];
-
+
switch(rfork(RFNOWAIT|RFNOTEG|RFFDG|RFPROC)){
case -1:
panic(1, "fork");
blob - c46adf21e82877b3c95176b611856bba830429d0
blob + bebf0986d65eec6d65abdd628e8d833d53d03468
--- src/cmd/9660srv/xfile.c
+++ src/cmd/9660srv/xfile.c
f->qid = (Qid){0,0,0};
return f;
}
-
blob - c8d4c4448dbdb2df59da335d267332641fe4c9b0
blob + 75511a1947480ad5cb0c2c0a626749e683fe5ea6
--- src/cmd/9p.c
+++ src/cmd/9p.c
threadexitsall(0);
}
}
- usage();
+ usage();
}
CFsys*
fsclose(fid);
if(n < 0)
sysfatal("read error: %r");
- threadexitsall(0);
+ threadexitsall(0);
}
void
sysfatal("write error: %r");
if(n < 0)
sysfatal("read error: %r");
- threadexitsall(0);
+ threadexitsall(0);
}
void
if(n < 0)
sysfatal("read error: %r");
fsclose(fid);
- threadexitsall(0);
+ threadexitsall(0);
}
void
sysfatal("write error: %r");
if(n < 0)
sysfatal("read error: %r");
- threadexitsall(0);
+ threadexitsall(0);
}
void
fprint(2, "write: %r\n");
}
fsclose(fid);
- threadexitsall(0);
+ threadexitsall(0);
}
void
default:
usage();
}ARGEND
-
+
if(argc == 0)
usage();
-
+
for(i=0; i<argc; i++){
fs = xparse(argv[i], &p);
if((fid=fscreate(fs, p, OREAD, 0666)) == nil)
default:
usage();
}ARGEND
-
+
if(argc == 0)
usage();
-
+
for(i=0; i<argc; i++){
fs = xparse(argv[i], &p);
if(fsremove(fs, p) < 0)
int n;
char buf[4096];
CFid *fid;
-
+
fid = v;
for(;;){
n = read(0, buf, sizeof buf);
char buf[4096], *r, *w, *e;
int n, nocr;
CFid *fid;
-
+
nocr = 1;
ARGBEGIN{
threadexitsall(0);
}
fsclose(fid);
- threadexitsall(0);
+ threadexitsall(0);
}
-static char *mon[] =
+static char *mon[] =
{
- "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
};
ulong u;
static ulong time0;
Tm *tm;
-
+
if(time0 == 0)
time0 = time(0);
u = va_arg(fmt->args, ulong);
dircmp(const void *va, const void *vb)
{
Dir *a, *b;
-
+
a = (Dir*)va;
b = (Dir*)vb;
return strcmp(a->name, b->name);
timecmp(const void *va, const void *vb)
{
Dir *a, *b;
-
+
a = (Dir*)va;
b = (Dir*)vb;
if(a->mtime < b->mtime)
tflag = 1;
break;
}ARGEND
-
+
fmtinstall('D', dirfmt);
fmtinstall('M', dirmodefmt);
quotefmtinstall();
fmtinstall('T', timefmt);
-
+
if(argc == 0){
argv = dot;
argc = 1;
}
threadexitsall(err);
}
-
blob - e03d9589a0d30491dc0a506a38c9deff23641278
blob + e3a122e4cb8d42586a0f714f1ecc543badd7af4c
--- src/cmd/9pfuse/errstr.c
+++ src/cmd/9pfuse/errstr.c
{
char e[ERRMAX];
int i, len;
-
+
if(errno != EPLAN9)
return errno;
return errortab[i].err;
return ERANGE; /* who knows - be blatantly wrong */
}
-
blob - 66f66065dfabd0fff17977956736d28e70684ba7
blob + 4c9aac9bf9b6d7711ce4862f94cd1fb4363366be
--- src/cmd/9pfuse/fuse.c
+++ src/cmd/9pfuse/fuse.c
{
FuseMsg *m;
void *vbuf;
-
+
lock(&fusemsglock);
if((m = fusemsglist) != nil){
fusemsglist = m->next;
{
FuseMsg *m;
int n, nn;
-
+
m = allocfusemsg();
/*
* The FUSE kernel device apparently guarantees
sysfatal("readfusemsg: got %d wanted %d",
n, m->hdr->len);
m->hdr->len -= sizeof(*m->hdr);
-
+
/*
* Paranoia.
* Make sure lengths are long enough.
if(((char*)m->tx)[m->hdr->len-1] != 0
|| memchr(m->tx, 0, m->hdr->len-1) == 0)
goto bad;
- break;
+ break;
case FUSE_MKNOD:
if(m->hdr->len <= sizeof(struct fuse_mknod_in)
|| ((char*)m->tx)[m->hdr->len-1] != 0)
}
/*
- * Reply to FUSE request m using additonal
+ * Reply to FUSE request m using additonal
* argument buffer arg of size narg bytes.
* Perhaps should free the FuseMsg here?
*/
struct iovec vec[2];
struct fuse_out_header hdr;
int nvec;
-
+
hdr.len = sizeof hdr + narg;
hdr.error = 0;
hdr.unique = m->hdr->unique;
replyfuseerrno(FuseMsg *m, int e)
{
struct fuse_out_header hdr;
-
+
hdr.len = sizeof hdr;
hdr.error = -e; /* FUSE sends negative errnos. */
hdr.unique = m->hdr->unique;
/*
* Complain if the kernel is too new.
* We could forge ahead, but at least the one time I tried,
- * the kernel rejected the newer version by making the
+ * the kernel rejected the newer version by making the
* writev fail in replyfuse, which is a much more confusing
- * error message. In the future, might be nice to try to
+ * error message. In the future, might be nice to try to
* support older versions that differ only slightly.
*/
- if(tx->major < FUSE_KERNEL_VERSION
+ if(tx->major < FUSE_KERNEL_VERSION
|| (tx->major == FUSE_KERNEL_VERSION && tx->minor < FUSE_KERNEL_MINOR_VERSION))
sysfatal("fuse: too kernel version %d.%d older than program version %d.%d",
tx->major, tx->minor, FUSE_KERNEL_VERSION, FUSE_KERNEL_MINOR_VERSION);
}
case FUSE_SYMLINK: {
char *old, *new;
-
+
old = a;
new = a + strlen(a) + 1;
fmtprint(fmt, "Symlink nodeid %#llux old %#q new %#q",
case FUSE_RELEASE: {
struct fuse_release_in *tx = a;
fmtprint(fmt, "Release nodeid %#llux fh %#llux flags %#ux",
- hdr->nodeid, tx->fh, tx->flags);
+ hdr->nodeid, tx->fh, tx->flags);
break;
}
case FUSE_FSYNC: {
case FUSE_RELEASEDIR: {
struct fuse_release_in *tx = a;
fmtprint(fmt, "Releasedir nodeid %#llux fh %#llux flags %#ux",
- hdr->nodeid, tx->fh, tx->flags);
+ hdr->nodeid, tx->fh, tx->flags);
break;
}
case FUSE_FSYNCDIR: {
case FUSE_LOOKUP: {
/*
* For a negative entry, can send back ENOENT
- * or rx->ino == 0.
+ * or rx->ino == 0.
* In protocol version 7.4 and before, can only use
* the ENOENT method.
* Presumably the benefit of sending rx->ino == 0
rx->attr_valid+rx->attr_valid_nsec*1e-9);
fmtprint(fmt, " ino %#llux size %lld blocks %lld atime %.20g mtime %.20g ctime %.20g mode %#uo nlink %d uid %d gid %d rdev %#ux",
rx->attr.ino, rx->attr.size, rx->attr.blocks,
- rx->attr.atime+rx->attr.atimensec*1e-9,
+ rx->attr.atime+rx->attr.atimensec*1e-9,
rx->attr.mtime+rx->attr.mtimensec*1e-9,
rx->attr.ctime+rx->attr.ctimensec*1e-9,
rx->attr.mode, rx->attr.nlink, rx->attr.uid,
rx->attr_valid+rx->attr_valid_nsec*1e-9);
fmtprint(fmt, " ino %#llux size %lld blocks %lld atime %.20g mtime %.20g ctime %.20g mode %#uo nlink %d uid %d gid %d rdev %#ux",
rx->attr.ino, rx->attr.size, rx->attr.blocks,
- rx->attr.atime+rx->attr.atimensec*1e-9,
+ rx->attr.atime+rx->attr.atimensec*1e-9,
rx->attr.mtime+rx->attr.mtimensec*1e-9,
rx->attr.ctime+rx->attr.ctimensec*1e-9,
rx->attr.mode, rx->attr.nlink, rx->attr.uid,
rx->e.attr_valid+rx->e.attr_valid_nsec*1e-9);
fmtprint(fmt, " ino %#llux size %lld blocks %lld atime %.20g mtime %.20g ctime %.20g mode %#uo nlink %d uid %d gid %d rdev %#ux",
rx->e.attr.ino, rx->e.attr.size, rx->e.attr.blocks,
- rx->e.attr.atime+rx->e.attr.atimensec*1e-9,
+ rx->e.attr.atime+rx->e.attr.atimensec*1e-9,
rx->e.attr.mtime+rx->e.attr.mtimensec*1e-9,
rx->e.attr.ctime+rx->e.attr.ctimensec*1e-9,
rx->e.attr.mode, rx->e.attr.nlink, rx->e.attr.uid,
/*
* Mounts a fuse file system on mtpt and returns
- * a file descriptor for the corresponding fuse
+ * a file descriptor for the corresponding fuse
* message conversation.
*/
int
#if defined(__linux__)
int p[2], pid, fd;
char buf[20];
-
+
if(socketpair(AF_UNIX, SOCK_STREAM, 0, p) < 0)
return -1;
pid = fork();
#elif defined(__FreeBSD__) && !defined(__APPLE__)
int pid, fd;
char buf[20];
-
+
if((fd = open("/dev/fuse", ORDWR)) < 0)
return -1;
snprint(buf, sizeof buf, "%d", fd);
-
+
pid = fork();
if(pid < 0)
return -1;
_exit(1);
}
return fd;
-
+
#else
werrstr("cannot mount fuse on this system");
return -1;
blob - a36628988b52998c727ffaa5a181715baf6dc827
blob + 0d4adb08cc1f059f2b85ba81e32a2c35439f7b7b
--- src/cmd/9pfuse/main.c
+++ src/cmd/9pfuse/main.c
* writing the 9P connection. Thus the many threads in the
* request proc can do 9P interactions without blocking.
*/
-
+
#define _GNU_SOURCE 1 /* for O_DIRECTORY on Linux */
#include "a.h"
/*
* FUSE uses nodeids to refer to active "struct inodes"
* (9P's unopened fids). FUSE uses fhs to refer to active
- * "struct fuse_files" (9P's opened fids). The choice of
+ * "struct fuse_files" (9P's opened fids). The choice of
* numbers is up to us except that nodeid 1 is the root directory.
- * We use the same number space for both and call the
+ * We use the same number space for both and call the
* bookkeeping structure a FuseFid.
*
- * FUSE requires nodeids to have associated generation
- * numbers. If we reuse a nodeid, we have to bump the
+ * FUSE requires nodeids to have associated generation
+ * numbers. If we reuse a nodeid, we have to bump the
* generation number to guarantee that the nodeid,gen
* combination is never reused.
- *
+ *
* There are also inode numbers returned in directory reads
* and file attributes, but these do NOT need to match the nodeids.
* We use a combination of qid.path and qid.type as the inode
int id;
int gen;
int isnodeid;
-
+
/* directory read state */
Dir *d0;
Dir *d;
allocfusefid(void)
{
Fusefid *f;
-
+
if((f = freefusefidlist) == nil){
f = emalloc(sizeof *f);
fusefid = erealloc(fusefid, (nfusefid+1)*sizeof *fusefid);
_alloc(CFid *fid, int isnodeid)
{
Fusefid *ff;
-
+
ff = allocfusefid();
ff->fid = fid;
ff->isnodeid = isnodeid;
_lookupcfid(uvlong id, int isnodeid)
{
Fusefid *ff;
-
+
if((ff = lookupfusefid(id, isnodeid)) == nil)
return nil;
return ff->fid;
CFid *fid, *newfid;
Dir *d;
struct fuse_entry_out out;
-
+
name = m->tx;
if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
replyfuseerrno(m, ESTALE);
/*
* Forget. Reference-counted clunk for nodeids.
* Does not send a reply.
- * Each lookup response gives the kernel an additional reference
+ * Each lookup response gives the kernel an additional reference
* to the returned nodeid. Forget says "drop this many references
* to this nodeid". Our fuselookup, when presented with the same query,
* does not return the same results (it allocates a new nodeid for each
* Getattr.
* Replies with a fuse_attr_out structure giving the
* attr for the requested nodeid in out.attr.
- * Out.attr_valid and out.attr_valid_nsec give
+ * Out.attr_valid and out.attr_valid_nsec give
* the amount of time that the attributes can
* be cached.
*
/*
* Special case: Linux issues a size change to
* truncate a file before opening it OTRUNC.
- * Synthetic file servers (e.g., plumber) honor
+ * Synthetic file servers (e.g., plumber) honor
* open(OTRUNC) but not wstat.
*/
if(in->valid == FATTR_SIZE && in->size == 0){
*err = errstr2errno();
return nil;
}
-
+
if(fsfopen(newfid, openmode) < 0){
*err = errstr2errno();
fsclose(newfid);
return;
}
out.fh = allocfh(fid);
- out.open_flags = FOPEN_DIRECT_IO; /* no page cache */
+ out.open_flags = FOPEN_DIRECT_IO; /* no page cache */
replyfuse(m, &out, sizeof out);
}
CFid *fid;
int err;
char *name;
-
+
in = m->tx;
name = (char*)(in+1);
if((fid = _fusecreate(m->hdr->nodeid, name, in->mode, 1, OREAD, &out, &err)) == nil){
CFid *fid;
int err, openmode, flags;
char *name;
-
+
in = m->tx;
flags = in->flags;
openmode = in->flags&3;
}
/*
- * Access.
+ * Access.
* Lib9pclient implements this just as Plan 9 does,
* by opening the file (or not) and then closing it.
*/
ORDWR,
ORDWR
};
-
+
in = m->tx;
if(in->mask >= nelem(a2o)){
replyfuseerrno(m, EINVAL);
{
struct fuse_release_in *in;
Fusefid *ff;
-
+
in = m->tx;
if((ff = lookupfusefid(in->fh, 0)) != nil)
freefusefid(ff);
return;
}
-/*
+/*
* Readdir.
* Read from file handle in->fh at offset in->offset for size in->size.
* We truncate size to maxwrite just to keep the buffer reasonable.
uchar *buf, *p, *ep;
int n;
Fusefid *ff;
-
+
in = m->tx;
if((ff = lookupfusefid(in->fh, 0)) == nil){
replyfuseerrno(m, ESTALE);
return;
- }
+ }
if(in->offset == 0){
fsseek(ff->fid, 0, 0);
free(ff->d0);
break;
ff->d = ff->d0;
}
-out:
+out:
replyfuse(m, buf, p - buf);
free(buf);
}
uchar *p;
struct fuse_dirent *de;
int pad, size;
-
+
p = *pp;
size = FUSE_NAME_OFFSET + strlen(d->name);
pad = 0;
* Write.
* Write from file handle in->fh at offset in->offset for size in->size.
* Don't know what in->write_flags means.
- *
+ *
* Apparently implementations are allowed to buffer these writes
* and wait until Flush is sent, but FUSE docs say flush may be
* called zero, one, or even more times per close. So better do the
void *a;
CFid *fid;
int n;
-
+
in = m->tx;
a = in+1;
if((fid = fh2fid(in->fh)) == nil){
/*
* Flush. Supposed to flush any buffered writes. Don't use this.
- *
+ *
* Flush is a total crock. It gets called on close() of a file descriptor
* associated with this open file. Some open files have multiple file
* descriptors and thus multiple closes of those file descriptors.
* closed explicitly. For those files, Flush is never called.
* Even more amusing, Flush gets called before close() of read-only
* file descriptors too!
- *
+ *
* This is just a bad idea.
*/
void
{
char *name;
CFid *fid, *newfid;
-
+
name = m->tx;
if((fid = nodeid2fid(m->hdr->nodeid)) == nil){
replyfuseerrno(m, ESTALE);
char *before, *after;
CFid *fid, *newfid;
Dir d;
-
+
in = m->tx;
if(in->newdir != m->hdr->nodeid){
replyfuseerrno(m, EXDEV);
struct fuse_fsync_in *in;
CFid *fid;
Dir d;
-
+
in = m->tx;
if((fid = fh2fid(in->fh)) == nil){
replyfuseerrno(m, ESTALE);
fusestatfs(FuseMsg *m)
{
struct fuse_statfs_out out;
-
+
memset(&out, 0, sizeof out);
replyfuse(m, &out, sizeof out);
}
{ FUSE_FSYNC, fusefsync },
/*
* FUSE_SETXATTR, FUSE_GETXATTR, FUSE_LISTXATTR, and
- * FUSE_REMOVEXATTR are unimplemented.
+ * FUSE_REMOVEXATTR are unimplemented.
* FUSE will stop sending these requests after getting
* an -ENOSYS reply (see dispatch below).
*/
FuseMsg *m;
m = v;
- if((uint)m->hdr->opcode >= nelem(fusehandlers)
+ if((uint)m->hdr->opcode >= nelem(fusehandlers)
|| !fusehandlers[m->hdr->opcode]){
replyfuseerrno(m, ENOSYS);
return;
case FUSE_FORGET:
fusehandlers[m->hdr->opcode](m);
break;
- default:
+ default:
threadcreate(fusethread, m, STACK);
}
}
blob - 24c80714824265e454d619695723c8be7e0a12ea
blob + 255bcbb25244b6276cc3f973f1d084947f765e7b
--- src/cmd/9pserve.c
+++ src/cmd/9pserve.c
logging++;
break;
}ARGEND
-
+
if(attached && !versioned){
fprint(2, "-A must be used with -M\n");
usage();
/* if(rootfid) */
/* dorootstat(); */
-
+
threadcreate(listenthread, nil, STACK);
threadexits(0);
}
c->outqdead = chancreate(sizeof(void*), 0);
if(verbose) fprint(2, "%T incoming call on %s\n", c->dir);
threadcreate(connthread, c, STACK);
- }
+ }
}
void
estrdup(char *s)
{
char *t;
-
+
t = emalloc(strlen(s)+1);
strcpy(t, s);
return t;
chanfree(c->internal);
c->internal = 0;
free(c);
-}
+}
int
xopenfd(Msg *m)
closeioproc(io);
fprint(2, "%T output eof\n");
threadexitsall(0);
-}
+}
void
inputthread(void *arg)
* Clear data associated with connections, so that
* if all msgs have been msgcleared, the connection
* can be freed. Note that this does *not* free the tpkt
- * and rpkt; they are freed in msgput with the msg itself.
+ * and rpkt; they are freed in msgput with the msg itself.
* The io write thread might still be holding a ref to msg
* even once the connection has finished with it.
*/
if(m == nil)
return;
- if(verbose > 1) fprint(2, "%T msgput 0x%lux %p tag %d/%d ref %d\n",
+ if(verbose > 1) fprint(2, "%T msgput 0x%lux %p tag %d/%d ref %d\n",
getcallerpc(&m), m, m->tag, m->ctag, m->ref);
assert(m->ref > 0);
if(--m->ref > 0)
{
uint n, nn;
uchar *pkt;
-
+
pkt = *ppkt;
n = GBIT32(pkt);
nn = sizeS2M(f);
pkt = emalloc(nn);
*ppkt = pkt;
}
- n = convS2M(f, pkt, nn);
+ n = convS2M(f, pkt, nn);
if(n <= BIT16SZ)
sysfatal("convS2M conversion error");
if(n != nn)
int
timefmt(Fmt *fmt)
{
- static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
vlong ns;
Tm tm;
ns = nsec();
tm = *localtime(time(0));
- return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
+ return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}
blob - 81c39a6354f18e713972037b850d8ac5c4dceda3
blob + b28f44fafe085c246ec5798d591cac87005f1df6
--- src/cmd/9term/9term.c
+++ src/cmd/9term/9term.c
threadmain(int argc, char *argv[])
{
char *p;
-
+
rfork(RFNOTEG);
font = nil;
_wantfocuschanges = 1;
mainpid = getpid();
messagesize = 8192;
-
+
ARGBEGIN{
default:
usage();
winsize = EARGF(usage());
break;
}ARGEND
-
+
if(fontname)
putenv("font", fontname);
if(maxtab <= 0)
maxtab = 4;
free(p);
-
+
startdir = ".";
if(initdraw(derror, fontname, "9term") < 0)
notify(hangupnote);
noteenable("sys: child");
-
+
mousectl = initmouse(nil, screen);
if(mousectl == nil)
error("cannot find mouse");
resizethread(void *v)
{
Point p;
-
+
USED(v);
-
+
for(;;){
p = stringsize(display->defaultfont, "0");
if(p.x && p.y)
- updatewinsize(Dy(screen->r)/p.y, (Dx(screen->r)-Scrollwid-2)/p.x,
+ updatewinsize(Dy(screen->r)/p.y, (Dx(screen->r)-Scrollwid-2)/p.x,
Dx(screen->r), Dy(screen->r));
wresize(w, screen, 0);
flushimage(display, 1);
sysfatal("can't reattach to window");
}
}
-
+
void
mousethread(void *v)
{
bouncemouse(mouse);
}
}
-
+
void
wborder(Window *w, int type)
{
Conswritemesg cwm;
Rune *r;
Stringpair pair;
-
+
i = 0;
cnt = 0;
for(;;){
if(nb < cnt)
memmove(data, data+nb, cnt-nb);
cnt -= nb;
-
+
nr = label(r, nr);
if(nr == 0)
continue;
-
+
recv(w->conswrite, &cwm);
pair.s = r;
pair.ns = nr;
winterrupt(Window *w)
{
char rubout[1];
-
+
USED(w);
rubout[0] = getintr(sfd);
write(rcfd, rubout, 1);
{
Rune *sl, *el, *er, *r;
char *p, *dir;
-
+
er = sr+n;
for(r=er-1; r>=sr; r--)
if(*r == '\007')
recv(w->consread, &crm);
c1 = crm.c1;
c2 = crm.c2;
-
+
pair.s = data;
pair.ns = sizeof data;
send(c1, &pair);
rioputsnarf(void)
{
char *s;
-
+
s = smprint("%.*S", nsnarf, snarf);
if(s){
putsnarf(s);
for(x=0; x<p-buf; x+=n)
if((n = write(fd, buf+x, (p-x)-buf)) <= 0)
goto break2;
-
+
if(i >= end)
break;
p = buf;
break2:
close(fd);
}
-
blob - e0f866ab51f93d0754fbd725e2183a74e44e546a
blob + 73914a674b411e8587bcfd38035168b860aae3fb
--- src/cmd/9term/SunOS.c
+++ src/cmd/9term/SunOS.c
return 0x7F;
return ttmode.c_cc[VINTR];
}
-
blob - 31281325a02b527bd542bb7161f0da85fc57dd87
blob + d64e4c2fcb9a88d397890adf5e9336e14ada2a83
--- src/cmd/9term/bsdpty.c
+++ src/cmd/9term/bsdpty.c
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
"0123456789";
-static char *_123 =
+static char *_123 =
"0123456789"
"abcdefghijklmnopqrstuvwxyz"
"ABCDEFGHIJKLMNOPQRSTUVWXYZ";
return 0x7F;
return ttmode.c_cc[VINTR];
}
-
blob - 25270a0e38f32451a80d32f93e6cc149c3986c14
blob + a215253fb55fb2619b271c1a38a5262d6cbd8270
--- src/cmd/9term/dat.h
+++ src/cmd/9term/dat.h
ulong counter; /* serial no. of last mouse event we received */
ulong lastcounter; /* serial no. of last mouse event sent to client */
int lastb; /* last button state we received */
- uchar qfull; /* filled the queue; no more recording until client comes back */
-};
+ uchar qfull; /* filled the queue; no more recording until client comes back */
+};
struct Window
{
blob - e0f18e873b2ac0397adf7e7189ff92f86767b5f3
blob + 4c2a76020c1e53e8d4224679f3797cf64b086ca8
--- src/cmd/9term/data.c
+++ src/cmd/9term/data.c
Cursor whitearrow = {
{0, 0},
- {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
- 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,
- 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
+ {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
+ 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,
+ 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, },
- {0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,
- 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,
- 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,
+ {0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,
+ 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,
+ 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,
0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }
};
Cursor query = {
{-7,-7},
- {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
- 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
- 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
+ {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
+ 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
+ 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
- {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
- 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
- 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
+ {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
+ 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
+ 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
};
Cursor tl = {
{-4, -4},
- {0xfe, 0x00, 0x82, 0x00, 0x8c, 0x00, 0x87, 0xff,
- 0xa0, 0x01, 0xb0, 0x01, 0xd0, 0x01, 0x11, 0xff,
- 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ {0xfe, 0x00, 0x82, 0x00, 0x8c, 0x00, 0x87, 0xff,
+ 0xa0, 0x01, 0xb0, 0x01, 0xd0, 0x01, 0x11, 0xff,
+ 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x1f, 0x00, },
- {0x00, 0x00, 0x7c, 0x00, 0x70, 0x00, 0x78, 0x00,
- 0x5f, 0xfe, 0x4f, 0xfe, 0x0f, 0xfe, 0x0e, 0x00,
- 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ {0x00, 0x00, 0x7c, 0x00, 0x70, 0x00, 0x78, 0x00,
+ 0x5f, 0xfe, 0x4f, 0xfe, 0x0f, 0xfe, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x00, 0x00, }
};
Cursor t = {
{-7, -8},
- {0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x06, 0xc0,
- 0x1c, 0x70, 0x10, 0x10, 0x0c, 0x60, 0xfc, 0x7f,
- 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xff, 0xff,
+ {0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x06, 0xc0,
+ 0x1c, 0x70, 0x10, 0x10, 0x0c, 0x60, 0xfc, 0x7f,
+ 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
- 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80,
- 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+ 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80,
+ 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};
Cursor tr = {
{-11, -4},
- {0x00, 0x7f, 0x00, 0x41, 0x00, 0x31, 0xff, 0xe1,
- 0x80, 0x05, 0x80, 0x0d, 0x80, 0x0b, 0xff, 0x88,
- 0x00, 0x88, 0x0, 0x88, 0x00, 0x88, 0x00, 0x88,
+ {0x00, 0x7f, 0x00, 0x41, 0x00, 0x31, 0xff, 0xe1,
+ 0x80, 0x05, 0x80, 0x0d, 0x80, 0x0b, 0xff, 0x88,
+ 0x00, 0x88, 0x0, 0x88, 0x00, 0x88, 0x00, 0x88,
0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xf8, },
- {0x00, 0x00, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x1e,
- 0x7f, 0xfa, 0x7f, 0xf2, 0x7f, 0xf0, 0x00, 0x70,
- 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ {0x00, 0x00, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x1e,
+ 0x7f, 0xfa, 0x7f, 0xf2, 0x7f, 0xf0, 0x00, 0x70,
+ 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, }
};
Cursor r = {
{-8, -7},
- {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58,
- 0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02,
- 0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58,
+ {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58,
+ 0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02,
+ 0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58,
0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x07, 0xc0, },
- {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
- 0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc,
- 0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80,
+ {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
+ 0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc,
+ 0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80,
0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
};
Cursor br = {
{-11, -11},
- {0x00, 0xf8, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
- 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
- 0xff, 0x88, 0x80, 0x0b, 0x80, 0x0d, 0x80, 0x05,
+ {0x00, 0xf8, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
+ 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
+ 0xff, 0x88, 0x80, 0x0b, 0x80, 0x0d, 0x80, 0x05,
0xff, 0xe1, 0x00, 0x31, 0x00, 0x41, 0x00, 0x7f, },
- {0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
- 0x0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
- 0x00, 0x70, 0x7f, 0xf0, 0x7f, 0xf2, 0x7f, 0xfa,
+ {0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ 0x0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ 0x00, 0x70, 0x7f, 0xf0, 0x7f, 0xf2, 0x7f, 0xfa,
0x00, 0x1e, 0x00, 0x0e, 0x00, 0x3e, 0x00, 0x00, }
};
Cursor b = {
{-7, -7},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
- 0xfc, 0x7f, 0x0c, 0x60, 0x10, 0x10, 0x1c, 0x70,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+ 0xfc, 0x7f, 0x0c, 0x60, 0x10, 0x10, 0x1c, 0x70,
0x06, 0xc0, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, },
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe,
- 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe,
+ 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};
Cursor bl = {
{-4, -11},
- {0x1f, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
- 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
- 0x11, 0xff, 0xd0, 0x01, 0xb0, 0x01, 0xa0, 0x01,
+ {0x1f, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ 0x11, 0xff, 0xd0, 0x01, 0xb0, 0x01, 0xa0, 0x01,
0x87, 0xff, 0x8c, 0x00, 0x82, 0x00, 0xfe, 0x00, },
- {0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
- 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
- 0x0e, 0x00, 0x0f, 0xfe, 0x4f, 0xfe, 0x5f, 0xfe,
+ {0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0f, 0xfe, 0x4f, 0xfe, 0x5f, 0xfe,
0x78, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x00, 0x0, }
};
Cursor l = {
{-7, -7},
- {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20,
- 0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20,
- 0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20,
+ {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20,
+ 0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20,
+ 0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20,
0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x03, 0xe0, },
- {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
- 0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0,
- 0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0,
+ {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
+ 0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0,
+ 0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0,
0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x00, 0x00, }
};
blob - 34cebf01e3ef0925962c04067bcd124a6123815a
blob + fd0bd74a3001dc74ed4264046f0368d483686196
--- src/cmd/9term/fns.h
+++ src/cmd/9term/fns.h
void rioputsnarf(void);
void riogetsnarf(void);
-
blob - 130942bdc38851ebb5305223c40ef6f374d1e943
blob + 9132235b3419d7be512670cb6002f865119f72e7
--- src/cmd/9term/malloc.c
+++ src/cmd/9term/malloc.c
p9malloc(ulong n)
{
void *v;
-
+
if(n == 0)
n++;
lock(&malloclock);
p9calloc(ulong a, ulong b)
{
void *v;
-
+
if(a*b == 0)
a = b = 1;
p9realloc(void *v, ulong n)
{
void *vv;
-
+
lock(&malloclock);
vv = realloc(v, n);
unlock(&malloclock);
print("p9realloc %p %lud => %p; pc %lux\n", v, n, vv, getcallerpc(&v));
return vv;
}
-
blob - fddabc6de49f3abe35d2c6b1a7e949230de150d8
blob + a447036d425adb872b81a77f1a10f5cafdd5600e
--- src/cmd/9term/rcstart.c
+++ src/cmd/9term/rcstart.c
}
/*
* notedisable("sys: window size change");
- *
+ *
* Can't disable because will be inherited by other programs
* like if you run an xterm from the prompt, and then xterm's
- * resizes won't get handled right. Sigh.
+ * resizes won't get handled right. Sigh.
*
* Can't not disable because when we stty below we'll get a
* signal, which will drop us into the thread library note handler,
* which will get all confused because we just forked and thus
- * have an unknown pid.
+ * have an unknown pid.
*
* So disable it internally. ARGH!
*/
if(echo.w+n > sizeof echo.buf)
n = 0;
memmove(echo.buf+echo.w, p, n);
- echo.w += n;
+ echo.w += n;
unlock(&echo.l);
}
blob - 8a35d1d75625c85dde4f582adc68297cb300d940
blob + 32ea08b6290e948d5c798934aa0132be2451412d
--- src/cmd/9term/util.c
+++ src/cmd/9term/util.c
*ip = m;
return s;
}
-
blob - 017d546b47475f45cee0d694a55734cceaff6bb1
blob + 9c7a12eb617c81a242654fad32736071e1e93223
--- src/cmd/9term/win.c
+++ src/cmd/9term/win.c
char buf1[128];
CFsys *fs;
char *dump;
-
+
dump = onestring(argc, argv);
ARGBEGIN{
fswrite(ctlfd, buf, strlen(buf));
sprint(buf, "scroll");
fswrite(ctlfd, buf, strlen(buf));
-
+
updatewinsize(25, 80, 0, 0);
proccreate(stdoutproc, nil, STACK);
stdinproc(nil);
error(char *s, ...)
{
va_list arg;
-
+
if(s){
va_start(arg, s);
s = vsmprint(s, arg);
fprint(2, "shift typing %d... ", e.q1-e.q0);
q.p += e.q1-e.q0;
break;
-
+
case 'i':
case 'd': /* tag */
break;
-
+
default:
goto Unknown;
}
{
int i;
char *w, *r, *q;
-
+
r = p;
w = p;
for(i=0; i<n; i++) {
n = read(fd1, buf+npart, 8192);
if(n <= 0)
error(nil);
-
+
n = echocancel(buf+npart, n);
if(n == 0)
continue;
-
+
n = dropcrnl(buf+npart, n);
if(n == 0)
continue;
-
+
n = dropcr(buf+npart, n);
if(n == 0)
continue;
buf[n] = 0;
n = label(buf, n);
buf[n] = 0;
-
+
// clumsy but effective: notice password
// prompts so we can disable echo.
password = 0;
if(cistrstr(buf, "password") || cistrstr(buf, "passphrase")) {
int i;
-
+
i = n;
while(i > 0 && buf[i-1] == ' ')
i--;
sendtype(int fd0)
{
int i, n, nr, raw;
-
+
raw = israw(fd0);
while(ntypebreak || (raw && ntypeb > 0)){
for(i=0; i<ntypeb; i++)
blob - d47e84674c6e3b28ac53d6cbd0cf66ccc596e365
blob + 7993930da0fa131895a0c208456c541404b33261
--- src/cmd/9term/wind.c
+++ src/cmd/9term/wind.c
{
int i, n;
char err[ERRMAX];
-
+
n = sprint(w->name, "window.%d.%d", w->id, w->namecount++);
for(i='A'; i<='Z'; i++){
if(nameimage(w->i, w->name, 1) > 0)
crm.c2 = chancreate(sizeof(Stringpair), 0);
cwrm.c1 = chancreate(sizeof(Stringpair), 0);
cwrm.c2 = chancreate(sizeof(Stringpair), 0);
-
+
alts[WKey].c = w->ck;
alts[WKey].v = &kbdr;
alts[WKey].op = CHANRCV;
if(r == '\n'){ /* eat at most one more character */
if(q == w->q0 && c != '\r') /* eat the newline */
--q;
- break;
+ break;
}
if(c == 0x17){
eq = isalnum(r);
}
}
-static Rune left1[] = {
+static Rune left1[] = {
'{', '[', '(', '<', 0xAB,
- 0x207d, 0x2329, 0x27e6, 0x27e8, 0x27ea,
- 0xfe59, 0xfe5b, 0xfe5d, 0xff08, 0xff3b, 0xff5b,
+ 0x207d, 0x2329, 0x27e6, 0x27e8, 0x27ea,
+ 0xfe59, 0xfe5b, 0xfe5d, 0xff08, 0xff3b, 0xff5b,
0
};
static Rune right1[] = {
'}', ']', ')', '>', 0xBB,
- 0x207e, 0x232a, 0x27e7, 0x27e9, 0x27eb,
+ 0x207e, 0x232a, 0x27e7, 0x27e9, 0x27eb,
0xfe5a, 0xfe5c, 0xfe5e, 0xff09, 0xff3d, 0xff5d,
0
};
blob - ddc326a48d4adb19655b6fe0bfc615f7719d1507
blob + be387abeb9428378c80351743f46db55230b2ded
--- src/cmd/acid/builtin.c
+++ src/cmd/acid/builtin.c
if(pipe(pip) < 0)
error("pipe: %r");
-
+
pid = fork();
switch(pid) {
case -1:
close(pip[1]);
pushfd(pip[0]);
-
+
isave = interactive;
interactive = 0;
r->store.u.ival = yyparse();
r->op = OCONST;
r->type = TINT;
r->store.fmt = 'D';
- r->store.u.ival = 0;
+ r->store.u.ival = 0;
if(access(res.store.u.string->string, 4) == 0)
r->store.u.ival = 1;
}
i = findseg(m, nam, fil);
}
if(i < 0)
- error("%s %s is not a map entry", nam, fil);
+ error("%s %s is not a map entry", nam, fil);
l = l->next;
if(l->type != TINT)
error("map entry not int");
}
}
-void
+void
flatten(Node **av, Node *n)
{
if(n == 0)
l = l->next;
}
regs.rw = straceregrw;
-
+
tracelist = 0;
if(stacktrace(cormap, ®s, trlist) <= 0)
error("no stack frame");
if(p == 0)
error("pcfile(addr): funny file %s", buf);
*p = '\0';
- r->store.u.string = strnode(buf);
+ r->store.u.string = strnode(buf);
}
void
p = strrchr(buf, ':');
if(p == 0)
error("pcline(addr): funny file %s", buf);
- r->store.u.ival = atoi(p+1);
+ r->store.u.ival = atoi(p+1);
}
void
blob - fd4464925fe97f71580cad20c6ec2af881a8ab4e
blob + 80ec2d020ba73f393959e7c11ac52d8890099709
--- src/cmd/acid/dot.c
+++ src/cmd/acid/dot.c
error("no tag for (expr).%s", s);
/* Propagate types */
- if(t->type)
+ if(t->type)
r->store.comt = t->type->lt;
-
+
addr = res.store.u.ival+t->offset;
if(t->fmt == 'a') {
r->op = OCONST;
r->type = TINT;
r->store.u.ival = addr;
}
- else
+ else
indir(cormap, addr, t->fmt, r);
}
switch(m->op) {
case OLIST:
- buildtype(m->left, d);
+ buildtype(m->left, d);
buildtype(m->right, d);
break;
t->offset = m->store.u.ival;
if(m->left) {
t->type = m->left->sym;
- t->fmt = 'a';
+ t->fmt = 'a';
}
else {
t->type = 0;
*tail = t;
tail = &t->next;
- }
+ }
}
void
blob - 088b98f848935ad3ee0848bcd89e4d3f25a5fcb2
blob + dc2f59c7691abe93592b8332f10a98ea4b327832
--- src/cmd/acid/expr.c
+++ src/cmd/acid/expr.c
if(lp->op == OCALL){
s = chklval(lp->left);
- if(strcmp(s->name, "var") == 0
+ if(strcmp(s->name, "var") == 0
&& (lp->builtin || s->proc == 0)){
if(lp->right == 0)
error("var(string): arg count");
}
}
error("need l-value");
- return nil;
+ return nil;
}
void
lp = n->left;
if(localaddr(cormap, acidregs, p, lp->sym->name, &ival) < 0)
error("colon: %r");
-
+
res->store.u.ival = ival;
res->op = OCONST;
res->store.fmt = 'X';
if(r.type == TSTRING) {
res->type = TSTRING;
res->store.fmt = 's';
- res->store.u.string = stradd(l.store.u.string, r.store.u.string);
+ res->store.u.string = stradd(l.store.u.string, r.store.u.string);
break;
}
error("bad rhs for +");
v->store.u.ival -= fmtsize(v);
else
v->store.u.ival += fmtsize(v);
- break;
+ break;
case TFLOAT:
if(n->op == OEDEC)
v->store.u.fval--;
v->store.u.ival -= fmtsize(v);
else
v->store.u.ival += fmtsize(v);
- break;
+ break;
case TFLOAT:
if(n->op == OPDEC)
v->store.u.fval--;
blob - 19581eab3a6ac4485e086dd3c0f43e74f0f1a819
blob + 90e23f7872fcd556c7ce92087c67c5566e234719
--- src/cmd/acid/lex.c
+++ src/cmd/acid/lex.c
initcmap();
- for(i = 0; keywds[i].name; i++)
+ for(i = 0; keywds[i].name; i++)
enter(keywds[i].name, keywds[i].terminal);
}
return numsym('.');
return '.';
-
+
case '(':
case ')':
case '[':
for(q = s->name; *q; q++)
h = h*3 + *q;
h %= Hashsize;
-
+
if(hash[h] == s)
hash[h] = s->hash;
else{
blob - 2c26426e244b2c62019ea73e1d7af031e390e514
blob + af9f77ae6c7c498fa96c0fc39e74ca30828acd79
--- src/cmd/acid/list.c
+++ src/cmd/acid/list.c
l = al(res.type);
l->store = res.store;
*tail = l;
- tail = &l->next;
+ tail = &l->next;
}
}
blob - 59ae90b1c026c7ae0f210eedc6b6b1ef2ed175c6
blob + ba3ce46e59ae7e98c4bea8cf247f0574aa073f34
--- src/cmd/acid/main.c
+++ src/cmd/acid/main.c
default:
usage();
}ARGEND
-
+
USED(pid);
fmtinstall('Z', Zfmt);
pid = 0;
interactive = 0;
USED(pid);
-
+
if(setjmp(err))
return -1;
blob - e6efc95a0da1d031b09e679303577e2c5f7da1db
blob + ff37cd5f31e54dc535984519e7a7e377a4c97dca
--- src/cmd/acid/proc.c
+++ src/cmd/acid/proc.c
free(correg);
correg = regs;
}else{
- /* XXX should only change register set here if cormap already mapped */
+ /* XXX should only change register set here if cormap already mapped */
if(xpid <= 0)
error("bad pid");
unmapproc(cormap);
{
return "unknown";
}
-
blob - 29db6d8bc1d1cf8ec5bd040d8dcceb6d35cd4eae
blob + e44cb5e2f76d7377ab784255ec06806fcbdad103
--- src/cmd/acid/util.c
+++ src/cmd/acid/util.c
if(l == 0)
l = enter(buf, Tid);
s->aux = l;
- return l;
+ return l;
}
void
tl->store.u.l = list;
list->store.u.string = strnode(buf);
list->store.fmt = 's';
-
+
list->next = al(TINT);
list = list->next;
list->store.fmt = 'c';
list->store.u.ival = s.type;
-
+
list->next = al(TINT);
list = list->next;
list->store.fmt = 'X';
list->store.u.ival = v;
-
+
list->next = al(TSTRING);
list = list->next;
list->store.fmt = 's';
list->store.u.string = file;
-
+
list->next = al(TSTRING);
list = list->next;
list->store.fmt = 's';
blob - 8a043787cf480fe97c2562febc2824f0e6103d28
blob + 97b3a1665353fea27ec579b2c6a8299dd7cb0ba9
--- src/cmd/acidtypes/dat.h
+++ src/cmd/acidtypes/dat.h
Base,
Enum,
Aggr,
- Function,
+ Function,
Pointer,
Array,
Range,
#ifdef VARARGCK
#pragma varargck type "B" char*
#endif
-
blob - f92942865ca193fe1c03fc8c9ec9e18fd4cb1d51
blob + cb39fcbf82c50fd997e95a2d7300c40ac61901f4
--- src/cmd/acidtypes/dwarf.c
+++ src/cmd/acidtypes/dwarf.c
break;
}
}
-
blob - f272f67a982f364ca5c9a82d0c263feb3e245424
blob + eb1a941820058eb9ebd7abd8b7521c4105a3e80c
--- src/cmd/acidtypes/main.c
+++ src/cmd/acidtypes/main.c
}
have = 1;
}
-
+
if(!have){
Bprint(&b, "// no debugging symbols in %s\n\n", argv[i]);
/* fprint(2, "no debugging symbols in %s\n", argv[i]); */
Bterm(&b);
exits(0);
}
-
blob - 5ce0d461159029e90d4d2fcd68ff3082e877b6c6
blob + 0ca3b73f0d7855dafdc457b2d5d0e8f07ac35bf1
--- src/cmd/acidtypes/stabs.c
+++ src/cmd/acidtypes/stabs.c
/*
attr ::= '@' text ';'
- text is
+ text is
'a' integer (alignment)
'p' integer (pointer class)
'P' (packed type)
/*13*/ 8, 'f', /* double */
/*14*/ 10, 'f', /* long double */
/*15*/ 4, 'd', /* int32 */
-/*16*/ 4, 'd', /* bool32 */
+/*16*/ 4, 'd', /* bool32 */
/*17*/ 2, 'f', /* short real */
/*18*/ 4, 'f', /* real */
/*19*/ 4, 'x', /* stringptr */
t->ty = Pointer;
t->sub = parseinfo(p+1, &p);
break;
- case 'a': /* array */
+ case 'a': /* array */
case 'P': /* packed array */
t->ty = Pointer;
tt = newtype();
}
semi(&p);
break;
-
+
case 's': /* struct */
case 'u': /* union */
p++;
}
/*
- bound ::=
+ bound ::=
'A' offset (bound is on stack by ref at offset offset from arg list)
| 'T' offset (bound is on stack by val at offset offset from arg list)
| 'a' regnum (bound passed by reference in register)
fno++;
if((f = findftypes(dir, sym.name)) == nil){
static int cannotprint;
-
+
if(cannotprint++ == 0)
fprint(2, "cannot find remembered %s\n", sym.name);
continue;
}
if(setjmp(kaboom)){
static int cannotparse;
-
+
if(cannotparse++ == 0)
fprint(2, "cannot parse %s\n", name);
continue;
continue;
if(*p != 0){
static int extradesc;
-
+
if(extradesc++ == 0)
fprint(2, "extra desc '%s' in '%s'\n", p, desc);
}
blob - 00897e34670e0a1174ef7108e6292201cd282a0a
blob + 0f1c2f3094de8d11bc7aa8774c9421851a3e9084
--- src/cmd/acidtypes/type.c
+++ src/cmd/acidtypes/type.c
t->n2 = n2;
addhash(t);
return t;
-}
+}
Type*
newtype(void)
{
char *b, *p;
static char buf[65536]; /* These can be huge. */
-
+
if(strchr(name, '<') == nil)
return nonempty(name);
-
+
b = buf;
for(p = name; *p != 0; p++){
switch(*p){
mkname(char *prefix, char *name)
{
static char buf[65536];
-
+
snprint(buf, sizeof buf, "%s%s", prefix, name);
return buf;
}
if(nprint == 0)
Bprint(b, "\t'X' 0 __dummy;\n");
Bprint(b, "};\n\n");
-
+
name = nameof(t, 1); /* might have smashed it */
Bprint(b, "defn %B(addr) { %B(addr, \"\"); }\n", name, mkname("indent_", name));
Bprint(b, "defn %B(addr, indent) {\n", mkname("indent_", name));
}
Bprint(b, "};\n\n");
break;
-
+
case Enum:
name = nameof(t, 1);
Bprint(b, "// enum %s\n", name);
for(j=0; j<t->n; j++)
Bprint(b, "%B = %ld;\n", fixname(t->tname[j]), t->val[j]);
-
+
Bprint(b, "%B = {\n", mkname("vals_", name));
for(j=0; j<t->n; j++)
Bprint(b, "\t%lud,\n", t->val[j]);
* only take one type of a given name; acid is going to do this anyway,
* and this will reduce the amount of code we output considerably.
* we could run a DFA equivalence relaxation sort of algorithm
- * to find the actual equivalence classes, and then rename types
+ * to find the actual equivalence classes, and then rename types
* appropriately, but this will do for now.
*/
all = emalloc(n*sizeof(all[0]));
blob - 47fe193d77abe135d5ef48e3f2fcb976a8565a56
blob + 41883bbd6e64ddfc13ae69a08367bb9b9551c68d
--- src/cmd/acidtypes/util.c
+++ src/cmd/acidtypes/util.c
{
int i;
char *s, *t;
-
+
if(!isBfrog['.']){
for(i=0; i<256; i++)
if(i != '_' && i != '$' && i < Runeself && !isalnum(i))
blob - 12701f23fff2da5c66624f847202a647541d042d
blob + e5658a4ef1339357d62759399079cd21d39abfbb
--- src/cmd/acme/acme.c
+++ src/cmd/acme/acme.c
Cursor2 boxcursor2 = {
{-15, -15},
- {0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xC0, 0x03, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
+ {0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xC0, 0x03, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF},
- {0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0x00, 0x00, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x00, 0x00, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0x00, 0x00, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00}
};
tagcols[BORD] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DPurpleblue);
tagcols[TEXT] = display->black;
tagcols[HTEXT] = display->black;
-
+
/* Yellow */
textcols[BACK] = allocimagemix(display, DPaleyellow, DWhite);
textcols[HIGH] = allocimage(display, Rect(0,0,1,1), screen->chan, 1, DDarkyellow);
textcols[TEXT] = display->black;
textcols[HTEXT] = display->black;
}
-
+
r = Rect(0, 0, Scrollwid+ButtonBorder, font->height+1);
if(button && eqrect(r, button->r))
return;
return fmtprint(f, "%04d/%02d/%02d %02d:%02d:%02d",
tm->year+1900, tm->mon+1, tm->mday, tm->hour, tm->min, tm->sec);
}
-
blob - 6215e04410fdc958773b9a3549f5fcd7cb1b5274
blob + 63c33ac11c52dded05cc959bb0f7644ed1610780
--- src/cmd/acme/cols.c
+++ src/cmd/acme/cols.c
/*
* figure out where to split v to make room for w
*/
-
+
/* new window stops where next window begins */
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);
-
+
/* 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)
buggered = 1;
r1.min.y = winresize(v, r1, FALSE, FALSE);
r1.max.y = r1.min.y+Border;
draw(screen, r1, display->black, nil, ZP);
-
+
/*
* leave r with w's coordinates
*/
c->nw++;
c->w[i] = w;
c->safe = TRUE;
-
+
/* if there were too many windows, redraw the whole column */
if(buggered)
colresize(c, c->r);
blob - ef92e3395deca665f306c2f7059f35803ea96f16
blob + 75cf710f19bfeadb658f67cb8c3303d63d279516
--- src/cmd/acme/ecmd.c
+++ src/cmd/acme/ecmd.c
/*
* The editoutlk exists only so that we can tell when
* the editout file has been closed. It can get closed *after*
- * the process exits because, since the process cannot be
- * connected directly to editout (no 9P kernel support),
+ * the process exits because, since the process cannot be
+ * connected directly to editout (no 9P kernel support),
* the process is actually connected to a pipe to another
* process (arranged via 9pserve) that reads from the pipe
* and then writes the data in the pipe to editout using
if (t != nil && t->file != nil && t->file->name != nil)
warning(nil, "%.*S:", t->file->nname, t->file->name);
-
+
switch(mode) {
case PosnChars:
warning(nil, "#%d", addr.r.q0);
warning(nil, ",#%d", addr.r.q1);
warning(nil, "\n");
return;
-
+
default:
case PosnLine:
l1 = 1+nlcount(t, 0, addr.r.q0, nil);
blob - d3f820593ea00d1e52229b00bcd847bb62affd58
blob + 81f80300db28d033b22290177f3e00632b679e72
--- src/cmd/acme/edit.c
+++ src/cmd/acme/edit.c
if(nextc() == 'g')
cmd.flag = getch();
}
-
+
}
}
}
addr.num = getnum(1);
break;
case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
+ case '5': case '6': case '7': case '8': case '9':
addr.num = getnum(1);
addr.type='l';
break;
blob - c5650f03f9934aaba9d8a20aa1741b0725c24d18
blob + 8a8951fb409ad1b9971806b5992c7d0e4ef68562
--- src/cmd/acme/elog.c
+++ src/cmd/acme/elog.c
* 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
+ * convention that an insertion at t->q0==t->q1 is intended to select the
* inserted text.
*/
}
fbuffree(buf);
elogterm(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.
blob - 4c395eb2bf2090d8b432466d75979c1f47197cc1
blob + d9d4b30d73d2c66281d04669c5f005ae9852c81a
--- src/cmd/acme/fsys.c
+++ src/cmd/acme/fsys.c
qunlock(&row.lk);
dir = dirtabw;
goto Accept;
-
+
Regular:
if(strcmp(x->fcall.wname[i], "new") == 0){
if(w)
blob - 567b83839e653505a5ede655d12ef057ce56637a
blob + 562026c92c6efd612be64b3aa8a08446b132341f
--- src/cmd/acme/logf.c
+++ src/cmd/acme/logf.c
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;
int nev;
Fid **f;
int nf;
int mf;
-
+
// active (blocked) reads waiting for events
Xfid **read;
int nread;
xfidlogopen(Xfid *x)
{
qlock(&eventlog.lk);
- if(eventlog.nf >= eventlog.mf) {
+ if(eventlog.nf >= eventlog.mf) {
eventlog.mf = eventlog.mf*2;
if(eventlog.mf == 0)
eventlog.mf = 8;
Fcall fc;
qlock(&eventlog.lk);
- if(eventlog.nread >= eventlog.mread) {
+ 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[eventlog.nread++] = x;
-
+
if(eventlog.r.l == nil)
eventlog.r.l = &eventlog.lk;
x->flushed = FALSE;
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) {
eventlog.read[i] = eventlog.read[--eventlog.nread];
fc.data = p;
fc.count = strlen(p);
respond(x, &fc, nil);
- free(p);
+ free(p);
}
void
eventlog.start += n;
memmove(eventlog.ev, eventlog.ev+n, eventlog.nev*sizeof eventlog.ev[0]);
}
-
+
// Otherwise grow.
if(eventlog.nev >= eventlog.mev) {
eventlog.mev = eventlog.mev*2;
blob - a7ac6a0bb1fa569d192b77f0286495c9580624cb
blob + 66bb3a5d4f6399493a7af9d3076076a3d8cecfae
--- src/cmd/acme/mail/dat.h
+++ src/cmd/acme/mail/dat.h
extern CFsys *mailfs;
extern CFsys *acmefs;
-
blob - e3a956b06250ef02b003d06c7a2812f774e1e905
blob + e193fc4d4f63ec698ee7bedab0cc2301ab4dec89
--- src/cmd/acme/mail/html.c
+++ src/cmd/acme/mail/html.c
readbody(char *type, char *dir, int *np)
{
char *body;
-
+
body = readfile(dir, "body", np);
if(body != nil && strcmp(type, "text/html") == 0)
return formathtml(body, np);
blob - d79721f80c0d79f5b2bea731d85fa67cc82d1e24
blob + e1047bb8b7c393e3b9777b947ec3d7586add5da6
--- src/cmd/acme/mail/mail.c
+++ src/cmd/acme/mail/mail.c
Unknown:
print("unknown message %c%c\n", e->c1, e->c2);
break;
-
+
case 'E': /* write to body; can't affect us */
break;
-
+
case 'F': /* generated by our actions; ignore */
break;
-
+
case 'K': /* type away; we don't care */
break;
-
+
case 'M':
switch(e->c2){
case 'x':
if(na)
free(s);
break;
-
+
case 'l':
case 'L':
buf = nil;
winwriteevent(w, e);
free(buf);
break;
-
+
case 'I': /* modify away; we don't care */
case 'D':
case 'd':
case 'i':
break;
-
+
default:
goto Unknown;
}
}
}
}
-
blob - 9bfe10e152e79b2a6b85fe7b9ae8d9fdd3a659f3
blob + 739ce10a780b003b3a83898227b8ccdb373be71c
--- src/cmd/acme/mail/mesg.c
+++ src/cmd/acme/mail/mesg.c
int i, nf, inquote;
char **f, *s;
Fmt fmt;
-
+
inquote = 0;
nf = 2;
for(s=t; *s; s++){
data = readfile(dir, "info", &n);
if(data == nil)
return 0;
-
+
p = data;
while((s = line(p, &p)) != nil && *s != 0){
t = strchr(s, ' ');
if (m->level != 1){
m->recursed = 1;
- readmbox(m, dir, m->name);
+ readmbox(m, dir, m->name);
}
return 1;
}
fsseek(fid, 0, 0);
free(d);
d = fsdirfstat(fid);
- }
+ }
free(file);
len = 0;
if(d != nil)
i = estrdup(s);
return i;
- }
+ }
i = estrdup("");
i = eappend(i, "\t", p);
i = egrow(i, "\t", stripdate(m->date));
if(ind == 0){
- if(strcmp(m->type, "text")!=0 && strncmp(m->type, "text/", 5)!=0 &&
+ if(strcmp(m->type, "text")!=0 && strncmp(m->type, "text/", 5)!=0 &&
strncmp(m->type, "multipart/", 10)!=0)
i = egrow(i, "\t(", estrstrdup(m->type, ")"));
}else if(strncmp(m->type, "multipart/", 10) != 0)
}
return 1;
}
-
+
t = estrstrdup(mbox.name, m->name);
raw = readfile(t, "raw", &n);
unixheader = readfile(t, "unixheader", &k);
if(max <= 0)
return 0;
-
+
/* if(strchr(str, ',') || strchr(str, '"') || strchr(str, '<') || strchr(str, '(')) */
/* splitc = ","; */
for(na=0; *str != '\0';str++){
blob - 5dda0edc317be4f0634392b032b3162627ba709d
blob + f28cbef106eb62de737ca109ba7c372487290686
--- src/cmd/acme/mail/reply.c
+++ src/cmd/acme/mail/reply.c
Plumbattr *a;
quotereply = (label[0] == 'Q');
-
+
if(quotereply && m && m->replywinid > 0){
snprint(buf, sizeof buf, "%d/body", m->replywinid);
if((fd = fsopen(acmefs, buf, OWRITE)) != nil){
return;
}
}
-
+
r = emalloc(sizeof(Message));
r->isreply = 1;
if(m != nil)
q[0] = e->q[0];
q[1] = e->q[1];
prog = e->prog; /* known not to be malloc'ed */
-
+
fd[0] = dup(p[0], -1);
if(q[0])
fd[1] = dup(q[1], -1);
free(e->argv);
chanfree(e->sync);
free(e);
-
+
threadexec(nil, fd, prog, argv);
close(fd[0]);
close(fd[1]);
blob - 888e7e72c8f3d3d62fd0617a0bf60fc257257f0d
blob + 8ac9f94671a9ef4ec76d85e934ecdde259f6e82f
--- src/cmd/acme/mail/util.c
+++ src/cmd/acme/mail/util.c
if(n <= 0)
error("control file write error: %r");
}
-
blob - 84c9cee0c68d39303850015451407fd11e44d4c9
blob + 1cf776dda1a3ce03ae0085f94df5d7940357b06d
--- src/cmd/acme/mail/win.c
+++ src/cmd/acme/mail/win.c
while(!fullrune(buf, n))
buf[n++] = wingetec(w);
chartorune(&r, buf);
- }
+ }
*nb = n;
return r;
}
blob - 8ff5884df8e3cc7aa1c8c3cbd1ef6e4792585304
blob + 09422dda077cfa755a87ba156da88fafa25cd7b1
--- src/cmd/acme/text.c
+++ src/cmd/acme/text.c
textscrdraw(u);
}
}
-
+
}
if(q0 < t->iq1)
t->iq1 += n;
if(r == '\n'){ /* eat at most one more character */
if(q == t->q0) /* eat the newline */
--q;
- break;
+ break;
}
if(c == 0x17){
eq = isalnum(r);
case Kcmd+'Z': /* %-shift-Z: redo */
typecommit(t);
undo(t, nil, nil, FALSE, 0, nil, 0);
- return;
+ return;
Tagdown:
/* expand tag to show all text */
winresize(t->w, t->w->r, FALSE, TRUE);
}
return;
-
+
Tagup:
/* shrink tag to single line */
if(t->w->tagexpand){
textsetselect(Text *t, uint q0, uint q1)
{
int p0, p1, ticked;
-
+
/* t->fr.p0 and t->fr.p1 are always right; t->q0 and t->q1 may be off */
t->q0 = q0;
t->q1 = q1;
{
uint p0, p1;
int buts;
-
+
p0 = xselect(&t->fr, mousectl, high, &p1);
buts = mousectl->m.buttons;
if((buts & mask) == 0){
if(textclickhtmlmatch(t, q0, q1))
return;
-
+
for(i=0; left[i]!=nil; i++){
q = *q0;
l = left[i];
return;
}
}
-
+
/* try filling out word to right */
while(*q1<t->file->b.nc && isalnum(textreadc(t, *q1)))
(*q1)++;
ishtmlend(Text *t, uint q, uint *q0)
{
int c, c1, c2;
-
+
if(q < 2)
return 0;
if(textreadc(t, --q) != '>')
{
int depth, n;
uint q, nq;
-
+
q = *q0;
// after opening tag? scan forward for closing tag
if(ishtmlend(t, q, nil) == 1) {
q--;
}
}
-
+
return 0;
}
blob - dc9780954e0589e35d8cc5eb7a14b034d39534d2
blob + c153f8c180c0c2325d9b26c1b29e0f6257ba61b4
--- src/cmd/acme/util.c
+++ src/cmd/acme/util.c
}
/*
- * Incoming window should be locked.
+ * Incoming window should be locked.
* It will be unlocked and returned window
* will be locked in its place.
*/
addwarningtext(Mntdir *md, Rune *r, int nr)
{
Warning *warn;
-
+
for(warn = warnings; warn; warn=warn->next){
if(warn->md == md){
bufinsert(&warn->buf, warn->buf.nc, r, nr);
blob - b4f1a1cbcc530ce2ebf1f54390090ae7027c2f42
blob + 820955b0b62c63f20ffa1e4fa56d0510c07f6f8e
--- src/cmd/acme/wind.c
+++ src/cmd/acme/wind.c
{
Image *b;
Rectangle br;
-
+
b = button;
if(!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
b = modbutton;
{
int n;
Rune rune;
-
+
for(n=0; n<w->tag.file->b.nc; n++) {
bufread(&w->tag.file->b, n, &rune, 1);
if(rune == ' ')
movetodel(Window *w)
{
int n;
-
+
n = delrunepos(w);
if(n < 0)
return;
textresize(&w->tag, r, TRUE);
w->tag.fr.noredraw = 0;
w->tagsafe = FALSE;
-
+
if(!w->tagexpand) {
/* use just as many lines as needed to show the Del */
n = delrunepos(w);
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)
return w->tag.fr.maxlines;
moveto(mousectl, p);
}
}
-
+
/* If needed, resize & redraw body. */
r1 = r;
r1.min.y = y;
void
winmousebut(Window *w)
{
- moveto(mousectl, addpt(w->tag.scrollr.min,
+ moveto(mousectl, addpt(w->tag.scrollr.min,
divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
}
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),
+ return smprint("%s%11d %q %11d ", buf, Dx(w->body.fr.r),
w->body.reffont->f->name, w->body.fr.maxtab);
return buf;
}
blob - 637ad206b3aa614a13518ad205fc42114a122fd1
blob + 8ce3748bddba0804714018cc9505d7893a434027
--- src/cmd/astro/cosadd.c
+++ src/cmd/astro/cosadd.c
int i;
double sum, a1, a2;
va_list arg;
-
+
sum = 0;
cp = cacp;
va_start(arg, n);
blob - d5f26bfc77e01d148cfe070c9bf4f03f95e6c820
blob + 684275277949f835493d145ceb763d1375c5a4fd
--- src/cmd/auth/dsa2pub.c
+++ src/cmd/auth/dsa2pub.c
sysfatal("%r");
s = smprint("key %A p=%lB q=%lB alpha=%lB key=%lB\n",
- a,
+ a,
key->pub.p, key->pub.q, key->pub.alpha, key->pub.key);
if(s == nil)
sysfatal("smprint: %r");
blob - 489f2d211c61356ac8c47d184a87874558cff416
blob + 26f9ff6d0d68fc6a38346a373f36b20e84afb32e
--- src/cmd/auth/dsa2ssh.c
+++ src/cmd/auth/dsa2ssh.c
DSApriv *k;
char *comment;
uchar buf[8192], *p;
-
+
fmtinstall('B', mpfmt);
fmtinstall('[', encodefmt);
comment = "";
blob - cb618edee3e3c56a9c395637c4a1931ec6bcd6ca
blob + d938cf5ddff81ffc4f7da5cb86258417eb7a0df5
--- src/cmd/auth/dsagen.c
+++ src/cmd/auth/dsagen.c
if(write(1, s, strlen(s)) != strlen(s))
sysfatal("write: %r");
-
+
exits(nil);
}
blob - 913385f9a6bd5608fe72464596c5bc420c2c62e9
blob + 594e84e2863c1abdcdcb4990a1b117e3781bc097
--- src/cmd/auth/dsasign.c
+++ src/cmd/auth/dsasign.c
uchar digest[SHA1dlen];
AuthRpc *rpc;
Fmt fmt;
-
+
fmtinstall('[', encodefmt);
fmtinstall('H', encodefmt);
-
+
verify = 0;
id = "";
ARGBEGIN{
default:
usage();
}ARGEND
-
+
if(argc != 1)
usage();
key = argv[0];
auth_freerpc(rpc);
threadexits("rpc");
}
-
+
print("+%s\n", id);
Binit(&b, 0, OREAD);
{
char *p;
mpint *m;
-
+
p = _strfindattr(a, name);
if(p == nil)
sysfatal("missing key attribute %s", name);
Attr *a;
DSAsig dsig;
DSApub dkey;
-
+
a = _parseattr(key);
if(a == nil)
sysfatal("invalid key");
if(dsaverify(&dkey, &dsig, betomp(digest, sizeof digest, nil)) < 0)
sysfatal("signature failed to verify: %r");
-
+
write(1, text, strlen(text));
threadexitsall(0);
}
{
char *p;
int n;
-
+
if((p = Brdline(&b, '\n')) == nil)
return nil;
n = Blinelen(&b);
blob - 992cc0ad1283140bafda1980db15d45faa0564a9
blob + d3d8c95ac646b1ba259bd50201c4332ea0017ab2
--- src/cmd/auth/factotum/apop.c
+++ src/cmd/auth/factotum/apop.c
* S -> C: ok
*
* Note that this is the protocol between factotum and the local
- * program, not between the two factotums. The information
+ * program, not between the two factotums. The information
* exchanged here is wrapped in the APOP protocol by the local
* programs.
*
Attr *attr;
DigestState *ds;
Key *k;
-
+
chal = nil;
k = nil;
res = nil;
}
static Role
-apoproles[] =
+apoproles[] =
{
"client", apopclient,
"server", apopserver,
apopcheck,
nil
};
-
blob - 1c037a5366f09f1939d948b214916d3d7f45329b
blob + 25a4615991beb80a6bb3d79799b80c76a5b15471
--- src/cmd/auth/factotum/attr.c
+++ src/cmd/auth/factotum/attr.c
break;
}
}
- return a;
+ return a;
}
void
break;
}
}
- return 1;
+ return 1;
}
Attr*
blob - fa44db96b2ee9daac328aa5c03be542a31e5dd86
blob + d4fee3c4c19ab606cc3d674a0e76e70ca46da41e
--- src/cmd/auth/factotum/chap.c
+++ src/cmd/auth/factotum/chap.c
/*
* CHAP, MSCHAP
- *
+ *
* The client does not authenticate the server, hence no CAI
*
* Protocol:
{
uchar buf[512];
int i;
-
+
for(i=0; *passwd && i<sizeof(buf); passwd++) {
buf[i++] = *passwd;
buf[i++] = 0;
{
int i;
uchar buf[21];
-
+
memset(buf, 0, sizeof(buf));
memcpy(buf, hash, MShashlen);
}
static Role
-chaproles[] =
+chaproles[] =
{
"client", chapclient,
"server", chapserver,
"user? !password?",
chapcheck
};
-
-
blob - 3a8cf590d904bc21fc22eba2b3195e1adf719beb
blob + 090a5ad3cddf6edac94dfabb5762850ab57ad626
--- src/cmd/auth/factotum/conv.c
+++ src/cmd/auth/factotum/conv.c
return -1;
return 0;
}
-
blob - 46399049ec119cd108957901b26aa9cdc2657030
blob + 64c4c9806f6bafb66725563bcfe923ef39c66be7
--- src/cmd/auth/factotum/cpu.c
+++ src/cmd/auth/factotum/cpu.c
/* start up a process to pass along notes */
lclnoteproc(data);
- /*
+ /*
* Wait for the other end to execute and start our file service
* of /mnt/term
*/
close(fd);
close(p[0]);
}
- return p[1];
+ return p[1];
}
/* Invoked with stdin, stdout and stderr connected to the network connection */
while(len) {
n = read(fd, str, 1);
- if(n < 0)
+ if(n < 0)
return -1;
if(*str == '\0')
return 0;
syslog(0, "cpu", "cpu -R: can't open %s", rmtnotefile);
_exits(0);
}
-
+
for(;;){
n = read(fd, buf, sizeof(buf)-1);
if(n <= 0){
blob - 49377f40192e6c37f25094ecd5cd347bad3830f6
blob + db4a3b1e03845d4a3f2960f86888a3b8ed60a58f
--- src/cmd/auth/factotum/dat.h
+++ src/cmd/auth/factotum/dat.h
Req *req; /* 9P call to read response */
Channel *keywait; /* wait here for key confirmation */
-
+
};
struct Key
blob - ced10355f3d448107392334c409b238979779bb4
blob + aa67881eb05ff3b9378ccadb3cbffb83cb39df91
--- src/cmd/auth/factotum/dsa.c
+++ src/cmd/auth/factotum/dsa.c
/*
* DSA signing and verification
- *
+ *
* Sign:
* start p=xxx q=xxx alpha=xxx key=xxx
* write msg
* write msg
* write signature(msg)
* read ok or fail
- *
+ *
* all numbers are hexadecimal bigints parsable with strtomp.
*/
-
+
static int
xdsasign(Conv *c)
{
}
/*
- * convert to canonical form (lower case)
+ * convert to canonical form (lower case)
* for use in attribute matches.
*/
static void
priv = dsaprivalloc();
- if((a=strfindattr(k->attr, "p"))==nil
+ if((a=strfindattr(k->attr, "p"))==nil
|| (priv->pub.p=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->attr, "q"))==nil
+ if((a=strfindattr(k->attr, "q"))==nil
|| (priv->pub.q=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
werrstr("dsa: p or q not prime");
goto Error;
}
- if((a=strfindattr(k->attr, "alpha"))==nil
+ if((a=strfindattr(k->attr, "alpha"))==nil
|| (priv->pub.alpha=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->attr, "key"))==nil
+ if((a=strfindattr(k->attr, "key"))==nil
|| (priv->pub.key=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->privattr, "!secret"))==nil
+ if((a=strfindattr(k->privattr, "!secret"))==nil
|| (priv->secret=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
dsacheck(Key *k)
{
static int first = 1;
-
+
if(first){
fmtinstall('B', mpfmt);
first = 0;
}
static Role
-dsaroles[] =
+dsaroles[] =
{
"sign", xdsasign,
0
dsacheck,
dsaclose
};
-
blob - fd89b2c28fb4425a58ae9529e1ecf82d78ce7c85
blob + 811bd5b045dfa9a05d2434876d583a0c42e71ad7
--- src/cmd/auth/factotum/fs.c
+++ src/cmd/auth/factotum/fs.c
if(n > 0)
return -1;
-
+
fillstat(dir, factname, QTDIR, Qfactotum, DMDIR|0555);
return 0;
}
memmove(a, buf, n);
return n;
}
-
+
static void
fskickreply(Conv *c)
{
respond(r, nil);
c->nreply = 0;
}
-
+
/*
* Some of the file system work happens in the fs proc, but
* fsopen, fsread, fswrite, fsdestroyfid, and fsflush happen in
c->kickreply = fskickreply;
r->fid->aux = c;
}
-
+
respond(r, nil);
}
fs.destroyfid = fssendclunk;
fs.start = fsstart;
}
-
blob - 3e299bf5e35906ea954d330c330ac26dc3bf4263
blob + 1e9d5793f54f26c324d9a436ffd118729b9fd7bd
--- src/cmd/auth/factotum/httpdigest.c
+++ src/cmd/auth/factotum/httpdigest.c
* HTTPDIGEST - MD5 challenge/response authentication (RFC 2617)
*
* Client protocol:
- * write challenge: nonce method uri
+ * write challenge: nonce method uri
* read response: 2*MD5dlen hex digits
*
* Server protocol:
char *realm, *passwd, *user, *f[4], *s, resp[MD5dlen*2+1];
int ret;
Key *k;
-
+
ret = -1;
s = nil;
-
+
c->state = "keylookup";
k = keyfetch(c, "%A", c->attr);
if(k == nil)
digest(user, realm, passwd, f[0], f[1], f[2], resp);
convwrite(c, resp, strlen(resp));
ret = 0;
-
+
out:
free(s);
keyclose(k);
strtolower(dig);
}
-static Role hdroles[] =
+static Role hdroles[] =
{
"client", hdclient,
0
blob - 9df50eb31cd780ba51bc31d1bb33f58d826c6e09
blob + 817df97bbeb2569bad31d0f15bff5dc3408d6416
--- src/cmd/auth/factotum/key.c
+++ src/cmd/auth/factotum/key.c
sysfatal("out of memory");
va_end(arg);
- /* replace prompted values with prompts */
+ /* replace prompted values with prompts */
a = copyattr(k->attr);
bp = parseattr(k->proto->keyprompt);
for(b=bp; b; b=b->next){
sysfatal("out of memory");
va_end(arg);
- /* replace prompted values with prompts */
+ /* replace prompted values with prompts */
a = copyattr(k->attr);
bp = parseattr(k->proto->keyprompt);
for(b=bp; b; b=b->next){
blob - 4d29536b06850619d7d248f5a81e8d97a35872ec
blob + e644028ad395c0b7df1136aa1702fb1302972606
--- src/cmd/auth/factotum/log.c
+++ src/cmd/auth/factotum/log.c
lbvappend(&logbuf, fmt, arg);
va_end(arg);
}
-
blob - 1f603ac7a0e6ed9218f29ae4ac36caaca18b5713
blob + b3ace12c41e976d0e1ea2bf7889b0073ad6eb874
--- src/cmd/auth/factotum/main.c
+++ src/cmd/auth/factotum/main.c
int rv;
char buf[8192];
CFid *fid;
-
+
fid = nsopen("factotum", nil, "ctl", OWRITE);
if(fid == nil)
sysfatal("opening factotum/ctl: %r");
blob - 0267a6164717a68000c578b20fe517428d7fbd4d
blob + 079eed942ff3415fd28dca458a5110f0103a39c3
--- src/cmd/auth/factotum/p9any.c
+++ src/cmd/auth/factotum/p9any.c
* C->S: proto dom NUL
* [negotiated proto continues]
*/
-
+
extern Proto p9sk1, p9sk2, p9cr;
static Proto* okproto[] =
}
ret = 0;
-
+
out:
free(s);
freeattr(attr);
/* f[i] is the chosen protocol, q the chosen domain */
attr = addattr(attr, "proto=%q dom=%q", f[i], q);
c->state = "write choice";
-
+
/* have a key: go for it */
choice = estrappend(nil, "%q %q", f[i], q);
if(convwrite(c, choice, strlen(choice)+1) < 0){
}
static Role
-p9anyroles[] =
+p9anyroles[] =
{
"client", p9anyclient,
"server", p9anyserver,
"p9any",
p9anyroles
};
-
blob - 1c3f21e1940bddd1940dd0ca5eaf0c9a019d93bc
blob + 4f181e98127d5385602d2d30911c29c83950c110
--- src/cmd/auth/factotum/p9cr.c
+++ src/cmd/auth/factotum/p9cr.c
* S -> C: ok or bad
*
* Note that this is the protocol between factotum and the local
- * program, not between the two factotums. The information
+ * program, not between the two factotums. The information
* exchanged here is wrapped in other protocols by the local
* programs.
*/
static int
p9response(char *pw, uchar *chal, uchar *resp)
-{
+{
char key[DESKEYLEN];
uchar buf[8];
ulong x;
vncresponse(char *pw, uchar *chal, uchar *resp)
{
DESstate des;
-
+
memmove(resp, chal, MAXCHAL);
setupDESstate(&des, 0, nil); // XXX put key in for 0
desECBencrypt(resp, MAXCHAL, &des);
blob - 0a79a361bede4c53d0a41afc1f9341652b6c84aa
blob + d2d7eb89543ba7f977d88a241eae315c5084e8f6
--- src/cmd/auth/factotum/p9sk1.c
+++ src/cmd/auth/factotum/p9sk1.c
k = keyfetch(c, "%A", a);
if(k == nil)
goto out;
-
+
/* relay ticket request to auth server, get tickets */
strcpy(tr.hostid, strfindattr(k->attr, "user"));
if(speakfor)
}
static Role
-p9sk1roles[] =
+p9sk1roles[] =
{
"client", p9skclient,
"server", p9skserver,
};
static Role
-p9sk2roles[] =
+p9sk2roles[] =
{
"client", p9skclient,
"server", p9skserver,
"p9sk2",
p9sk2roles
};
-
blob - 453045ce820b9b98e3daf8539f62619d65dec2c6
blob + ddda95964f5fa24621958d68615af57e0ce2f2e9
--- src/cmd/auth/factotum/pass.c
+++ src/cmd/auth/factotum/pass.c
passproto(Conv *c)
{
Key *k;
-
+
k = keyfetch(c, "%A", c->attr);
if(k == nil)
return -1;
c->state = "write";
- convprint(c, "%q %q",
+ convprint(c, "%q %q",
strfindattr(k->attr, "user"),
strfindattr(k->privattr, "!password"));
return 0;
blob - f3278454cdf0fef9a405da7cd942f2b37df9238e
blob + 0e116f2dea91670f0bbf950d7130df6e85df1e8f
--- src/cmd/auth/factotum/pkcs1.c
+++ src/cmd/auth/factotum/pkcs1.c
*
* We sign hashes of messages instead of the messages
* themselves.
- *
+ *
* The hashes are encoded in ASN.1 DER to identify
* the signature type, and then prefixed with 0x01 PAD 0x00
* where PAD is as many 0xFF bytes as desired.
#define O3(x) \
(((x)>>14)&0x7F)|0x80, \
(((x)>>7)&0x7F)|0x80, \
- ((x)&0x7F)
+ ((x)&0x7F)
uchar oidsha1[] = { O0(1, 3), 14, 3, 2, 26 };
uchar oidmd2[] = { O0(1, 2), O2(840), O3(113549), 2, 2 };
uchar oidmd5[] = { O0(1, 2), O2(840), O3(113549), 2, 5 };
sysfatal("bad alg in mkasn1");
return -1;
}
-
+
p = asn1;
*p++ = 0x30; /* sequence */
p++;
-
+
*p++ = 0x30; /* another sequence */
p++;
*p++ = olen;
memmove(p, obj, olen);
p += olen;
-
+
*p++ = 0x05; /* null */
*p++ = 0;
-
+
asn1[3] = p - (asn1+4); /* end of inner sequence */
-
+
*p++ = 0x04; /* octet string */
*p++ = dlen;
memmove(p, d, dlen);
asn1[1] = p - (asn1+2); /* end of outer sequence */
return p-asn1;
}
-
blob - ad894330731d63abd907b1ba722ff20d0fde152e
blob + 26d5fd4b8c7ce6dae640438367cf4189b1fbf895
--- src/cmd/auth/factotum/rpc.c
+++ src/cmd/auth/factotum/rpc.c
* done [haveai] - authentication is done [haveai: you can get an ai with authinfo]
*/
-char *rpcname[] =
+char *rpcname[] =
{
"unknown",
"authinfo",
rpcrespond(c, "error conversation not successful");
else{
/* make up an auth info using the attr */
- p = convAI2M((uchar*)c->reply+3, sizeof c->reply-3,
+ p = convAI2M((uchar*)c->reply+3, sizeof c->reply-3,
strfindattr(c->attr, "cuid"),
strfindattr(c->attr, "suid"),
strfindattr(c->attr, "cap"),
werrstr("authinfo too big");
return p;
}
-
blob - 95545f931a2decbdc5a249e3bfbdc39dc5f5c39c
blob + e59feaab15450513f5b712e6583b88e6d3ce5685
--- src/cmd/auth/factotum/rsa.c
+++ src/cmd/auth/factotum/rsa.c
/*
* RSA authentication.
- *
+ *
* Encrypt/Decrypt:
* start n=xxx ek=xxx
* write msg
* start n=xxx ek=xxx
* write hash(msg)
* read signature(hash(msg))
- *
+ *
* Verify:
* start n=xxx ek=xxx
* write hash(msg)
if(k == nil)
goto out;
key = k->priv;
-
+
/* make sure have private half if needed */
role = strfindattr(c->attr, "role");
if(strcmp(role, "decrypt") == 0 && !key->c2){
werrstr("missing private half of key -- cannot decrypt");
goto out;
}
-
+
/* read text */
c->state = "read";
if((n=convreadm(c, &txt)) < 0)
convprint(c, "data too short");
goto out;
}
-
+
/* encrypt/decrypt */
m = betomp((uchar*)txt, n, nil);
if(m == nil)
if(mm == nil)
goto out;
n = mptobe(mm, (uchar*)buf, sizeof buf, nil);
-
+
/* send response */
c->state = "write";
convwrite(c, buf, n);
char *sig2;
ret = -1;
-
+
/* fetch key */
c->state = "keylookup";
k = keylookup("%A", c->attr);
werrstr("missing private half of key -- cannot sign");
goto out;
}
-
+
/* get hash type from key */
hash = strfindattr(k->attr, "hash");
if(hash == nil)
/* read signature */
if((n = convreadm(c, &sig2)) < 0)
goto out;
-
+
/* verify */
if(rsaverify(&key->pub, hashfn, digest, dlen, (uchar*)sig2, n) == 0)
convprint(c, "ok");
}
/*
- * convert to canonical form (lower case)
+ * convert to canonical form (lower case)
* for use in attribute matches.
*/
static void
priv = rsaprivalloc();
- if((a=strfindattr(k->attr, "ek"))==nil
+ if((a=strfindattr(k->attr, "ek"))==nil
|| (priv->pub.ek=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->attr, "n"))==nil
+ if((a=strfindattr(k->attr, "n"))==nil
|| (priv->pub.n=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
if(k->privattr == nil) /* only public half */
return priv;
- if((a=strfindattr(k->privattr, "!p"))==nil
+ if((a=strfindattr(k->privattr, "!p"))==nil
|| (priv->p=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->privattr, "!q"))==nil
+ if((a=strfindattr(k->privattr, "!q"))==nil
|| (priv->q=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
werrstr("rsa: p or q not prime");
goto Error;
}
- if((a=strfindattr(k->privattr, "!kp"))==nil
+ if((a=strfindattr(k->privattr, "!kp"))==nil
|| (priv->kp=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->privattr, "!kq"))==nil
+ if((a=strfindattr(k->privattr, "!kq"))==nil
|| (priv->kq=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->privattr, "!c2"))==nil
+ if((a=strfindattr(k->privattr, "!c2"))==nil
|| (priv->c2=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
- if((a=strfindattr(k->privattr, "!dk"))==nil
+ if((a=strfindattr(k->privattr, "!dk"))==nil
|| (priv->dk=strtomp(a, nil, 16, nil))==nil)
goto Error;
strlwr(a);
rsacheck(Key *k)
{
static int first = 1;
-
+
if(first){
fmtinstall('B', mpfmt);
first = 0;
}
static Role
-rsaroles[] =
+rsaroles[] =
{
"sign", xrsasign,
"verify", xrsasign, /* public operation */
blob - c17c3cf2784b6d1b5334e142e21b3887c6963bfe
blob + 9928d3610771c226fcf6ae023ba6ce0f0b441b06
--- src/cmd/auth/factotum/secstore.c
+++ src/cmd/auth/factotum/secstore.c
free(sta);
return rv;
}
-
blob - 814664e0fb482cf11e5da201fb5f5c63d6b5b17a
blob + 52c55b7c8a60a3076c286b10981fd64c7cb38e3a
--- src/cmd/auth/factotum/std.h
+++ src/cmd/auth/factotum/std.h
#include <thread.h>
#include <fcall.h>
#include <9p.h>
-
blob - accddddde1c0aa943d3437aa04dad9a03e7658ad
blob + dce37dca7970c24288937cf08c6ea0f8eaa05876
--- src/cmd/auth/factotum/util.c
+++ src/cmd/auth/factotum/util.c
free(t);
return s;
}
-
-
blob - 1d516db288bd3f166fe2a1b15ab520449b501fea
blob + 701018e776006662de0cc4c78ce27622f8881cff
--- src/cmd/auth/factotum/wep.c
+++ src/cmd/auth/factotum/wep.c
char *dev, buf[128], *p, *kp;
Key *k;
int ret, fd, cfd;
-
+
fd = cfd = -1;
ret = -1;
dev = nil;
-
+
if((k = keylookup("%A !key1?", c->attr)) == nil
&& (k = keylookup("%A !key2?", c->attr)) == nil
&& (k = keylookup("%A !key3?", c->attr)) == nil){
0
};
-Proto wep =
+Proto wep =
{
"wep",
weproles,
blob - 2e6b141b0cae8629e25e8d5bb0bb35b907400ca3
blob + 116fccaf58e13110bda2bb376a4535efe590d560
--- src/cmd/auth/factotum/xio.c
+++ src/cmd/auth/factotum/xio.c
{
Ioproc *c;
int i;
-
+
for(i=0; i<ncache; i++){
if(c = cache[i]){
cache[i] = nil;
n = 0;
return n;
}
-
blob - da23638fab5d11d0f31ac3aa08a68eeb516d71b2
blob + 0b5e0453b979ff797ea63a2f2fff6b9410ad6fa0
--- src/cmd/auth/passwd.c
+++ src/cmd/auth/passwd.c
readln(char *prompt, char *buf, int nbuf, int secret)
{
char *p;
-
+
p = readcons(prompt, nil, secret);
if(p == nil)
sysfatal("user terminated input");
blob - c6634220be48873a137fab5696a8d94989a54963
blob + 68f9d400c32d9eb064ccb01d9022ce47272f25e0
--- src/cmd/auth/respond.c
+++ src/cmd/auth/respond.c
write(1, buf, n);
print("\n");
}
-
-
\ No newline at end of file
blob - 8538ac38856f53970033dba431baca79b80df597
blob + e306cdeca72405578efbfe6efc5300e2b80eeae4
--- src/cmd/auth/rsa2any.c
+++ src/cmd/auth/rsa2any.c
}
if((key->kp = strtomp(p, &p, 16, nil)) == nil || *p != 0){
fprint(2, "warning: bad !kp\n");
- regen = 1;
+ regen = 1;
goto regen;
}
if((p = _strfindattr(a, "!kq")) == nil){
fprint(2, "warning: no !kq\n");
- regen = 1;
+ regen = 1;
goto regen;
}
if((key->kq = strtomp(p, &p, 16, nil)) == nil || *p != 0){
fprint(2, "warning: bad !kq\n");
- regen = 1;
+ regen = 1;
goto regen;
}
if((p = _strfindattr(a, "!c2")) == nil){
fprint(2, "warning: no !c2\n");
- regen = 1;
+ regen = 1;
goto regen;
}
if((key->c2 = strtomp(p, &p, 16, nil)) == nil || *p != 0){
fprint(2, "warning: bad !c2\n");
- regen = 1;
+ regen = 1;
goto regen;
}
regen:
putmp2(uchar *p, mpint *b)
{
int bits, n;
-
+
if(mpcmp(b, mpzero) == 0)
return put4(p, 0);
bits = mpsignif(b);
blob - c0a208a72af18d821d7dcc029bd87b83dc4876ff
blob + e45c04915a92c636a9f134ac55b751e9483d3e58
--- src/cmd/auth/rsa2pub.c
+++ src/cmd/auth/rsa2pub.c
sysfatal("%r");
s = smprint("key %A size=%d ek=%lB n=%lB\n",
- a,
+ a,
mpsignif(key->pub.n), key->pub.ek, key->pub.n);
if(s == nil)
sysfatal("smprint: %r");
blob - 3de2792e33043bf3abe7a6cd2e1fb9174e966337
blob + 9951106b6012dfa2fd05f76517eff3772fc2d854
--- src/cmd/auth/rsa2ssh.c
+++ src/cmd/auth/rsa2ssh.c
{
RSApriv *k;
char *comment;
-
+
fmtinstall('B', mpfmt);
fmtinstall('[', encodefmt);
comment = "";
if(ssh2){
uchar buf[8192], *p;
-
+
p = buf;
p = put4(p, 7);
p = putn(p, "ssh-rsa", 7);
blob - 08cb85998975460922846f9b2f4d3a19cfb77223
blob + efab877e2500789d444093dbf45089cbf09075de
--- src/cmd/auth/rsafill.c
+++ src/cmd/auth/rsafill.c
sysfatal("%r");
s = smprint("key %A size=%d ek=%lB !dk=%lB n=%lB !p=%lB !q=%lB !kp=%lB !kq=%lB !c2=%lB\n",
- a,
+ a,
mpsignif(key->pub.n), key->pub.ek,
key->dk, key->pub.n, key->p, key->q,
key->kp, key->kq, key->c2);
blob - d51560b6350c944a667eb3eec61d9c72a3981440
blob + 2ca99d3498136986c7a0ebaa64be2d2c6e26b9da
--- src/cmd/auth/rsagen.c
+++ src/cmd/auth/rsagen.c
if(write(1, s, strlen(s)) != strlen(s))
sysfatal("write: %r");
-
+
exits(nil);
}
blob - 07e92327b732d2a66e115aae0f639bd0fb8ba7f2
blob + 9ffb3d93543607e290f312b7f8a04dd73a5d44b0
--- src/cmd/auth/secstore/SConn.c
+++ src/cmd/auth/secstore/SConn.c
}
return n;
}
-
blob - 31765f3ecc4dff853258aec872c101453f80cdc0
blob + 09ddb637f383c4818ba36fff529ff087ce43f718
--- src/cmd/auth/secstore/SConn.h
+++ src/cmd/auth/secstore/SConn.h
extern void *emalloc(ulong); /* dies on failure; clears memory */
extern void *erealloc(void *, ulong);
extern char *estrdup(char *);
-
blob - eaae8cdc99547c4ae0e416b1414ba5a6f3916c92
blob + 39542a52c6f5c0b2fde255c80525baf48307be3a
--- src/cmd/auth/secstore/dirls.c
+++ src/cmd/auth/secstore/dirls.c
free(dirbuf);
return list;
}
-
blob - effc01d9f5bb985ca44a4974dfa4ce8fe13d52af
blob + 1f1a09c5b483c338482ad6fd2dead8bb4887c87c
--- src/cmd/auth/secstore/pak.c
+++ src/cmd/auth/secstore/pak.c
mpfree(H);
return rc;
}
-
blob - b2a00e724f989e031bc25808ee8b767da81528e8
blob + c9e63d19ae5387f60206c061e82dc34151a90571
--- src/cmd/auth/secstore/password.c
+++ src/cmd/auth/secstore/password.c
mpfree(pw->Hi);
free(pw);
}
-
blob - 571c6fae465b346253b80ec1b54cc8157478a602
blob + 2b33e5d4ee0f5bc644b6219df4e3b7c0e02a989b
--- src/cmd/auth/secstore/secstore.c
+++ src/cmd/auth/secstore/secstore.c
return 0;
}
- /* conn is already encrypted against wiretappers,
+ /* conn is already encrypted against wiretappers,
but gf is also encrypted against server breakin. */
if(buf == nil && (fd =create(gf, OWRITE, 0600)) < 0){
fprint(2, "can't open %s: %r\n", gf);
return -1;
}
}else{
- if((n = len - bufi) > Maxmsg-ivo)
+ if((n = len - bufi) > Maxmsg-ivo)
n = Maxmsg-ivo;
memcpy(b+ivo, buf+bufi, n);
bufi += n;
exits("");
return 0;
}
-
blob - d9cb807dc41c5e7292f961a70d0f3613334c7064
blob + dfc07730b7dfc1472e6fa3f98cf592762023606b
--- src/cmd/auth/secstore/secstore.h
+++ src/cmd/auth/secstore/secstore.h
#define LOG "secstore"
extern char *SECSTORE_DIR;
-
blob - 9a3c4b66bed1778db6227a6e4b90b290bbdc132c
blob + d32ec64c10e46e630571940eb14ec926a86c1725
--- src/cmd/auth/secstore/secstored.c
+++ src/cmd/auth/secstore/secstored.c
static int
getdir(SConn *conn, char *id)
{
- char *ls, *s;
+ char *ls, *s;
uchar *msg;
int n, len;
}
}
}
-
blob - 8ef6f6aaad7202198a9ff7a8178d13a16447d1b4
blob + 9d8e81ad6daac59b3eea122555a31d30c839fdef
--- src/cmd/auth/secstore/secureidcheck.c
+++ src/cmd/auth/secstore/secureidcheck.c
resp = nil;
continue;
}
-
+
switch(resp->code){
case R_AccessAccept:
syslog(0, AUTHLOG, "%s accepted ruser=%s", dest, ruser);
blob - 31ba184bb5d680aa3f18d666e44481814ce7cbd6
blob + 8e4eae605bb930d754abb277ab115800d98a3cb8
--- src/cmd/auth/secstore/secuser.c
+++ src/cmd/auth/secstore/secuser.c
exits("input too large");
}
}
-
blob - 40516a770f00dc4993c125481f125ed9e100e473
blob + c3b0c7ef35373bf992059fbadd170269971183e3
--- src/cmd/auth/ssh-agent.c
+++ src/cmd/auth/ssh-agent.c
SSH_AGENTC_ADD_RSA_IDENTITY,
SSH_AGENTC_REMOVE_RSA_IDENTITY,
SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES,
-
+
SSH2_AGENTC_REQUEST_IDENTITIES = 11,
SSH2_AGENT_IDENTITIES_ANSWER,
SSH2_AGENTC_SIGN_REQUEST,
SSH_AGENTC_ADD_RSA_ID_CONSTRAINED,
SSH2_AGENTC_ADD_ID_CONSTRAINED,
SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED,
-
+
SSH_AGENT_CONSTRAIN_LIFETIME = 1,
SSH_AGENT_CONSTRAIN_CONFIRM = 2,
SSH2_AGENT_FAILURE = 30,
-
+
SSH_COM_AGENT2_FAILURE = 102,
SSH_AGENT_OLD_SIGNATURE = 0x01
};
default:
usage();
}ARGEND
-
+
if(argc > 1)
usage();
if(argc == 1)
factotum = argv[0];
-
+
if(dotextlist)
listkeystext();
if((afd = announce(addr, adir)) < 0)
sysfatal("announce %s: %r", addr);
-
+
print("SSH_AUTH_SOCK=%s;\n", sock);
if(export)
print("export SSH_AUTH_SOCK;\n");
{
Aconn *a;
int n;
-
+
a = v;
a->fd = accept(a->ctl, a->dir);
close(a->ctl);
get2(Msg *m)
{
uint x;
-
+
if(m->p+2 > m->ep)
return 0;
x = (m->p[0]<<8)|m->p[1];
getn(Msg *m, uint n)
{
uchar *p;
-
+
if(m->p+n > m->ep)
return nil;
p = m->p;
{
int n;
uchar *p;
-
+
n = (get2(m)+7)/8;
if((p=getn(m, n)) == nil)
return nil;
{
int n;
uchar *p;
-
+
n = get4(m);
if((p = getn(m, n)) == nil)
return nil;
{
uint n;
uchar *p;
-
+
n = get4(m);
if((p = getn(m, n)) == nil)
return nil;
put4(Msg *m, uint n)
{
uchar *p;
-
+
p = ensure(m, 4);
p[0] = (n>>24)&0xFF;
p[1] = (n>>16)&0xFF;
put2(Msg *m, uint n)
{
uchar *p;
-
+
p = ensure(m, 2);
p[0] = (n>>8)&0xFF;
p[1] = n&0xFF;
put1(Msg *m, uint n)
{
uchar *p;
-
+
p = ensure(m, 1);
p[0] = n&0xFF;
}
putn(Msg *m, void *a, uint n)
{
uchar *p;
-
+
p = ensure(m, n);
memmove(p, a, n);
}
{
int bits, n;
uchar *p;
-
+
bits = mpsignif(b);
put2(m, bits);
n = (bits+7)/8;
{
int bits, n;
uchar *p;
-
+
if(mpcmp(b, mpzero) == 0){
put4(m, 0);
return;
putstr(Msg *m, char *s)
{
int n;
-
+
n = strlen(s);
put4(m, n);
putn(m, s, n);
putm(Msg *m, Msg *mm)
{
uint n;
-
+
n = mm->p - mm->bp;
put4(m, n);
putn(m, mm->bp, n);
{
uint n;
uchar *p;
-
+
n = (m->p - m->bp) - 4;
p = m->bp;
p[0] = (n>>24)&0xFF;
printattr(char **f, int nf)
{
int i;
-
+
print("#");
for(i=0; i<nf; i++)
print(" %s", f[i]);
getrsapub(Msg *m)
{
RSApub *k;
-
+
k = rsapuballoc();
if(k == nil)
return nil;
{
char *p;
Msg mm;
-
+
newmsg(&mm);
if(put(&mm, f, nf) < 0)
return -1;
{
Msg m;
char *p;
-
+
newmsg(&m);
if(put(&m, f, nf) < 0)
return -1;
getdsapub(Msg *m)
{
DSApub *k;
-
+
k = dsapuballoc();
if(k == nil)
return nil;
auth_freerpc(rpc);
return -1;
}
-
+
p = mptoa(chal, 16, nil, 0);
if(p == nil){
fprint(2, "ssh-agent: dorsa: mptoa: %r\n");
DSApub *dsa;
char buf[4096];
uchar digest[SHA1dlen];
-
+
s = getstr(mkey);
if(strcmp(s, "ssh-rsa") == 0){
rsa = getrsapub(mkey);
uint len, flags;
DigestState *s;
Msg m, mkey, mdata, msig;
-
+
if(a->ndata < 4)
return 0;
len = (a->data[0]<<24)|(a->data[1]<<16)|(a->data[2]<<8)|a->data[3];
goto Failchal;
md5(sessid, 16, digest, s);
print("md5 %.*H %.*H => %.*H\n", 32, chalbuf, 16, sessid, MD5dlen, digest);
-
+
newreply(&m, SSH_AGENT_RSA_RESPONSE);
putn(&m, digest, 16);
reply(a, &m);
mreset(&msig);
reply(a, &m);
break;
-
+
case SSH_AGENTC_ADD_RSA_IDENTITY:
/*
msg: n[4] mod[mp] pubexp[exp] privexp[mp]
p^-1 mod q[mp] p[mp] q[mp] comment[str]
*/
goto Failure;
-
+
case SSH_AGENTC_REMOVE_RSA_IDENTITY:
/*
msg: n[4] mod[mp] pubexp[mp]
*/
goto Failure;
-
+
}
-
+
a->ndata -= 4+len;
memmove(a->data, a->data+4+len, a->ndata);
return 1;
}
return v;
}
-
blob - b92f682ef0234bb7ad3837658d8b1570a9781807
blob + 836de5205d0078ce45668a29e61221eeec644c1a
--- src/cmd/auxstats/Darwin.c
+++ src/cmd/auxstats/Darwin.c
sampleinit(void)
{
mach_timebase_info_data_t info;
-
+
if(stat_port)
return;
sample.net_obytes = 0;
sample.net_errors = 0;
sample.net_ifaces = 0;
-
+
for(ifa=ifa_list; ifa; ifa=ifa->ifa_next){
if(ifa->ifa_addr->sa_family != AF_LINK)
continue;
continue;
if(strncmp(ifa->ifa_name, "lo", 2) == 0) /* loopback */
continue;
-
+
if_data = (struct if_data*)ifa->ifa_data;
sample.net_ipackets += if_data->ifi_ipackets;
sample.net_opackets += if_data->ifi_opackets;
* all the other stat monitoring apps get set:
*
* -rwsr-xr-x 1 root wheel 83088 Mar 20 2005 /usr/bin/top
- * -rwsrwxr-x 1 root admin 54048 Mar 20 2005
+ * -rwsrwxr-x 1 root admin 54048 Mar 20 2005
* /Applications/Utilities/Activity Monitor.app/Contents/Resources/pmTool
*
* If Darwin eventually encompases more into sysctl then this
mach_error_string(error));
return;
}
-
+
sample.p_syscalls_mach = sample.syscalls_mach;
sample.p_syscalls_unix = sample.syscalls_unix;
sample.p_csw = sample.csw;
sample.syscalls_mach = 0;
sample.syscalls_unix = 0;
sample.csw = 0;
-
+
for(i=0; i<pcnt; i++){
if((error=host_processor_set_priv(stat_port, psets[i], &pset)) != KERN_SUCCESS){
Bprint(&bout, "host_processor_set_priv: %s\n", mach_error_string(error));
sample.syscalls_unix += events.syscalls_unix;
sample.csw += events.csw;
}
-
+
if(tasks[j] != mach_task_self())
mach_port_deallocate(mach_task_self(), tasks[j]);
}
-
- if((error = vm_deallocate((vm_map_t)mach_task_self(),
+
+ if((error = vm_deallocate((vm_map_t)mach_task_self(),
(vm_address_t)tasks, tcnt*sizeof(task_t))) != KERN_SUCCESS){
Bprint(&bout, "vm_deallocate: %s\n", mach_error_string(error));
return;
}
-
+
if((error = mach_port_deallocate(mach_task_self(), pset)) != KERN_SUCCESS
|| (error = mach_port_deallocate(mach_task_self(), psets[i])) != KERN_SUCCESS){
Bprint(&bout, "mach_port_deallocate: %s\n", mach_error_string(error));
return;
}
}
-
+
if((error = vm_deallocate((vm_map_t)mach_task_self(), (vm_address_t)psets,
pcnt*sizeof(processor_set_t))) != KERN_SUCCESS){
Bprint(&bout, "vm_deallocate: %s\n", mach_error_string(error));
int mib[2];
mach_msg_type_number_t count;
size_t len;
-
+
if(first){
sampleinit();
return;
}
-
+
sample.seq++;
sample.p_time = sample.time;
sample.time = mach_absolute_time();
sample.p_vm_stat = sample.vm_stat;
count = sizeof(sample.vm_stat) / sizeof(natural_t);
host_statistics(stat_port, HOST_VM_INFO, (host_info_t)&sample.vm_stat, &count);
-
+
if(sample.seq == 1)
sample.p_vm_stat = sample.vm_stat;
if(first)
return;
-
+
src = IOPSCopyPowerSourcesInfo();
array = IOPSCopyPowerSourcesList(src);
{
uint n;
ulong err, in, inb, out, outb;
-
+
n = sample.net_ifaces;
in = sample.net_ipackets - sample.p_net_ipackets;
out = sample.net_opackets - sample.p_net_opackets;
inb = sample.net_ibytes - sample.p_net_ibytes;
outb = sample.net_obytes - sample.p_net_obytes;
err = sample.net_errors - sample.p_net_errors;
-
+
Bprint(&bout, "etherb %lud %d\n", inb+outb, n*1000000);
Bprint(&bout, "ether %lud %d\n", in+out, n*1000);
Bprint(&bout, "ethererr %lud %d\n", err, n*1000);
+ sample.vm_stat.active_count
+ sample.vm_stat.inactive_count
+ sample.vm_stat.wire_count;
-
+
active = sample.vm_stat.active_count
+ sample.vm_stat.inactive_count
+ sample.vm_stat.wire_count;
Bprint(&bout, "context %lld 1000\n", (vlong)sample.csw);
Bprint(&bout, "syscall %lld 1000\n", (vlong)sample.syscalls_mach+sample.syscalls_unix);
- Bprint(&bout, "intr %lld 1000\n",
+ Bprint(&bout, "intr %lld 1000\n",
isys("vm.stats.sys.v_intr")
+isys("vm.stats.sys.v_trap"));
-
+
Bprint(&bout, "fault %lld 1000\n", sample.vm_stat.faults);
Bprint(&bout, "fork %lld 1000\n",
isys("vm.stats.vm.v_rforks")
sample.p_cpu.cpu_ticks[CPU_STATE_USER];
nice = sample.cpu.cpu_ticks[CPU_STATE_NICE] -
sample.p_cpu.cpu_ticks[CPU_STATE_NICE];
-
+
t = sys+idle+user+nice;
Bprint(&bout, "user =%lud %lud\n", user, t);
#ifdef VM_SWAPUSAGE
if(sample.xsu_valid)
- Bprint(&bout, "swap %lld %lld\n",
- (vlong)sample.xsu.xsu_used,
+ Bprint(&bout, "swap %lld %lld\n",
+ (vlong)sample.xsu.xsu_used,
(vlong)sample.xsu.xsu_total);
#endif
}
blob - ec9310447017e5215754d96967872b6d5a70f59b
blob + 33ebdedc18f59eb24385c1f73dbec11df59e63fe
--- src/cmd/auxstats/DragonFly.c
+++ src/cmd/auxstats/DragonFly.c
#include <bio.h>
#include "dat.h"
-void (*statfn[])(int) =
+void (*statfn[])(int) =
{
0
};
-
blob - 2497fe35eb5be77886f0e494d81d25efb43686ac
blob + 2cc82879dab4d0ae4dd6f9b05bdd2d14cb9f6a22
--- src/cmd/auxstats/FreeBSD.c
+++ src/cmd/auxstats/FreeBSD.c
pgsize = 4096;
}
- Bprint(&bout, "mem =%lld %lld\n",
- isys("vm.stats.vm.v_active_count")*pgsize,
+ Bprint(&bout, "mem =%lld %lld\n",
+ isys("vm.stats.vm.v_active_count")*pgsize,
isys("vm.stats.vm.v_page_count")*pgsize);
Bprint(&bout, "context %lld 1000\n", isys("vm.stats.sys.v_swtch"));
Bprint(&bout, "syscall %lld 1000\n", isys("vm.stats.sys.v_syscall"));
Bprint(&bout, "swap =%lld %lld\n", s.ksw_used*(vlong)pgsize, s.ksw_total*(vlong)pgsize);
}
-
blob - 64c86a26cd6aeeaf7e9e00ed60205faffbee5d42
blob + 7bc4b7206881f4756cf9a951ba4f21275e4b8240
--- src/cmd/auxstats/Linux.c
+++ src/cmd/auxstats/Linux.c
readfile(fd);
tokens(0);
curr = atoi(tok[0]);
-
+
if(curr != -1)
Bprint(&bout, "battery =%d 100\n", curr);
}
-
+
void
xloadavg(int first)
{
{
static int fd = -1;
int i;
-
+
if(first){
fd = open("/proc/net/wireless", OREAD);
return;
blob - ec9310447017e5215754d96967872b6d5a70f59b
blob + 33ebdedc18f59eb24385c1f73dbec11df59e63fe
--- src/cmd/auxstats/NetBSD.c
+++ src/cmd/auxstats/NetBSD.c
#include <bio.h>
#include "dat.h"
-void (*statfn[])(int) =
+void (*statfn[])(int) =
{
0
};
-
blob - ec9310447017e5215754d96967872b6d5a70f59b
blob + 33ebdedc18f59eb24385c1f73dbec11df59e63fe
--- src/cmd/auxstats/SunOS.c
+++ src/cmd/auxstats/SunOS.c
#include <bio.h>
#include "dat.h"
-void (*statfn[])(int) =
+void (*statfn[])(int) =
{
0
};
-
blob - d1c3556193847cdc91b9d319d14981b0f0de5584
blob + 3fd77ac4c42d5150a2c833fc6f54679ae67fd8ae
--- src/cmd/auxstats/main.c
+++ src/cmd/auxstats/main.c
}
ntok = tokenize(line[i], tok, nelem(tok));
}
-
blob - 1853381d4fac0c696fd027204ed3802de2c806c4
blob + 913f450924e93cb1658a0efcd25e5c11c6c2629d
--- src/cmd/awk/awk.h
+++ src/cmd/awk/awk.h
#define CCOPY 6
#define CCON 5
#define CTEMP 4
-#define CNAME 3
+#define CNAME 3
#define CVAR 2
#define CFLD 1
#define CUNK 0
#define freeable(p) ( ((p)->tval & (STR|DONTFREE)) == STR )
#include "proto.h"
-
blob - 74a99030511806632f6517321cf30086a759cc77
blob + 0a051eded7fd5f887a51d077805ac6146eb7f45d
--- src/cmd/awk/lex.c
+++ src/cmd/awk/lex.c
if (bp-buf >= sz)
if (!adjbuf(&buf, &sz, bp-buf+2, 100, &bp, 0))
FATAL( "out of space for number %.10s...", buf );
- if (isdigit(c) || c == 'e' || c == 'E'
+ if (isdigit(c) || c == 'e' || c == 'E'
|| c == '.' || c == '+' || c == '-')
*bp++ = c;
else {
/* should this also have STR set? */
RET(NUMBER);
}
-
+
yylval.i = c;
switch (c) {
case '\n': /* {EOL} */
case '&':
if (peek() == '&') {
input(); RET(AND);
- } else
+ } else
RET('&');
case '|':
if (peek() == '|') {
input(); yylval.i = POWEQ; RET(ASGNOP);
} else
RET(POWER);
-
+
case '$':
/* BUG: awkward, if not wrong */
c = gettok(&buf, &bufsize);
unputstr(buf);
RET(INDIRECT);
}
-
+
case '}':
if (--bracecnt < 0)
SYNTAX( "extra }" );
case '(':
parencnt++;
RET('(');
-
+
case '"':
return string(); /* BUG: should be like tran.c ? */
-
+
default:
RET(c);
}
c = input();
switch (c) {
case '"': *bp++ = '"'; break;
- case 'n': *bp++ = '\n'; break;
+ case 'n': *bp++ = '\n'; break;
case 't': *bp++ = '\t'; break;
case 'f': *bp++ = '\f'; break;
case 'r': *bp++ = '\r'; break;
break;
}
- default:
+ default:
*bp++ = c;
break;
}
break;
}
}
- *bp = 0;
+ *bp = 0;
s = tostring(buf);
*bp++ = ' '; *bp++ = 0;
yylval.cp = setsymtab(buf, s, 0.0, CON|STR|DONTFREE, symtab);
return -1;
}
-int word(char *w)
+int word(char *w)
{
Keyword *kp;
int c, n;
if (!adjbuf(&buf, &bufsz, bp-buf+3, 500, &bp, 0))
FATAL("out of space for reg expr %.10s...", buf);
if (c == '\n') {
- SYNTAX( "newline in regular expression %.10s...", buf );
+ SYNTAX( "newline in regular expression %.10s...", buf );
unput('\n');
break;
} else if (c == '\\') {
- *bp++ = '\\';
+ *bp++ = '\\';
*bp++ = input();
} else {
*bp++ = c;
for (i = strlen(s)-1; i >= 0; i--)
unput(s[i]);
}
-
blob - 3eb30687cf9f746445c95938fe1810886c652fc6
blob + 30c3ddd4bf7a161d24bb08fc6b71a67687d4dc61
--- src/cmd/awk/lib.c
+++ src/cmd/awk/lib.c
break;
}
}
- return i;
+ return i;
}
void recbld(void) /* create $0 from $1..$NF if necessary */
else
return 0;
}
-
blob - ea20f63e5d71dade631baae91b88abb2b1f4ebae
blob + 532cc1f649e890b7da83c6ea4462deff38893a8c
--- src/cmd/awk/main.c
+++ src/cmd/awk/main.c
else
return NULL;
}
-
blob - 50908ce9770ffd9ac7dbddc83fb0f8de85a1fdcb
blob + 13d34e96e0d0c2d2f960ad68cfa589cf27b7f797
--- src/cmd/awk/maketab.c
+++ src/cmd/awk/maketab.c
printf("}\n");
return 0;
}
-
blob - d4c88324327751bf90c39e0940c0925ab1115285
blob + 2ee6eca621314b74a671f6a6237c3be5f0bbc422
--- src/cmd/awk/parse.c
+++ src/cmd/awk/parse.c
{
return (Node *) (long) i;
}
-
blob - f124f4e4c46cc82c20bb4c7940a734d844899f72
blob + d12a9322130344fbd0b432c9e01d8bccdaba1891
--- src/cmd/awk/proto.h
+++ src/cmd/awk/proto.h
extern FILE *popen(const char *, const char *);
extern int pclose(FILE *);
-
blob - a15d2f4dd84be54cdc6384e6d0d5749847da20d1
blob + 2a226768b5e20ebbdd883277d7497108a68a252b
--- src/cmd/awk/re.c
+++ src/cmd/awk/re.c
if (pmatch(p, s, start) == 1 && patlen > 0)
return 1;
patlen = -1;
- patbeg = start;
+ patbeg = start;
return 0;
}
/* in the parsing of regular expressions, metacharacters like . have */
{
FATAL("%s", "regular expression too big");
}
-
blob - b145758cc0372d8460bbd64b33fcb4a2369ce39c
blob + 9aa3e0e4ce1cd13ae40845de01df64639b93fe4e
--- src/cmd/awk/run.c
+++ src/cmd/awk/run.c
s = getsval(y);
if (!adjbuf(&buf, &bufsz, strlen(buf)+strlen(s)+nsub+1, recsize, 0, 0))
FATAL("out of memory deleting %s[%s...]", x->nval, buf);
- strcat(buf, s);
+ strcat(buf, s);
if (np->nnext)
strcat(buf, *SUBSEP);
tempfree(y);
*pb_ptr = pb;
*sptr_ptr = sptr;
}
-
blob - 272a7fdc0c0c3c53378a20e9544db40bc6f2751a
blob + 387bc00bdbf654a61d0c0e618f716b96b233880b
--- src/cmd/awk/tran.c
+++ src/cmd/awk/tran.c
if (freeable(cp))
xfree(cp->sval);
temp = cp->cnext; /* avoids freeing then using */
- free(cp);
+ free(cp);
}
tp->tab[i] = 0;
}
Array *tp;
Cell *p, *prev = NULL;
int h;
-
+
tp = (Array *) ap->sval;
h = hash(s, tp->size);
for (p = tp->tab[h]; p != NULL; prev = p, p = p->cnext)
{
int fldno;
- if ((vp->tval & (NUM | STR)) == 0)
+ if ((vp->tval & (NUM | STR)) == 0)
funnyvar(vp, "assign to");
if (isfld(vp)) {
donerec = 0; /* mark $0 invalid */
if (c == 0) { /* \ at end */
*bp++ = '\\';
break; /* for loop */
- }
+ }
switch (c) {
case '\\': *bp++ = '\\'; break;
case 'n': *bp++ = '\n'; break;
*bp++ = 0;
return buf;
}
-
blob - 653ebc33e820ff9dcbce4ddb5d70e6cbe5f1f04c
blob + 38abb7ed36905c5480ed0995e4aa2e039f10818e
--- src/cmd/bzip2/bunzip2.c
+++ src/cmd/bzip2/bunzip2.c
if(!done && strm.avail_in < sizeof buf) {
if(strm.avail_in)
memmove(buf, strm.next_in, strm.avail_in);
-
+
n = Bread(bin, buf+strm.avail_in, sizeof(buf)-strm.avail_in);
if(n <= 0)
done = 1;
blob - cc21a57c2554317c5a6616357acdbb6c5cb9055a
blob + 6743acb8e8f03c5e4660394e4650bf26cd1a1b59
--- src/cmd/bzip2/bzip2.c
+++ src/cmd/bzip2/bzip2.c
if(!done && strm.avail_in < sizeof buf) {
if(strm.avail_in)
memmove(buf, strm.next_in, strm.avail_in);
-
+
n = Bread(&bin, buf+strm.avail_in, sizeof(buf)-strm.avail_in);
if(n <= 0)
done = 1;
blob - ba3d175632a77de125e5d2c2a346f1efb1cc27c2
blob + c31c50abecef4ae2b7ab4499ef5a4e678d63c707
--- src/cmd/bzip2/bzip2recover.c
+++ src/cmd/bzip2/bzip2recover.c
/*-----------------------------------------------------------*/
/*--
- This program is bzip2recover, a program to attempt data
+ This program is bzip2recover, a program to attempt data
salvage from damaged files created by the accompanying
bzip2-1.0 program.
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
}
buffHi = (buffHi << 1) | (buffLo >> 31);
buffLo = (buffLo << 1) | (b & 1);
- if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI
+ if ( ( (buffHi & 0x0000ffff) == BLOCK_HEADER_HI
&& buffLo == BLOCK_HEADER_LO)
- ||
- ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI
+ ||
+ ( (buffHi & 0x0000ffff) == BLOCK_ENDMARK_HI
&& buffLo == BLOCK_ENDMARK_LO)
) {
if (bitsRead > 49)
if (b == 2) break;
buffHi = (buffHi << 1) | (buffLo >> 31);
buffLo = (buffLo << 1) | (b & 1);
- if (bitsRead == 47+rbStart[wrBlock])
+ if (bitsRead == 47+rbStart[wrBlock])
blockCRC = (buffHi << 16) | (buffLo >> 16);
if (outFile != NULL && bitsRead >= rbStart[wrBlock]
blob - f43d569e6da61eca1add14dd1eb8cfe4d9284467
blob + e6d154b30baa473917056c0c2df1e52443419c5a
--- src/cmd/bzip2/lib/blocksort.c
+++ src/cmd/bzip2/lib/blocksort.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
For more information on these sources, see the manual.
- To get some idea how the block sorting algorithms in this file
- work, read my paper
+ To get some idea how the block sorting algorithms in this file
+ work, read my paper
On the Performance of BWT Sorting Algorithms
in Proceedings of the IEEE Data Compression Conference 2000,
Snowbird, Utah, USA, 27-30 March 2000. The main sort in this
/*---------------------------------------------*/
/*---------------------------------------------*/
-static
+static
__inline__
-void fallbackSimpleSort ( UInt32* fmap,
- UInt32* eclass,
- Int32 lo,
+void fallbackSimpleSort ( UInt32* fmap,
+ UInt32* eclass,
+ Int32 lo,
Int32 hi )
{
Int32 i, j, tmp;
static
-void fallbackQSort3 ( UInt32* fmap,
+void fallbackQSort3 ( UInt32* fmap,
UInt32* eclass,
- Int32 loSt,
+ Int32 loSt,
Int32 hiSt )
{
Int32 unLo, unHi, ltLo, gtHi, n, m;
}
/* Random partitioning. Median of 3 sometimes fails to
- avoid bad cases. Median of 9 seems to help but
+ avoid bad cases. Median of 9 seems to help but
looks rather expensive. This too seems to work but
- is cheaper. Guidance for the magic constants
+ is cheaper. Guidance for the magic constants
7621 and 32768 is taken from Sedgewick's algorithms
book, chapter 35.
*/
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unLo]] - (Int32)med;
- if (n == 0) {
- fswap(fmap[unLo], fmap[ltLo]);
- ltLo++; unLo++;
- continue;
+ if (n == 0) {
+ fswap(fmap[unLo], fmap[ltLo]);
+ ltLo++; unLo++;
+ continue;
};
if (n > 0) break;
unLo++;
while (1) {
if (unLo > unHi) break;
n = (Int32)eclass[fmap[unHi]] - (Int32)med;
- if (n == 0) {
- fswap(fmap[unHi], fmap[gtHi]);
- gtHi--; unHi--;
- continue;
+ if (n == 0) {
+ fswap(fmap[unHi], fmap[gtHi]);
+ gtHi--; unHi--;
+ continue;
};
if (n < 0) break;
unHi--;
#define UNALIGNED_BH(zz) ((zz) & 0x01f)
static
-void fallbackSort ( UInt32* fmap,
- UInt32* eclass,
+void fallbackSort ( UInt32* fmap,
+ UInt32* eclass,
UInt32* bhtab,
Int32 nblock,
Int32 verb )
--*/
/*-- set sentinel bits for block-end detection --*/
- for (i = 0; i < 32; i++) {
+ for (i = 0; i < 32; i++) {
SET_BH(nblock + 2*i);
CLEAR_BH(nblock + 2*i + 1);
}
H = 1;
while (1) {
- if (verb >= 4)
+ if (verb >= 4)
VPrintf1 ( " depth %6d has ", H );
j = 0;
}
}
- if (verb >= 4)
+ if (verb >= 4)
VPrintf1 ( "%6d unresolved strings\n", nNotDone );
H *= 2;
if (H > nblock || nNotDone == 0) break;
}
- /*--
+ /*--
Reconstruct the original block in
eclass8 [0 .. nblock-1], since the
previous phase destroyed it.
/*---------------------------------------------*/
static
__inline__
-Bool mainGtU ( UInt32 i1,
+Bool mainGtU ( UInt32 i1,
UInt32 i2,
- UChar* block,
+ UChar* block,
UInt16* quadrant,
UInt32 nblock,
Int32* budget )
UChar* block,
UInt16* quadrant,
Int32 nblock,
- Int32 lo,
- Int32 hi,
+ Int32 lo,
+ Int32 hi,
Int32 d,
Int32* budget )
{
if (i > hi) break;
v = ptr[i];
j = i;
- while ( mainGtU (
- ptr[j-h]+d, v+d, block, quadrant, nblock, budget
+ while ( mainGtU (
+ ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
if (i > hi) break;
v = ptr[i];
j = i;
- while ( mainGtU (
- ptr[j-h]+d, v+d, block, quadrant, nblock, budget
+ while ( mainGtU (
+ ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
if (i > hi) break;
v = ptr[i];
j = i;
- while ( mainGtU (
- ptr[j-h]+d, v+d, block, quadrant, nblock, budget
+ while ( mainGtU (
+ ptr[j-h]+d, v+d, block, quadrant, nblock, budget
) ) {
ptr[j] = ptr[j-h];
j = j - h;
} \
}
-static
+static
__inline__
UChar mmed3 ( UChar a, UChar b, UChar c )
{
UChar t;
if (a > b) { t = a; a = b; b = t; };
- if (b > c) {
+ if (b > c) {
b = c;
if (a > b) b = a;
}
UChar* block,
UInt16* quadrant,
Int32 nblock,
- Int32 loSt,
- Int32 hiSt,
+ Int32 loSt,
+ Int32 hiSt,
Int32 dSt,
Int32* budget )
{
AssertH ( sp < MAIN_QSORT_STACK_SIZE, 1001 );
mpop ( lo, hi, d );
- if (hi - lo < MAIN_QSORT_SMALL_THRESH ||
+ if (hi - lo < MAIN_QSORT_SMALL_THRESH ||
d > MAIN_QSORT_DEPTH_THRESH) {
mainSimpleSort ( ptr, block, quadrant, nblock, lo, hi, d, budget );
if (*budget < 0) return;
continue;
}
- med = (Int32)
+ med = (Int32)
mmed3 ( block[ptr[ lo ]+d],
block[ptr[ hi ]+d],
block[ptr[ (lo+hi)>>1 ]+d] );
while (True) {
if (unLo > unHi) break;
n = ((Int32)block[ptr[unLo]+d]) - med;
- if (n == 0) {
- mswap(ptr[unLo], ptr[ltLo]);
- ltLo++; unLo++; continue;
+ if (n == 0) {
+ mswap(ptr[unLo], ptr[ltLo]);
+ ltLo++; unLo++; continue;
};
if (n > 0) break;
unLo++;
while (True) {
if (unLo > unHi) break;
n = ((Int32)block[ptr[unHi]+d]) - med;
- if (n == 0) {
- mswap(ptr[unHi], ptr[gtHi]);
- gtHi--; unHi--; continue;
+ if (n == 0) {
+ mswap(ptr[unHi], ptr[gtHi]);
+ gtHi--; unHi--; continue;
};
if (n < 0) break;
unHi--;
#define CLEARMASK (~(SETMASK))
static
-void mainSort ( UInt32* ptr,
+void mainSort ( UInt32* ptr,
UChar* block,
- UInt16* quadrant,
+ UInt16* quadrant,
UInt32* ftab,
Int32 nblock,
Int32 verb,
/*--
Step 1:
Complete the big bucket [ss] by quicksorting
- any unsorted small buckets [ss, j], for j != ss.
+ any unsorted small buckets [ss, j], for j != ss.
Hopefully previous pointer-scanning phases have already
completed many of the small buckets [ss, j], so
we don't have to sort them at all.
VPrintf4 ( " qsort [0x%x, 0x%x] "
"done %d this %d\n",
ss, j, numQSorted, hi - lo + 1 );
- mainQSort3 (
- ptr, block, quadrant, nblock,
- lo, hi, BZ_N_RADIX, budget
- );
+ mainQSort3 (
+ ptr, block, quadrant, nblock,
+ lo, hi, BZ_N_RADIX, budget
+ );
numQSorted += (hi - lo + 1);
if (*budget < 0) return;
}
for (j = (ftab[(ss+1) << 8] & CLEARMASK) - 1; j > copyEnd[ss]; j--) {
k = ptr[j]-1; if (k < 0) k += nblock;
c1 = block[k];
- if (!bigDone[c1])
+ if (!bigDone[c1])
ptr[ copyEnd[c1]-- ] = k;
}
}
updating for the last bucket is pointless.
The quadrant array provides a way to incrementally
- cache sort orderings, as they appear, so as to
+ cache sort orderings, as they appear, so as to
make subsequent comparisons in fullGtU() complete
faster. For repetitive blocks this makes a big
difference (but not big enough to be able to avoid
for 0 <= i < nblock and 0 <= j <= nblock
- if block[i] != block[j],
+ if block[i] != block[j],
- then the relative values of quadrant[i] and
+ then the relative values of quadrant[i] and
quadrant[j] are meaningless.
else {
*/
void BZ2_blockSort ( EState* s )
{
- UInt32* ptr = s->ptr;
+ UInt32* ptr = s->ptr;
UChar* block = s->block;
UInt32* ftab = s->ftab;
Int32 nblock = s->nblock;
quadrant = (UInt16*)(&(block[i]));
/* (wfact-1) / 3 puts the default-factor-30
- transition point at very roughly the same place as
- with v0.1 and v0.9.0.
+ transition point at very roughly the same place as
+ with v0.1 and v0.9.0.
Not that it particularly matters any more, since the
resulting compressed stream is now the same regardless
of whether or not we use the main sort or fallback sort.
budget = budgetInit;
mainSort ( ptr, block, quadrant, ftab, nblock, verb, &budget );
- if (verb >= 3)
+ if (verb >= 3)
VPrintf3 ( " %d work, %d block, ratio %5.2f\n",
budgetInit - budget,
- nblock,
+ nblock,
(float)(budgetInit - budget) /
- (float)(nblock==0 ? 1 : nblock) );
+ (float)(nblock==0 ? 1 : nblock) );
if (budget < 0) {
- if (verb >= 2)
+ if (verb >= 2)
VPrintf0 ( " too repetitive; using fallback"
" sorting algorithm\n" );
fallbackSort ( s->arr1, s->arr2, ftab, nblock, verb );
blob - 849c8ff00a3c578b4ba8389f771878f61caf7d07
blob + cd3509342d35fa47a37955300ab5b88f64fb2e5e
--- src/cmd/bzip2/lib/buffcompress.c
+++ src/cmd/bzip2/lib/buffcompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#include "bzlib_private.h"
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzBuffToBuffCompress)
- ( char* dest,
+int BZ_API(BZ2_bzBuffToBuffCompress)
+ ( char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int blockSize100k,
- int verbosity,
+ int blockSize100k,
+ int verbosity,
int workFactor )
{
bz_stream strm;
int ret;
- if (dest == NULL || destLen == NULL ||
+ if (dest == NULL || destLen == NULL ||
source == NULL ||
blockSize100k < 1 || blockSize100k > 9 ||
verbosity < 0 || verbosity > 4 ||
- workFactor < 0 || workFactor > 250)
+ workFactor < 0 || workFactor > 250)
return BZ_PARAM_ERROR;
if (workFactor == 0) workFactor = 30;
strm.bzalloc = NULL;
strm.bzfree = NULL;
strm.opaque = NULL;
- ret = BZ2_bzCompressInit ( &strm, blockSize100k,
+ ret = BZ2_bzCompressInit ( &strm, blockSize100k,
verbosity, workFactor );
if (ret != BZ_OK) return ret;
if (ret != BZ_STREAM_END) goto errhandler;
/* normal termination */
- *destLen -= strm.avail_out;
+ *destLen -= strm.avail_out;
BZ2_bzCompressEnd ( &strm );
return BZ_OK;
BZ2_bzCompressEnd ( &strm );
return ret;
}
-
blob - 944166f3f9fb7c4c8c44b7ba7d3f6160ca25aa0d
blob + 47492470939609644c30fdf3d11f28011b11c844
--- src/cmd/bzip2/lib/buffdecompress.c
+++ src/cmd/bzip2/lib/buffdecompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#include "bzlib_private.h"
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzBuffToBuffDecompress)
- ( char* dest,
+int BZ_API(BZ2_bzBuffToBuffDecompress)
+ ( char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
int small,
int verbosity )
bz_stream strm;
int ret;
- if (dest == NULL || destLen == NULL ||
+ if (dest == NULL || destLen == NULL ||
source == NULL ||
(small != 0 && small != 1) ||
- verbosity < 0 || verbosity > 4)
+ verbosity < 0 || verbosity > 4)
return BZ_PARAM_ERROR;
strm.bzalloc = NULL;
} else {
BZ2_bzDecompressEnd ( &strm );
return BZ_OUTBUFF_FULL;
- };
+ };
errhandler:
BZ2_bzDecompressEnd ( &strm );
- return ret;
+ return ret;
}
-
-
blob - 56d58fc245a0511686d31b3711f3ecaa457d6143
blob + 8a578bd0285a8342ac750efd403825bcbe721e6c
--- src/cmd/bzip2/lib/bzassert.c
+++ src/cmd/bzip2/lib/bzassert.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
void BZ2_bz__AssertH__fail ( int errcode )
{
- fprintf(stderr,
+ fprintf(stderr,
"\n\nbzip2/libbzip2: internal error number %d.\n"
"This is a bug in bzip2/libbzip2, %s.\n"
"Please report it to me at: jseward@acm.org. If this happened\n"
blob - 849c8ff00a3c578b4ba8389f771878f61caf7d07
blob + cd3509342d35fa47a37955300ab5b88f64fb2e5e
--- src/cmd/bzip2/lib/bzbuffcompress.c
+++ src/cmd/bzip2/lib/bzbuffcompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#include "bzlib_private.h"
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzBuffToBuffCompress)
- ( char* dest,
+int BZ_API(BZ2_bzBuffToBuffCompress)
+ ( char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int blockSize100k,
- int verbosity,
+ int blockSize100k,
+ int verbosity,
int workFactor )
{
bz_stream strm;
int ret;
- if (dest == NULL || destLen == NULL ||
+ if (dest == NULL || destLen == NULL ||
source == NULL ||
blockSize100k < 1 || blockSize100k > 9 ||
verbosity < 0 || verbosity > 4 ||
- workFactor < 0 || workFactor > 250)
+ workFactor < 0 || workFactor > 250)
return BZ_PARAM_ERROR;
if (workFactor == 0) workFactor = 30;
strm.bzalloc = NULL;
strm.bzfree = NULL;
strm.opaque = NULL;
- ret = BZ2_bzCompressInit ( &strm, blockSize100k,
+ ret = BZ2_bzCompressInit ( &strm, blockSize100k,
verbosity, workFactor );
if (ret != BZ_OK) return ret;
if (ret != BZ_STREAM_END) goto errhandler;
/* normal termination */
- *destLen -= strm.avail_out;
+ *destLen -= strm.avail_out;
BZ2_bzCompressEnd ( &strm );
return BZ_OK;
BZ2_bzCompressEnd ( &strm );
return ret;
}
-
blob - d27e67573c513d918a120d4b5665ae44f81371b5
blob + 7f3deec0e1504f7901c60f8c046862ce087bcfbf
--- src/cmd/bzip2/lib/bzcompress.c
+++ src/cmd/bzip2/lib/bzcompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzCompressInit)
- ( bz_stream* strm,
+int BZ_API(BZ2_bzCompressInit)
+ ( bz_stream* strm,
int blockSize100k,
int verbosity,
int workFactor )
if (!bz_config_ok()) return BZ_CONFIG_ERROR;
- if (strm == NULL ||
+ if (strm == NULL ||
blockSize100k < 1 || blockSize100k > 9 ||
workFactor < 0 || workFactor > 250)
return BZ_PARAM_ERROR;
/*-- no input? --*/
if (s->strm->avail_in == 0) break;
progress_in = True;
- ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
+ ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
s->strm->next_in++;
s->strm->avail_in--;
s->strm->total_in_lo32++;
/*-- flush/finish end? --*/
if (s->avail_in_expect == 0) break;
progress_in = True;
- ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
+ ADD_CHAR_TO_BLOCK ( s, (UInt32)(*((UChar*)(s->strm->next_in))) );
s->strm->next_in++;
s->strm->avail_in--;
s->strm->total_in_lo32++;
Bool progress_in = False;
Bool progress_out = False;
EState* s = strm->state;
-
+
while (True) {
if (s->state == BZ_S_OUTPUT) {
progress_out |= copy_output_until_stop ( s );
if (s->state_out_pos < s->numZ) break;
- if (s->mode == BZ_M_FINISHING &&
+ if (s->mode == BZ_M_FINISHING &&
s->avail_in_expect == 0 &&
isempty_RL(s)) break;
prepare_new_block ( s );
s->state = BZ_S_INPUT;
- if (s->mode == BZ_M_FLUSHING &&
+ if (s->mode == BZ_M_FLUSHING &&
s->avail_in_expect == 0 &&
isempty_RL(s)) break;
}
if (action == BZ_RUN) {
progress = handle_compress ( strm );
return progress ? BZ_RUN_OK : BZ_PARAM_ERROR;
- }
+ }
else
if (action == BZ_FLUSH) {
s->avail_in_expect = strm->avail_in;
s->mode = BZ_M_FINISHING;
goto preswitch;
}
- else
+ else
return BZ_PARAM_ERROR;
case BZ_M_FLUSHING:
if (action != BZ_FLUSH) return BZ_SEQUENCE_ERROR;
- if (s->avail_in_expect != s->strm->avail_in)
+ if (s->avail_in_expect != s->strm->avail_in)
return BZ_SEQUENCE_ERROR;
progress = handle_compress ( strm );
if (!progress) return BZ_SEQUENCE_ERROR; /*rsc added */
case BZ_M_FINISHING:
if (action != BZ_FINISH) return BZ_SEQUENCE_ERROR;
- if (s->avail_in_expect != s->strm->avail_in)
+ if (s->avail_in_expect != s->strm->avail_in)
return BZ_SEQUENCE_ERROR;
progress = handle_compress ( strm );
if (!progress) return BZ_SEQUENCE_ERROR;
if (s->ftab != NULL) BZFREE(s->ftab);
BZFREE(strm->state);
- strm->state = NULL;
+ strm->state = NULL;
return BZ_OK;
}
-
blob - 25ed925360f273179b360a56e590f5c50f648ad5
blob + da3251fbeb88042548e7f40c7a758a00e25b3c11
--- src/cmd/bzip2/lib/bzdecompress.c
+++ src/cmd/bzip2/lib/bzdecompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
/*---------------------------------------------------*/
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzDecompressInit)
- ( bz_stream* strm,
+int BZ_API(BZ2_bzDecompressInit)
+ ( bz_stream* strm,
int verbosity,
int small )
{
s->strm->total_out_lo32++;
if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
}
-
+
/* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return;
-
-
+
+
s->state_out_len = 1;
s->state_out_ch = s->k0;
- BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 2;
- BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 3;
- BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
- BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
+
+ BZ_GET_FAST(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
s->state_out_len = ((Int32)k1) + 4;
- BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
+ BZ_GET_FAST(s->k0); BZ_RAND_UPD_MASK;
s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
}
}
s_state_out_len_eq_one:
{
- if (cs_avail_out == 0) {
+ if (cs_avail_out == 0) {
c_state_out_len = 1; goto return_notr;
};
*( (UChar*)(cs_next_out) ) = c_state_out_ch;
cs_next_out++;
cs_avail_out--;
}
- }
+ }
/* can a new run be started? */
if (c_nblock_used == s_save_nblockPP) {
c_state_out_len = 0; goto return_notr;
- };
+ };
c_state_out_ch = c_k0;
BZ_GET_FAST_C(k1); c_nblock_used++;
- if (k1 != c_k0) {
- c_k0 = k1; goto s_state_out_len_eq_one;
+ if (k1 != c_k0) {
+ c_k0 = k1; goto s_state_out_len_eq_one;
};
- if (c_nblock_used == s_save_nblockPP)
+ if (c_nblock_used == s_save_nblockPP)
goto s_state_out_len_eq_one;
-
+
c_state_out_len = 2;
BZ_GET_FAST_C(k1); c_nblock_used++;
if (c_nblock_used == s_save_nblockPP) continue;
if (k1 != c_k0) { c_k0 = k1; continue; };
-
+
c_state_out_len = 3;
BZ_GET_FAST_C(k1); c_nblock_used++;
if (c_nblock_used == s_save_nblockPP) continue;
if (k1 != c_k0) { c_k0 = k1; continue; };
-
+
BZ_GET_FAST_C(k1); c_nblock_used++;
c_state_out_len = ((Int32)k1) + 4;
BZ_GET_FAST_C(c_k0); c_nblock_used++;
s->strm->total_out_lo32++;
if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
}
-
+
/* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return;
-
-
+
+
s->state_out_len = 1;
s->state_out_ch = s->k0;
- BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 2;
- BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 3;
- BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+ BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
- BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
+
+ BZ_GET_SMALL(k1); BZ_RAND_UPD_MASK;
k1 ^= BZ_RAND_MASK; s->nblock_used++;
s->state_out_len = ((Int32)k1) + 4;
- BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
+ BZ_GET_SMALL(s->k0); BZ_RAND_UPD_MASK;
s->k0 ^= BZ_RAND_MASK; s->nblock_used++;
}
s->strm->total_out_lo32++;
if (s->strm->total_out_lo32 == 0) s->strm->total_out_hi32++;
}
-
+
/* can a new run be started? */
if (s->nblock_used == s->save_nblock+1) return;
-
+
s->state_out_len = 1;
s->state_out_ch = s->k0;
BZ_GET_SMALL(k1); s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 2;
BZ_GET_SMALL(k1); s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
s->state_out_len = 3;
BZ_GET_SMALL(k1); s->nblock_used++;
if (s->nblock_used == s->save_nblock+1) continue;
if (k1 != s->k0) { s->k0 = k1; continue; };
-
+
BZ_GET_SMALL(k1); s->nblock_used++;
s->state_out_len = ((Int32)k1) + 4;
BZ_GET_SMALL(s->k0); s->nblock_used++;
unRLE_obuf_to_output_FAST ( s );
if (s->nblock_used == s->save_nblock+1 && s->state_out_len == 0) {
BZ_FINALISE_CRC ( s->calculatedBlockCRC );
- if (s->verbosity >= 3)
- VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
+ if (s->verbosity >= 3)
+ VPrintf2 ( " {0x%x, 0x%x}", s->storedBlockCRC,
s->calculatedBlockCRC );
if (s->verbosity >= 2) VPrintf0 ( "]" );
if (s->calculatedBlockCRC != s->storedBlockCRC)
return BZ_DATA_ERROR;
- s->calculatedCombinedCRC
- = (s->calculatedCombinedCRC << 1) |
+ s->calculatedCombinedCRC
+ = (s->calculatedCombinedCRC << 1) |
(s->calculatedCombinedCRC >> 31);
s->calculatedCombinedCRC ^= s->calculatedBlockCRC;
s->state = BZ_X_BLKHDR_1;
Int32 r = BZ2_decompress ( s );
if (r == BZ_STREAM_END) {
if (s->verbosity >= 3)
- VPrintf2 ( "\n combined CRCs: stored = 0x%x, computed = 0x%x",
+ VPrintf2 ( "\n combined CRCs: stored = 0x%x, computed = 0x%x",
s->storedCombinedCRC, s->calculatedCombinedCRC );
if (s->calculatedCombinedCRC != s->storedCombinedCRC)
return BZ_DATA_ERROR;
/*
AssertH ( 0, 6001 );
- return 0;
+ return 0;
*/
}
return BZ_OK;
}
-
blob - 74e1f88da69cc674ce9ad5ef225cbd334dc96110
blob + c96974daed724b4fe451fafd06ac1f60d981d7ae
--- src/cmd/bzip2/lib/bzfeof.c
+++ src/cmd/bzip2/lib/bzfeof.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
ungetc ( c, f );
return False;
}
-
blob - 66b89a2e8f9cf9b7cb03c5d94493a78fd4ac2323
blob + 12a4bf90f6540d99602bca3f166c15614be24b95
--- src/cmd/bzip2/lib/bzlib.c
+++ src/cmd/bzip2/lib/bzlib.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
blob - 0ece4e8a6d29fd4564a875c5d1f8902536f89fb1
blob + fae78bcbd9f425f5a4a4924759ba1bb6970f2c49
--- src/cmd/bzip2/lib/bzlib.h
+++ src/cmd/bzip2/lib/bzlib.h
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#define BZ_OUTBUFF_FULL (-8)
#define BZ_CONFIG_ERROR (-9)
-typedef
+typedef
struct {
char *next_in;
unsigned int avail_in;
void *(*bzalloc)(void *,int,int);
void (*bzfree)(void *,void *);
void *opaque;
- }
+ }
bz_stream;
/*-- Core (low-level) library functions --*/
-BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
- bz_stream* strm,
- int blockSize100k,
- int verbosity,
- int workFactor
+BZ_EXTERN int BZ_API(BZ2_bzCompressInit) (
+ bz_stream* strm,
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN int BZ_API(BZ2_bzCompress) (
- bz_stream* strm,
- int action
+BZ_EXTERN int BZ_API(BZ2_bzCompress) (
+ bz_stream* strm,
+ int action
);
-BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
- bz_stream* strm
+BZ_EXTERN int BZ_API(BZ2_bzCompressEnd) (
+ bz_stream* strm
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
- bz_stream *strm,
- int verbosity,
+BZ_EXTERN int BZ_API(BZ2_bzDecompressInit) (
+ bz_stream *strm,
+ int verbosity,
int small
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
- bz_stream* strm
+BZ_EXTERN int BZ_API(BZ2_bzDecompress) (
+ bz_stream* strm
);
-BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
- bz_stream *strm
+BZ_EXTERN int BZ_API(BZ2_bzDecompressEnd) (
+ bz_stream *strm
);
/*-- Utility functions --*/
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
- char* dest,
+BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffCompress) (
+ char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int blockSize100k,
- int verbosity,
- int workFactor
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
- char* dest,
+BZ_EXTERN int BZ_API(BZ2_bzBuffToBuffDecompress) (
+ char* dest,
unsigned int* destLen,
- char* source,
+ char* source,
unsigned int sourceLen,
- int small,
- int verbosity
+ int small,
+ int verbosity
);
blob - ad57870636f349cdd6aa37671dc74a22e50d2ee5
blob + 002d79b3285dd5b2275fbf4ae1b72143d9a49675
--- src/cmd/bzip2/lib/bzlib_private.h
+++ src/cmd/bzip2/lib/bzlib_private.h
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#ifndef __GNUC__
#define __inline__ /* */
-#endif
+#endif
/* these #defines can be overridden by bzlib_stdio.h */
extern void bz_internal_error ( int errcode );
/*-- externs for compression. --*/
-extern void
+extern void
BZ2_blockSort ( EState* );
-extern void
+extern void
BZ2_compressBlock ( EState*, Bool );
-extern void
+extern void
BZ2_bsInitWrite ( EState* );
-extern void
+extern void
BZ2_hbAssignCodes ( Int32*, UChar*, Int32, Int32, Int32 );
-extern void
+extern void
BZ2_hbMakeCodeLengths ( UChar*, Int32*, Int32, Int32 );
Int32 save_N;
Int32 save_curr;
Int32 save_zt;
- Int32 save_zn;
+ Int32 save_zn;
Int32 save_zvec;
Int32 save_zj;
Int32 save_gSel;
/*-- externs for decompression. --*/
-extern Int32
+extern Int32
BZ2_indexIntoF ( Int32, Int32* );
-extern Int32
+extern Int32
BZ2_decompress ( DState* );
-extern void
+extern void
BZ2_hbCreateDecodeTables ( Int32*, Int32*, Int32*, UChar*,
Int32, Int32, Int32 );
blob - 30d41d998462a2685456658c5a5ee3ec6b6a1178
blob + 18805f0ba953006b680a1a996cb114efb8913418
--- src/cmd/bzip2/lib/bzlib_stdio.h
+++ src/cmd/bzip2/lib/bzlib_stdio.h
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
int fd,
const char *mode
);
-
+
BZ_EXTERN int BZ_API(BZ2_bzread) (
- BZFILE* b,
- void* buf,
- int len
+ BZFILE* b,
+ void* buf,
+ int len
);
BZ_EXTERN int BZ_API(BZ2_bzwrite) (
- BZFILE* b,
- void* buf,
- int len
+ BZFILE* b,
+ void* buf,
+ int len
);
BZ_EXTERN int BZ_API(BZ2_bzflush) (
);
BZ_EXTERN const char * BZ_API(BZ2_bzerror) (
- BZFILE *b,
+ BZFILE *b,
int *errnum
);
/*-- High(er) level library functions --*/
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
- int* bzerror,
- FILE* f,
- int verbosity,
+BZ_EXTERN BZFILE* BZ_API(BZ2_bzReadOpen) (
+ int* bzerror,
+ FILE* f,
+ int verbosity,
int small,
- void* unused,
- int nUnused
+ void* unused,
+ int nUnused
);
-BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
- int* bzerror,
- BZFILE* b
+BZ_EXTERN void BZ_API(BZ2_bzReadClose) (
+ int* bzerror,
+ BZFILE* b
);
-BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
- int* bzerror,
- BZFILE* b,
- void** unused,
- int* nUnused
+BZ_EXTERN void BZ_API(BZ2_bzReadGetUnused) (
+ int* bzerror,
+ BZFILE* b,
+ void** unused,
+ int* nUnused
);
-BZ_EXTERN int BZ_API(BZ2_bzRead) (
- int* bzerror,
- BZFILE* b,
- void* buf,
- int len
+BZ_EXTERN int BZ_API(BZ2_bzRead) (
+ int* bzerror,
+ BZFILE* b,
+ void* buf,
+ int len
);
-BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
- int* bzerror,
- FILE* f,
- int blockSize100k,
- int verbosity,
- int workFactor
+BZ_EXTERN BZFILE* BZ_API(BZ2_bzWriteOpen) (
+ int* bzerror,
+ FILE* f,
+ int blockSize100k,
+ int verbosity,
+ int workFactor
);
-BZ_EXTERN void BZ_API(BZ2_bzWrite) (
- int* bzerror,
- BZFILE* b,
- void* buf,
- int len
+BZ_EXTERN void BZ_API(BZ2_bzWrite) (
+ int* bzerror,
+ BZFILE* b,
+ void* buf,
+ int len
);
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
- int* bzerror,
- BZFILE* b,
- int abandon,
- unsigned int* nbytes_in,
- unsigned int* nbytes_out
+BZ_EXTERN void BZ_API(BZ2_bzWriteClose) (
+ int* bzerror,
+ BZFILE* b,
+ int abandon,
+ unsigned int* nbytes_in,
+ unsigned int* nbytes_out
);
-BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
- int* bzerror,
- BZFILE* b,
- int abandon,
- unsigned int* nbytes_in_lo32,
- unsigned int* nbytes_in_hi32,
- unsigned int* nbytes_out_lo32,
+BZ_EXTERN void BZ_API(BZ2_bzWriteClose64) (
+ int* bzerror,
+ BZFILE* b,
+ int abandon,
+ unsigned int* nbytes_in_lo32,
+ unsigned int* nbytes_in_hi32,
+ unsigned int* nbytes_out_lo32,
unsigned int* nbytes_out_hi32
);
-
blob - 24b3114436cbd8c1a1a3007e2382f524c8e111f1
blob + caacf36a19dd01c866ff303ccae9cc0ff26eda33
--- src/cmd/bzip2/lib/bzlib_stdio_private.h
+++ src/cmd/bzip2/lib/bzlib_stdio_private.h
if (bzf != NULL) bzf->lastErr = eee; \
}
-typedef
+typedef
struct {
FILE* handle;
Char buf[BZ_MAX_UNUSED];
bzFile;
extern Bool bz_feof( FILE* );
-
blob - 8bd03888d0e7f2a91391b287a66c306c84064eec
blob + e523d249cea3223226bbda2d05eb9ebf25fbdad4
--- src/cmd/bzip2/lib/bzread.c
+++ src/cmd/bzip2/lib/bzread.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#include "bzlib_stdio_private.h"
/*---------------------------------------------------*/
-BZFILE* BZ_API(BZ2_bzReadOpen)
- ( int* bzerror,
- FILE* f,
+BZFILE* BZ_API(BZ2_bzReadOpen)
+ ( int* bzerror,
+ FILE* f,
int verbosity,
int small,
void* unused,
BZ_SETERR(BZ_OK);
- if (f == NULL ||
+ if (f == NULL ||
(small != 0 && small != 1) ||
(verbosity < 0 || verbosity > 4) ||
(unused == NULL && nUnused != 0) ||
{ BZ_SETERR(BZ_IO_ERROR); return NULL; };
bzf = malloc ( sizeof(bzFile) );
- if (bzf == NULL)
+ if (bzf == NULL)
{ BZ_SETERR(BZ_MEM_ERROR); return NULL; };
BZ_SETERR(BZ_OK);
bzf->strm.bzalloc = NULL;
bzf->strm.bzfree = NULL;
bzf->strm.opaque = NULL;
-
+
while (nUnused > 0) {
bzf->buf[bzf->bufN] = *((UChar*)(unused)); bzf->bufN++;
unused = ((void*)( 1 + ((UChar*)(unused)) ));
bzf->strm.next_in = bzf->buf;
bzf->initialisedOk = True;
- return bzf;
+ return bzf;
}
/*---------------------------------------------------*/
-int BZ_API(BZ2_bzRead)
- ( int* bzerror,
- BZFILE* b,
- void* buf,
+int BZ_API(BZ2_bzRead)
+ ( int* bzerror,
+ BZFILE* b,
+ void* buf,
int len )
{
Int32 n, ret;
while (True) {
- if (ferror(bzf->handle))
+ if (ferror(bzf->handle))
{ BZ_SETERR(BZ_IO_ERROR); return 0; };
if (bzf->strm.avail_in == 0 && !bz_feof(bzf->handle)) {
- n = fread ( bzf->buf, sizeof(UChar),
+ n = fread ( bzf->buf, sizeof(UChar),
BZ_MAX_UNUSED, bzf->handle );
if (ferror(bzf->handle))
{ BZ_SETERR(BZ_IO_ERROR); return 0; };
if (ret != BZ_OK && ret != BZ_STREAM_END)
{ BZ_SETERR(ret); return 0; };
- if (ret == BZ_OK && bz_feof(bzf->handle) &&
+ if (ret == BZ_OK && bz_feof(bzf->handle) &&
bzf->strm.avail_in == 0 && bzf->strm.avail_out > 0)
{ BZ_SETERR(BZ_UNEXPECTED_EOF); return 0; };
return len - bzf->strm.avail_out; };
if (bzf->strm.avail_out == 0)
{ BZ_SETERR(BZ_OK); return len; };
-
+
}
/* return 0; not reached*/
/*---------------------------------------------------*/
-void BZ_API(BZ2_bzReadGetUnused)
- ( int* bzerror,
- BZFILE* b,
- void** unused,
+void BZ_API(BZ2_bzReadGetUnused)
+ ( int* bzerror,
+ BZFILE* b,
+ void** unused,
int* nUnused )
{
bzFile* bzf = (bzFile*)b;
blob - 3e1f2de504e91c7d1e37c694fd24bc7499a35fe1
blob + 31b0a768894047d236df01590f805f4ead50e0ec
--- src/cmd/bzip2/lib/bzstdio.c
+++ src/cmd/bzip2/lib/bzstdio.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
ungetc ( c, f );
return False;
}
-
blob - 5320144b26eef4ca3b03918de333c346e9d029b6
blob + 601d0c91edd7f80aa62335b838e2997277cc3af9
--- src/cmd/bzip2/lib/bzversion.c
+++ src/cmd/bzip2/lib/bzversion.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
{
return BZ_VERSION;
}
-
blob - a37a66bab29667409394c317de29d0433f349f12
blob + 086b6e2d0b792ae2bf27862542666b27e1deb3cc
--- src/cmd/bzip2/lib/bzwrite.c
+++ src/cmd/bzip2/lib/bzwrite.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
#include "bzlib_stdio_private.h"
/*---------------------------------------------------*/
-BZFILE* BZ_API(BZ2_bzWriteOpen)
- ( int* bzerror,
- FILE* f,
- int blockSize100k,
+BZFILE* BZ_API(BZ2_bzWriteOpen)
+ ( int* bzerror,
+ FILE* f,
+ int blockSize100k,
int verbosity,
int workFactor )
{
bzf->strm.opaque = NULL;
if (workFactor == 0) workFactor = 30;
- ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
+ ret = BZ2_bzCompressInit ( &(bzf->strm), blockSize100k,
verbosity, workFactor );
if (ret != BZ_OK)
{ BZ_SETERR(ret); free(bzf); return NULL; };
bzf->strm.avail_in = 0;
bzf->initialisedOk = True;
- return bzf;
+ return bzf;
}
/*---------------------------------------------------*/
void BZ_API(BZ2_bzWrite)
- ( int* bzerror,
- BZFILE* b,
- void* buf,
+ ( int* bzerror,
+ BZFILE* b,
+ void* buf,
int len )
{
Int32 n, n2, ret;
if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
n = BZ_MAX_UNUSED - bzf->strm.avail_out;
- n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
+ n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
n, bzf->handle );
if (n != n2 || ferror(bzf->handle))
{ BZ_SETERR(BZ_IO_ERROR); return; };
/*---------------------------------------------------*/
void BZ_API(BZ2_bzWriteClose)
- ( int* bzerror,
- BZFILE* b,
+ ( int* bzerror,
+ BZFILE* b,
int abandon,
unsigned int* nbytes_in,
unsigned int* nbytes_out )
{
- BZ2_bzWriteClose64 ( bzerror, b, abandon,
+ BZ2_bzWriteClose64 ( bzerror, b, abandon,
nbytes_in, NULL, nbytes_out, NULL );
}
void BZ_API(BZ2_bzWriteClose64)
- ( int* bzerror,
- BZFILE* b,
+ ( int* bzerror,
+ BZFILE* b,
int abandon,
unsigned int* nbytes_in_lo32,
unsigned int* nbytes_in_hi32,
if (bzf->strm.avail_out < BZ_MAX_UNUSED) {
n = BZ_MAX_UNUSED - bzf->strm.avail_out;
- n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
+ n2 = fwrite ( (void*)(bzf->buf), sizeof(UChar),
n, bzf->handle );
if (n != n2 || ferror(bzf->handle))
{ BZ_SETERR(BZ_IO_ERROR); return; };
BZ2_bzCompressEnd ( &(bzf->strm) );
free ( bzf );
}
-
blob - 87b6912890af79a7e931fdc99a5c6e9d3438d047
blob + 56b0b7dea50d96660b12ec734317d03bb917ee15
--- src/cmd/bzip2/lib/bzzlib.c
+++ src/cmd/bzip2/lib/bzzlib.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
int verbosity = 0;
int workFactor = 30;
int smallMode = 0;
- int nUnused = 0;
+ int nUnused = 0;
if (mode == NULL) return NULL;
while (*mode) {
if (writing) {
/* Guard against total chaos and anarchy -- JRS */
if (blockSize100k < 1) blockSize100k = 1;
- if (blockSize100k > 9) blockSize100k = 9;
+ if (blockSize100k > 9) blockSize100k = 9;
bzfp = BZ2_bzWriteOpen(&bzerr,fp,blockSize100k,
verbosity,workFactor);
} else {
{
int bzerr;
FILE *fp = ((bzFile *)b)->handle;
-
+
if (b==NULL) {return;}
if(((bzFile*)b)->writing){
BZ2_bzWriteClose(&bzerr,b,0,NULL,NULL);
/*---------------------------------------------------*/
/*--
- return last error code
+ return last error code
--*/
static char *bzerrorstrings[] = {
"OK"
blob - 96c5591838ab1593fb8a40cbbb2ce28a8462dec7
blob + c7a1aa80bedc28978b2b8159eb6593fb499b48c4
--- src/cmd/bzip2/lib/compress.c
+++ src/cmd/bzip2/lib/compress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
0.9.0a/b -- no changes in this file.
0.9.0c
- * changed setting of nGroups in sendMTFValues() so as to
+ * changed setting of nGroups in sendMTFValues() so as to
do a bit better on small files
--*/
Int32 wr;
Int32 EOB;
- /*
+ /*
After sorting (eg, here),
s->arr1 [ 0 .. s->nblock-1 ] holds sorted order,
and
- ((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
+ ((UChar*)s->arr2) [ 0 .. s->nblock-1 ]
holds the original block data.
The first thing to do is generate the MTF values,
(UChar*) (&((UChar*)s->arr2)[s->nblock])
These storage aliases are set up in bzCompressInit(),
- except for the last one, which is arranged in
+ except for the last one, which is arranged in
compressBlock().
*/
UInt32* ptr = s->ptr;
ll_i = s->unseqToSeq[block[j]];
AssertD ( ll_i < s->nInUse, "generateMTFValues(2a)" );
- if (yy[0] == ll_i) {
+ if (yy[0] == ll_i) {
zPend++;
} else {
zPend--;
while (True) {
if (zPend & 1) {
- mtfv[wr] = BZ_RUNB; wr++;
- s->mtfFreq[BZ_RUNB]++;
+ mtfv[wr] = BZ_RUNB; wr++;
+ s->mtfFreq[BZ_RUNB]++;
} else {
- mtfv[wr] = BZ_RUNA; wr++;
- s->mtfFreq[BZ_RUNA]++;
+ mtfv[wr] = BZ_RUNA; wr++;
+ s->mtfFreq[BZ_RUNA]++;
}
if (zPend < 2) break;
zPend = (zPend - 2) / 2;
zPend--;
while (True) {
if (zPend & 1) {
- mtfv[wr] = BZ_RUNB; wr++;
- s->mtfFreq[BZ_RUNB]++;
+ mtfv[wr] = BZ_RUNB; wr++;
+ s->mtfFreq[BZ_RUNB]++;
} else {
- mtfv[wr] = BZ_RUNA; wr++;
- s->mtfFreq[BZ_RUNA]++;
+ mtfv[wr] = BZ_RUNA; wr++;
+ s->mtfFreq[BZ_RUNA]++;
}
if (zPend < 2) break;
zPend = (zPend - 2) / 2;
if (s->verbosity >= 3)
VPrintf3( " %d in block, %d after MTF & 1-2 coding, "
- "%d+2 syms in use\n",
+ "%d+2 syms in use\n",
s->nblock, s->nMTF, s->nInUse );
alphaSize = s->nInUse+2;
nGroups = 6;
/*--- Generate an initial set of coding tables ---*/
- {
+ {
Int32 nPart, remF, tFreq, aFreq;
nPart = nGroups;
aFreq += s->mtfFreq[ge];
}
- if (ge > gs
- && nPart != nGroups && nPart != 1
+ if (ge > gs
+ && nPart != nGroups && nPart != 1
&& ((nGroups-nPart) % 2 == 1)) {
aFreq -= s->mtfFreq[ge];
ge--;
if (s->verbosity >= 3)
VPrintf5( " initial group %d, [%d .. %d], "
"has %d syms (%4.1f%%)\n",
- nPart, gs, ge, aFreq,
- (100.0 * (float)aFreq) / (float)(s->nMTF) );
-
+ nPart, gs, ge, aFreq,
+ (100.0 * (float)aFreq) / (float)(s->nMTF) );
+
for (v = 0; v < alphaSize; v++)
- if (v >= gs && v <= ge)
+ if (v >= gs && v <= ge)
s->len[nPart-1][v] = BZ_LESSER_ICOST; else
s->len[nPart-1][v] = BZ_GREATER_ICOST;
-
+
nPart--;
gs = ge+1;
remF -= aFreq;
}
}
- /*---
+ /*---
Iterate up to BZ_N_ITERS times to improve the tables.
---*/
nSelectors = 40000; /* shut up some compilers' warnings about used and not set */
/*---
Set up an auxiliary length table which is used to fast-track
- the common case (nGroups == 6).
+ the common case (nGroups == 6).
---*/
if (nGroups == 6) {
for (v = 0; v < alphaSize; v++) {
/*--- Set group start & end marks. --*/
if (gs >= s->nMTF) break;
- ge = gs + BZ_G_SIZE - 1;
+ ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
- /*--
+ /*--
Calculate the cost of this group as coded
by each of the coding tables.
--*/
} else {
/*--- slow version which correctly handles all situations ---*/
- for (i = gs; i <= ge; i++) {
+ for (i = gs; i <= ge; i++) {
UInt16 icv = mtfv[i];
for (t = 0; t < nGroups; t++) cost[t] += s->len[t][icv];
}
}
-
- /*--
+
+ /*--
Find the coding table which is best for this group,
and record its identity in the selector table.
--*/
s->selector[nSelectors] = bt;
nSelectors++;
- /*--
+ /*--
Increment the symbol frequencies for the selected table.
--*/
if (nGroups == 6 && 50 == ge-gs+1) {
gs = ge+1;
}
if (s->verbosity >= 3) {
- VPrintf2 ( " pass %d: size is %d, grp uses are ",
+ VPrintf2 ( " pass %d: size is %d, grp uses are ",
iter+1, totc/8 );
for (t = 0; t < nGroups; t++)
VPrintf1 ( "%d ", fave[t] );
Recompute the tables based on the accumulated frequencies.
--*/
for (t = 0; t < nGroups; t++)
- BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
+ BZ2_hbMakeCodeLengths ( &(s->len[t][0]), &(s->rfreq[t][0]),
alphaSize, 20 );
}
}
AssertH ( !(maxLen > 20), 3004 );
AssertH ( !(minLen < 1), 3005 );
- BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
+ BZ2_hbAssignCodes ( &(s->code[t][0]), &(s->len[t][0]),
minLen, maxLen, alphaSize );
}
/*--- Transmit the mapping table. ---*/
- {
+ {
Bool inUse16[16];
for (i = 0; i < 16; i++) {
inUse16[i] = False;
for (j = 0; j < 16; j++)
if (s->inUse[i * 16 + j]) inUse16[i] = True;
}
-
+
nBytes = s->numZ;
for (i = 0; i < 16; i++)
if (inUse16[i]) bsW(s,1,1); else bsW(s,1,0);
if (s->inUse[i * 16 + j]) bsW(s,1,1); else bsW(s,1,0);
}
- if (s->verbosity >= 3)
+ if (s->verbosity >= 3)
VPrintf1( " bytes: mapping %d, ", s->numZ-nBytes );
}
nBytes = s->numZ;
bsW ( s, 3, nGroups );
bsW ( s, 15, nSelectors );
- for (i = 0; i < nSelectors; i++) {
+ for (i = 0; i < nSelectors; i++) {
for (j = 0; j < s->selectorMtf[i]; j++) bsW(s,1,1);
bsW(s,1,0);
}
gs = 0;
while (True) {
if (gs >= s->nMTF) break;
- ge = gs + BZ_G_SIZE - 1;
+ ge = gs + BZ_G_SIZE - 1;
if (ge >= s->nMTF) ge = s->nMTF-1;
AssertH ( s->selector[selCtr] < nGroups, 3006 );
if (nGroups == 6 && 50 == ge-gs+1) {
/*--- fast track the common case ---*/
UInt16 mtfv_i;
- UChar* s_len_sel_selCtr
+ UChar* s_len_sel_selCtr
= &(s->len[s->selector[selCtr]][0]);
Int32* s_code_sel_selCtr
= &(s->code[s->selector[selCtr]][0]);
} else {
/*--- slow version which correctly handles all situations ---*/
for (i = gs; i <= ge; i++) {
- bsW ( s,
+ bsW ( s,
s->len [s->selector[selCtr]] [mtfv[i]],
s->code [s->selector[selCtr]] [mtfv[i]] );
}
/*-- Now the block's CRC, so it is in a known place. --*/
bsPutUInt32 ( s, s->blockCRC );
- /*--
- Now a single bit indicating (non-)randomisation.
+ /*--
+ Now a single bit indicating (non-)randomisation.
As of version 0.9.5, we use a better sorting algorithm
which makes randomisation unnecessary. So always set
the randomised bit to 'no'. Of course, the decoder
blob - db1eb93f88dbaa1f99c3b95524c60ae93c26dc10
blob + efd1f8fb222f0b278212a3dd844ae68c3da14a99
--- src/cmd/bzip2/lib/crctable.c
+++ src/cmd/bzip2/lib/crctable.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
blob - 734bfee7bdf9cf871bcef3040662254baa173f58
blob + e9f8a59d558affcf774aa420887b3904b05d02e1
--- src/cmd/bzip2/lib/decompress.c
+++ src/cmd/bzip2/lib/decompress.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
Int32 N;
Int32 curr;
Int32 zt;
- Int32 zn;
+ Int32 zn;
Int32 zvec;
Int32 zj;
Int32 gSel;
N = s->save_N;
curr = s->save_curr;
zt = s->save_zt;
- zn = s->save_zn;
+ zn = s->save_zn;
zvec = s->save_zvec;
zj = s->save_zj;
gSel = s->save_gSel;
if (uc != 'h') RETURN(BZ_DATA_ERROR_MAGIC);
GET_BITS(BZ_X_MAGIC_4, s->blockSize100k, 8)
- if (s->blockSize100k < '1' ||
+ if (s->blockSize100k < '1' ||
s->blockSize100k > '9') RETURN(BZ_DATA_ERROR_MAGIC);
s->blockSize100k -= '0';
if (s->smallDecompress) {
s->ll16 = BZALLOC( s->blockSize100k * 100000 * sizeof(UInt16) );
- s->ll4 = BZALLOC(
- ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
+ s->ll4 = BZALLOC(
+ ((1 + s->blockSize100k * 100000) >> 1) * sizeof(UChar)
);
if (s->ll16 == NULL || s->ll4 == NULL) RETURN(BZ_MEM_ERROR);
} else {
s->currBlockNo++;
if (s->verbosity >= 2)
VPrintf1 ( "\n [%d: huff+mtf ", s->currBlockNo );
-
+
s->storedBlockCRC = 0;
GET_UCHAR(BZ_X_BCRC_1, uc);
s->storedBlockCRC = (s->storedBlockCRC << 8) | ((UInt32)uc);
if (s->origPtr < 0)
RETURN(BZ_DATA_ERROR);
- if (s->origPtr > 10 + 100000*s->blockSize100k)
+ if (s->origPtr > 10 + 100000*s->blockSize100k)
RETURN(BZ_DATA_ERROR);
/*--- Receive the mapping table ---*/
for (i = 0; i < 16; i++) {
GET_BIT(BZ_X_MAPPING_1, uc);
- if (uc == 1)
- s->inUse16[i] = True; else
+ if (uc == 1)
+ s->inUse16[i] = True; else
s->inUse16[i] = False;
}
{
UChar pos[BZ_N_GROUPS], tmp, v;
for (v = 0; v < nGroups; v++) pos[v] = v;
-
+
for (i = 0; i < nSelectors; i++) {
v = s->selectorMtf[i];
tmp = pos[v];
if (s->len[t][i] > maxLen) maxLen = s->len[t][i];
if (s->len[t][i] < minLen) minLen = s->len[t][i];
}
- BZ2_hbCreateDecodeTables (
- &(s->limit[t][0]),
- &(s->base[t][0]),
- &(s->perm[t][0]),
+ BZ2_hbCreateDecodeTables (
+ &(s->limit[t][0]),
+ &(s->base[t][0]),
+ &(s->perm[t][0]),
&(s->len[t][0]),
minLen, maxLen, alphaSize
);
s->mtfa[(z)-3] = s->mtfa[(z)-4];
nn -= 4;
}
- while (nn > 0) {
- s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
+ while (nn > 0) {
+ s->mtfa[(pp+nn)] = s->mtfa[(pp+nn)-1]; nn--;
};
s->mtfa[pp] = uc;
- } else {
+ } else {
/* general case */
lno = nn / MTFL_SIZE;
off = nn % MTFL_SIZE;
pp = s->mtfbase[lno] + off;
uc = s->mtfa[pp];
- while (pp > s->mtfbase[lno]) {
- s->mtfa[pp] = s->mtfa[pp-1]; pp--;
+ while (pp > s->mtfbase[lno]) {
+ s->mtfa[pp] = s->mtfa[pp-1]; pp--;
};
s->mtfbase[lno]++;
while (lno > 0) {
s->mtfbase[lno]--;
- s->mtfa[s->mtfbase[lno]]
+ s->mtfa[s->mtfbase[lno]]
= s->mtfa[s->mtfbase[lno-1] + MTFL_SIZE - 1];
lno--;
}
if (s->blockRandomised) {
BZ_RAND_INIT_MASK;
BZ_GET_SMALL(s->k0); s->nblock_used++;
- BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
+ BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
} else {
BZ_GET_SMALL(s->k0); s->nblock_used++;
}
if (s->blockRandomised) {
BZ_RAND_INIT_MASK;
BZ_GET_FAST(s->k0); s->nblock_used++;
- BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
+ BZ_RAND_UPD_MASK; s->k0 ^= BZ_RAND_MASK;
} else {
BZ_GET_FAST(s->k0); s->nblock_used++;
}
s->save_gBase = gBase;
s->save_gPerm = gPerm;
- return retVal;
+ return retVal;
}
blob - 9cad09706ca04fc8582254155f537ed87f99b9a8
blob + 9388ef21326d3cc63d7fbf04e06460d421bbcada
--- src/cmd/bzip2/lib/huffman.c
+++ src/cmd/bzip2/lib/huffman.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
/*---------------------------------------------------*/
-void BZ2_hbMakeCodeLengths ( UChar *len,
+void BZ2_hbMakeCodeLengths ( UChar *len,
Int32 *freq,
Int32 alphaSize,
Int32 maxLen )
Int32 heap [ BZ_MAX_ALPHA_SIZE + 2 ];
Int32 weight [ BZ_MAX_ALPHA_SIZE * 2 ];
- Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
+ Int32 parent [ BZ_MAX_ALPHA_SIZE * 2 ];
for (i = 0; i < alphaSize; i++)
weight[i+1] = (freq[i] == 0 ? 1 : freq[i]) << 8;
}
AssertH( nHeap < (BZ_MAX_ALPHA_SIZE+2), 2001 );
-
+
while (nHeap > 1) {
n1 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
n2 = heap[1]; heap[1] = heap[nHeap]; nHeap--; DOWNHEAP(1);
len[i-1] = j;
if (j > maxLen) tooLong = True;
}
-
+
if (! tooLong) break;
for (i = 1; i < alphaSize; i++) {
blob - aa196a878f91098b919d722a8a6e8c3cb9262b6b
blob + 1236e5d5827e3da70f40f56603b158b39a0c371c
--- src/cmd/bzip2/lib/os.h
+++ src/cmd/bzip2/lib/os.h
typedef unsigned int UInt32;
typedef short Int16;
typedef unsigned short UInt16;
-
+
#define True ((Bool)1)
#define False ((Bool)0)
Only here to avoid probs with 64-bit platforms.
--*/
typedef int IntNative;
-
blob - 2ab1e952d51b666fbd2d6c194da6c62814d2dc10
blob + c6d70773a0a1cbbb1df35954aec50e7f4ea34531
--- src/cmd/bzip2/lib/randtable.c
+++ src/cmd/bzip2/lib/randtable.c
1. Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- 2. The origin of this software must not be misrepresented; you must
- not claim that you wrote the original software. If you use this
- software in a product, an acknowledgment in the product
+ 2. The origin of this software must not be misrepresented; you must
+ not claim that you wrote the original software. If you use this
+ software in a product, an acknowledgment in the product
documentation would be appreciated but is not required.
3. Altered source versions must be plainly marked as such, and must
not be misrepresented as being the original software.
- 4. The name of the author may not be used to endorse or promote
- products derived from this software without specific prior written
+ 4. The name of the author may not be used to endorse or promote
+ products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
/*---------------------------------------------*/
-Int32 BZ2_rNums[512] = {
- 619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
- 985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
- 733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
- 419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
- 878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
- 862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
- 150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
- 170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
- 73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
- 909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
- 641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
- 161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
- 382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
- 98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
- 227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
- 469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
- 184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
- 715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
- 951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
- 652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
- 645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
- 609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
- 653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
- 411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
- 170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
- 857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
- 669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
- 944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
- 344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
- 897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
- 433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
- 686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
- 946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
- 978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
- 680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
- 707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
- 297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
- 134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
- 343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
- 140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
- 170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
- 369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
- 804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
- 896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
- 661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
- 768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
- 61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
- 372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
- 780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
- 920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
- 645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
+Int32 BZ2_rNums[512] = {
+ 619, 720, 127, 481, 931, 816, 813, 233, 566, 247,
+ 985, 724, 205, 454, 863, 491, 741, 242, 949, 214,
+ 733, 859, 335, 708, 621, 574, 73, 654, 730, 472,
+ 419, 436, 278, 496, 867, 210, 399, 680, 480, 51,
+ 878, 465, 811, 169, 869, 675, 611, 697, 867, 561,
+ 862, 687, 507, 283, 482, 129, 807, 591, 733, 623,
+ 150, 238, 59, 379, 684, 877, 625, 169, 643, 105,
+ 170, 607, 520, 932, 727, 476, 693, 425, 174, 647,
+ 73, 122, 335, 530, 442, 853, 695, 249, 445, 515,
+ 909, 545, 703, 919, 874, 474, 882, 500, 594, 612,
+ 641, 801, 220, 162, 819, 984, 589, 513, 495, 799,
+ 161, 604, 958, 533, 221, 400, 386, 867, 600, 782,
+ 382, 596, 414, 171, 516, 375, 682, 485, 911, 276,
+ 98, 553, 163, 354, 666, 933, 424, 341, 533, 870,
+ 227, 730, 475, 186, 263, 647, 537, 686, 600, 224,
+ 469, 68, 770, 919, 190, 373, 294, 822, 808, 206,
+ 184, 943, 795, 384, 383, 461, 404, 758, 839, 887,
+ 715, 67, 618, 276, 204, 918, 873, 777, 604, 560,
+ 951, 160, 578, 722, 79, 804, 96, 409, 713, 940,
+ 652, 934, 970, 447, 318, 353, 859, 672, 112, 785,
+ 645, 863, 803, 350, 139, 93, 354, 99, 820, 908,
+ 609, 772, 154, 274, 580, 184, 79, 626, 630, 742,
+ 653, 282, 762, 623, 680, 81, 927, 626, 789, 125,
+ 411, 521, 938, 300, 821, 78, 343, 175, 128, 250,
+ 170, 774, 972, 275, 999, 639, 495, 78, 352, 126,
+ 857, 956, 358, 619, 580, 124, 737, 594, 701, 612,
+ 669, 112, 134, 694, 363, 992, 809, 743, 168, 974,
+ 944, 375, 748, 52, 600, 747, 642, 182, 862, 81,
+ 344, 805, 988, 739, 511, 655, 814, 334, 249, 515,
+ 897, 955, 664, 981, 649, 113, 974, 459, 893, 228,
+ 433, 837, 553, 268, 926, 240, 102, 654, 459, 51,
+ 686, 754, 806, 760, 493, 403, 415, 394, 687, 700,
+ 946, 670, 656, 610, 738, 392, 760, 799, 887, 653,
+ 978, 321, 576, 617, 626, 502, 894, 679, 243, 440,
+ 680, 879, 194, 572, 640, 724, 926, 56, 204, 700,
+ 707, 151, 457, 449, 797, 195, 791, 558, 945, 679,
+ 297, 59, 87, 824, 713, 663, 412, 693, 342, 606,
+ 134, 108, 571, 364, 631, 212, 174, 643, 304, 329,
+ 343, 97, 430, 751, 497, 314, 983, 374, 822, 928,
+ 140, 206, 73, 263, 980, 736, 876, 478, 430, 305,
+ 170, 514, 364, 692, 829, 82, 855, 953, 676, 246,
+ 369, 970, 294, 750, 807, 827, 150, 790, 288, 923,
+ 804, 378, 215, 828, 592, 281, 565, 555, 710, 82,
+ 896, 831, 547, 261, 524, 462, 293, 465, 502, 56,
+ 661, 821, 976, 991, 658, 869, 905, 758, 745, 193,
+ 768, 550, 608, 933, 378, 286, 215, 979, 792, 961,
+ 61, 688, 793, 644, 986, 403, 106, 366, 905, 644,
+ 372, 567, 466, 434, 645, 210, 389, 550, 919, 135,
+ 780, 773, 635, 389, 707, 100, 626, 958, 165, 504,
+ 920, 176, 193, 713, 857, 265, 203, 50, 668, 108,
+ 645, 990, 626, 197, 510, 357, 358, 850, 858, 364,
936, 638
};
blob - e47197b82500b88a10ac20001b66a98b85794548
blob + 797ba1187c1119dfbd92cfe33c3cbfe1d5bb39c7
--- src/cmd/bzip2/lib/unix.h
+++ src/cmd/bzip2/lib/unix.h
#include <math.h>
#include <errno.h>
#include <ctype.h>
-
blob - 778c76082846beb54c16afe0d2b2249ac09a525d
blob + c936a286aacf11f6a252f06f128544599db444ed
--- src/cmd/calendar.c
+++ src/cmd/calendar.c
exits("");
}
-char *months[] =
+char *months[] =
{
"january",
"february",
first = alloc(sizeof(Date));
if(*last)
(*last)->next = first;
- first->p = regcomp(buf);
+ first->p = regcomp(buf);
if (matchyear)
snprint(buf, sizeof buf,
if(debug)
print("%s\n", buf);
nd = alloc(sizeof(Date));
- nd->p = regcomp(buf);
+ nd->p = regcomp(buf);
nd->next = 0;
first->next = nd;
*last = nd;
blob - ac5888979725984641e4d2e247d40ec8f626d313
blob + 8fdcf4ec359a19309799784edfe3a8bae36c7a48
--- src/cmd/cat.c
+++ src/cmd/cat.c
}
exits(0);
}
-
blob - 9e611f042c75f49897d80d1c4f47acb1ba1a1848
blob + ebca5cc5e9233a0257b4ebfe3ac578bfed8d959d
--- src/cmd/cb/cb.c
+++ src/cmd/cb/cb.c
int i;
for(i=0;i<IFLEVEL-1;i++)cl->ifc[i] = 0;
}
-char
+char
puttmp(char c, int keep)
{
if(tp < &temp[TEMP-120])
blob - 4f69e181597666c8855656231c2d7baefa32d7a8
blob + f06f12a51f020897a994a1ee5de2f031c209f063
--- src/cmd/cmp.c
+++ src/cmd/cmp.c
print("%6lld 0x%.2x 0x%.2x\n", nc+i, *p, *q);
}
}
- }
+ }
if(Lflag)
for(p = b1s; p < b1e;)
if(*p++ == '\n')
blob - fc2ec5af5017e36bd97c8539a42ade35fae1df98
blob + 272f5ec8c7d854b4b64b133d0086729a89ab8475
--- src/cmd/date.c
+++ src/cmd/date.c
print("%s", asctime(gmtime(now)));
else
print("%s", ctime(now));
-
+
exits(0);
}
blob - 55ed02a8283d830b2939a97bbd2ad20f810fdff8
blob + b89318e8017ef5483733ffc9593d96d8140b04f7
--- src/cmd/db/command.c
+++ src/cmd/db/command.c
break;
case '>':
- lastcom = savecom;
+ lastcom = savecom;
savc=rdc();
if (reg=regname(savc))
rput(correg, reg, dot);
- else
+ else
error("bad variable");
break;
case '!':
lastcom=savecom;
- shell();
+ shell();
break;
case '$':
lastcom=savecom;
- printdollar(nextchar());
+ printdollar(nextchar());
break;
case ':':
- if (!executing) {
+ if (!executing) {
executing=TRUE;
subpcs(nextchar());
executing=FALSE;
prints(DBNAME);
break;
- default:
+ default:
error("bad command");
}
flushbuf();
{
case 'm':
if (eqcom)
- error(BADEQ);
+ error(BADEQ);
cmdmap(map);
break;
case 'L':
case 'l':
if (eqcom)
- error(BADEQ);
+ error(BADEQ);
cmdsrc(lastc, map);
break;
case 'W':
case 'w':
if (eqcom)
- error(BADEQ);
+ error(BADEQ);
cmdwrite(lastc, map);
break;
else
dotinc = 2;
savdot=dot;
- expr(1);
+ expr(1);
locval=expv;
if (expr(0))
- locmsk=expv;
+ locmsk=expv;
else
locmsk = ~0;
if (c == 'L')
else
while ((ret = get2(map, dot, &sh)) > 0 && (sh&locmsk) != locval)
dot = inkdot(dotinc);
- if (ret < 0) {
- dot=savdot;
+ if (ret < 0) {
+ dot=savdot;
error("%r");
}
symoff(buf, 512, dot, CANY);
expr(1);
pass = 0;
do {
- pass++;
+ pass++;
savdot=dot;
exform(1, 1, format, map, 0, pass);
dot=savdot;
error(badwrite);
}
savdot=dot;
- dprint("=%8t");
+ dprint("=%8t");
exform(1, 0, format, map, 0, pass);
newline();
} while (expr(0));
}
break;
}
- prints("!");
+ prints("!");
reread();
}
}
blob - 74c9319a7884cb2aedfd26537f891faddb8431fb
blob + 72b8c906747f9994c64790600560a921172d0d22
--- src/cmd/db/expr.c
+++ src/cmd/db/expr.c
return 1;
}
error("bad file location");
- } else if (symchar(0)) {
+ } else if (symchar(0)) {
readsym(gsym);
if (lastc=='.') {
readchar(); /* ugh */
reread();
} else if (getnum(readchar)) {
;
- } else if (lastc=='.') {
+ } else if (lastc=='.') {
readchar();
if (!symchar(0) && lastc != '.') {
expv = dot;
if (localaddr(cormap, correg, s.name, lsym, &u) < 0)
error("%r");
expv = u;
- }
+ }
reread();
} else if (lastc=='"') {
expv=ditto;
expv = ascval();
else if (a)
error("address expected");
- else {
+ else {
reread();
return(0);
}
blob - 8cd091b017a259f2416a9a2ef1afca5f00b76cef
blob + bd97cd7075eb5d0d95c51c1242ec31cc1bed2b47
--- src/cmd/db/input.c
+++ src/cmd/db/input.c
*
* we handle this case specially because we have to look ahead
* at the token after the colon to decide if it is a file reference
- * or a colon-command with a symbol name prefix.
+ * or a colon-command with a symbol name prefix.
*/
int
blob - 176cec2858c1e2298fc027369a84808e4f90a8d9
blob + db4d0fa25eba5d9956b14267eae4644ed84d1249
--- src/cmd/db/output.c
+++ src/cmd/db/output.c
infile = STDIN;
} else {
if (infile) {
- close(infile);
+ close(infile);
infile=STDIN;
}
if (ifiledepth > 0) {
blob - b876f50abe9f4c2a40f2d7c80a039b4b87e8bb9f
blob + 681819da66ded907fdbe878c4c62f2e8b3a2fdbc
--- src/cmd/db/pcs.c
+++ src/cmd/db/pcs.c
switch (modif) {
/* delete breakpoint */
- case 'd':
+ case 'd':
case 'D':
if ((bk=scanbkpt(dot)) == 0)
error("no breakpoint set");
return;
/* set breakpoint */
- case 'b':
+ case 'b':
case 'B':
if (bk=scanbkpt(dot))
bk->flag=BKPTCLR;
return;
/* run program */
- case 'r':
+ case 'r':
case 'R':
endpcs();
setup();
break;
/* single step */
- case 's':
+ case 's':
if (pid == 0) {
setup();
loopcnt--;
loopcnt = 0;
break;
/* continue with optional note */
- case 'c':
- case 'C':
+ case 'c':
+ case 'C':
if (pid==0)
error(NOPCS);
runmode=CONTIN;
blob - eaeb61f2b140ab241ae0af4091ec562388239efa
blob + 15a196e1199abb19becf0713e08e9914f6d7c83e
--- src/cmd/db/setup.c
+++ src/cmd/db/setup.c
/* textseg(expv, &fhdr); */
map->seg[i].base = expv;
} else
- error("Invalid base address");
+ error("Invalid base address");
if (expr(0))
map->seg[i].size = expv - map->seg[i].base;
else
- error("Invalid end address");
+ error("Invalid end address");
if (expr(0))
- map->seg[i].offset = expv;
+ map->seg[i].offset = expv;
else
- error("Invalid file offset");
+ error("Invalid file offset");
/*
if (rdc()=='?' && map == cormap) {
if (fcor)
blob - 1b758efec074c7165289f7cf5f9ccc153c110978
blob + 0ad083759d94390241830c13a3e075388f38457f
--- src/cmd/deroff.c
+++ src/cmd/deroff.c
* Deroff follows .so and .nx commands, removes contents of macro
* definitions, equations (both .EQ ... .EN and $...$),
* Tbl command sequences, and Troff backslash vconstructions.
- *
+ *
* All input is through the C macro; the most recently read character is in c.
*/
#define C fC()
#define C1 fC1()
-#define SKIP while(C != '\n')
+#define SKIP while(C != '\n')
#define SKIP1 while(C1 != '\n')
#define SKIP_TO_COM SKIP;\
SKIP;\
c = C1;
else if(c == '"')
while(C1 != '"')
- if(c == '\\')
+ if(c == '\\')
C1;
if (msflag)
eqnflag = 1;
Rune r;
Dir *dir;
struct chain
- {
- struct chain* nextp;
- char* datap;
+ {
+ struct chain* nextp;
+ char* datap;
} *q;
static struct chain *namechain= 0;
else
if(filesp==files && c1=='T' && (c2=='S' || c2=='C' || c2=='&')) {
if(msflag)
- stbl();
+ stbl();
else
tbl();
}
SKIP;
else
if(c1=='h' && c2=='w')
- SKIP;
+ SKIP;
else
if(msflag && c1 == 'T' && c2 == 'L') {
SKIP_TO_COM;
- goto comx;
+ goto comx;
}
else
if(msflag && c1=='N' && c2 == 'R')
if(mac==MM)SKIP;
else {
SKIP_TO_COM;
- goto comx;
+ goto comx;
}
} else
if(msflag && c1=='F' && c2=='S') {
SKIP_TO_COM;
- goto comx;
+ goto comx;
}
else
if(msflag && (c1=='S' || c1=='N') && c2=='H') {
SKIP_TO_COM;
- goto comx;
+ goto comx;
} else
if(c1 == 'U' && c2 == 'X') {
if(wordflag)
} else
if(msflag && c1=='O' && c2=='K') {
SKIP_TO_COM;
- goto comx;
+ goto comx;
} else
if(msflag && c1=='N' && c2=='D')
SKIP;
if(!msflag && c1=='P' && c2=='S') {
inpic();
} else
- if(msflag && (c1=='D' || c1=='N' || c1=='K'|| c1=='P') && c2=='S') {
- sdis(c1, 'E');
+ if(msflag && (c1=='D' || c1=='N' || c1=='K'|| c1=='P') && c2=='S') {
+ sdis(c1, 'E');
} else
- if(msflag && (c1 == 'K' && c2 == 'F')) {
- sdis(c1,'E');
+ if(msflag && (c1 == 'K' && c2 == 'F')) {
+ sdis(c1,'E');
} else
if(msflag && c1=='n' && c2=='f')
sdis('f','i');
macro(void)
{
if(msflag) {
- do {
- SKIP1;
+ do {
+ SKIP1;
} while(C1 != '.' || C1 != '.' || C1 == '.');
if(c != '\n')
SKIP;
SKIP1;
} else
if(a1 == 'D' && c1 == 'E' && c2 == 'Q') {
- eqn();
+ eqn();
eqnf = 0;
} else
if(a1 == 'f') {
Bputc(&bout, 'x');
Bputc(&bout, ' ');
if(last) {
- Bputc(&bout, last);
- Bputc(&bout, '\n');
+ Bputc(&bout, last);
+ Bputc(&bout, '\n');
}
}
return;
dflg = 0;
}
if(c != '\n')
- while(C1 != '\n') {
+ while(C1 != '\n') {
if(chars[c] == PUNCT)
last = c;
else
{
int bdelim;
-sw:
+sw:
switch(C1)
{
case '"':
blob - 1221ec8c194fc33cd532e480c9cb67b0c28ac57b
blob + 4bfe02450ac8fb311b787e9994e2bae5bdef4ac5
--- src/cmd/devdraw/bigarrow.h
+++ src/cmd/devdraw/bigarrow.h
Cursor2 bigarrow2 = {
{ -2, -2 },
- { 0xFF, 0xFF, 0xFF, 0xFF,
- 0xFF, 0xFF, 0xFF, 0xFF,
- 0xC0, 0x00, 0x00, 0x03,
- 0xC0, 0x00, 0x00, 0x07,
- 0xC0, 0x00, 0x00, 0x1E,
- 0xC0, 0x00, 0x00, 0x3C,
- 0xC0, 0x00, 0x00, 0xF0,
- 0xC0, 0x00, 0x03, 0xE0,
- 0xC0, 0x00, 0x0F, 0x80,
- 0xC0, 0x00, 0x0E, 0x00,
- 0xC0, 0x00, 0x07, 0x00,
- 0xC0, 0x00, 0x03, 0x80,
- 0xC0, 0x00, 0x01, 0xC0,
- 0xC0, 0x00, 0x00, 0xE0,
- 0xC0, 0x00, 0x00, 0x70,
- 0xC0, 0x00, 0x00, 0x38,
- 0xC0, 0x00, 0x00, 0x1C,
- 0xC0, 0x00, 0x00, 0x0E,
- 0xC0, 0x00, 0x00, 0x07,
- 0xC0, 0x00, 0x00, 0x03,
- 0xC0, 0xC0, 0x00, 0x07,
- 0xC0, 0xE0, 0x00, 0x0E,
- 0xC1, 0xF0, 0x00, 0x1C,
- 0xC1, 0xB8, 0x00, 0x38,
- 0xC3, 0x9C, 0x00, 0x70,
- 0xC3, 0x0E, 0x00, 0xE0,
- 0xC7, 0x07, 0x01, 0xC0,
- 0xCE, 0x03, 0x83, 0x80,
- 0xCC, 0x01, 0xC7, 0x00,
- 0xDC, 0x00, 0xEE, 0x00,
- 0xF8, 0x00, 0x7C, 0x00,
+ { 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0xFF, 0xFF, 0xFF,
+ 0xC0, 0x00, 0x00, 0x03,
+ 0xC0, 0x00, 0x00, 0x07,
+ 0xC0, 0x00, 0x00, 0x1E,
+ 0xC0, 0x00, 0x00, 0x3C,
+ 0xC0, 0x00, 0x00, 0xF0,
+ 0xC0, 0x00, 0x03, 0xE0,
+ 0xC0, 0x00, 0x0F, 0x80,
+ 0xC0, 0x00, 0x0E, 0x00,
+ 0xC0, 0x00, 0x07, 0x00,
+ 0xC0, 0x00, 0x03, 0x80,
+ 0xC0, 0x00, 0x01, 0xC0,
+ 0xC0, 0x00, 0x00, 0xE0,
+ 0xC0, 0x00, 0x00, 0x70,
+ 0xC0, 0x00, 0x00, 0x38,
+ 0xC0, 0x00, 0x00, 0x1C,
+ 0xC0, 0x00, 0x00, 0x0E,
+ 0xC0, 0x00, 0x00, 0x07,
+ 0xC0, 0x00, 0x00, 0x03,
+ 0xC0, 0xC0, 0x00, 0x07,
+ 0xC0, 0xE0, 0x00, 0x0E,
+ 0xC1, 0xF0, 0x00, 0x1C,
+ 0xC1, 0xB8, 0x00, 0x38,
+ 0xC3, 0x9C, 0x00, 0x70,
+ 0xC3, 0x0E, 0x00, 0xE0,
+ 0xC7, 0x07, 0x01, 0xC0,
+ 0xCE, 0x03, 0x83, 0x80,
+ 0xCC, 0x01, 0xC7, 0x00,
+ 0xDC, 0x00, 0xEE, 0x00,
+ 0xF8, 0x00, 0x7C, 0x00,
0xF0, 0x00, 0x38, 0x00,
},
- { 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x00, 0x00,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0xFF, 0xFF, 0xF8,
- 0x3F, 0xFF, 0xFF, 0xE0,
- 0x3F, 0xFF, 0xFF, 0xC0,
- 0x3F, 0xFF, 0xFF, 0x00,
- 0x3F, 0xFF, 0xFC, 0x00,
- 0x3F, 0xFF, 0xF0, 0x00,
- 0x3F, 0xFF, 0xF0, 0x00,
- 0x3F, 0xFF, 0xF8, 0x00,
- 0x3F, 0xFF, 0xFC, 0x00,
- 0x3F, 0xFF, 0xFE, 0x00,
- 0x3F, 0xFF, 0xFF, 0x00,
- 0x3F, 0xFF, 0xFF, 0x80,
- 0x3F, 0xFF, 0xFF, 0xC0,
- 0x3F, 0xFF, 0xFF, 0xE0,
- 0x3F, 0xFF, 0xFF, 0xF0,
- 0x3F, 0xFF, 0xFF, 0xF8,
- 0x3F, 0xFF, 0xFF, 0xFC,
- 0x3F, 0x3F, 0xFF, 0xF8,
- 0x3F, 0x1F, 0xFF, 0xF0,
- 0x3E, 0x0F, 0xFF, 0xE0,
- 0x3E, 0x07, 0xFF, 0xC0,
- 0x3C, 0x03, 0xFF, 0x80,
- 0x3C, 0x01, 0xFF, 0x00,
- 0x38, 0x00, 0xFE, 0x00,
- 0x30, 0x00, 0x7C, 0x00,
- 0x30, 0x00, 0x38, 0x00,
- 0x20, 0x00, 0x10, 0x00,
- 0x00, 0x00, 0x00, 0x00,
+ { 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0xFF, 0xFF, 0xF8,
+ 0x3F, 0xFF, 0xFF, 0xE0,
+ 0x3F, 0xFF, 0xFF, 0xC0,
+ 0x3F, 0xFF, 0xFF, 0x00,
+ 0x3F, 0xFF, 0xFC, 0x00,
+ 0x3F, 0xFF, 0xF0, 0x00,
+ 0x3F, 0xFF, 0xF0, 0x00,
+ 0x3F, 0xFF, 0xF8, 0x00,
+ 0x3F, 0xFF, 0xFC, 0x00,
+ 0x3F, 0xFF, 0xFE, 0x00,
+ 0x3F, 0xFF, 0xFF, 0x00,
+ 0x3F, 0xFF, 0xFF, 0x80,
+ 0x3F, 0xFF, 0xFF, 0xC0,
+ 0x3F, 0xFF, 0xFF, 0xE0,
+ 0x3F, 0xFF, 0xFF, 0xF0,
+ 0x3F, 0xFF, 0xFF, 0xF8,
+ 0x3F, 0xFF, 0xFF, 0xFC,
+ 0x3F, 0x3F, 0xFF, 0xF8,
+ 0x3F, 0x1F, 0xFF, 0xF0,
+ 0x3E, 0x0F, 0xFF, 0xE0,
+ 0x3E, 0x07, 0xFF, 0xC0,
+ 0x3C, 0x03, 0xFF, 0x80,
+ 0x3C, 0x01, 0xFF, 0x00,
+ 0x38, 0x00, 0xFE, 0x00,
+ 0x30, 0x00, 0x7C, 0x00,
+ 0x30, 0x00, 0x38, 0x00,
+ 0x20, 0x00, 0x10, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00,
}
};
blob - c1cf5983856681bb4b210b96a7cc322a3a56f079
blob + dcb1801ac2c6f9947469959a9b5f7fefbc3291ba
--- src/cmd/devdraw/cocoa-srv.c
+++ src/cmd/devdraw/cocoa-srv.c
Wsysmsg m;
fmtinstall('W', drawfcallfmt);
-
+
mbuf = nil;
nmbuf = 0;
while((n = read(3, buf, 4)) == 4){
replyerror(Wsysmsg *m)
{
char err[256];
-
+
rerrstr(err, sizeof err);
m->type = Rerror;
m->error = err;
replymsg(m);
}
-/*
- * Handle a single wsysmsg.
+/*
+ * Handle a single wsysmsg.
* Might queue for later (kbd, mouse read)
*/
void
static uchar buf[65536];
int n;
Memimage *i;
-
+
switch(m->type){
case Tinit:
memimageinit();
setcursor(&m->cursor, &m->cursor2);
replymsg(m);
break;
-
+
case Tbouncemouse:
// _xbouncemouse(&m->mouse);
replymsg(m);
replymsg(m);
zunlock();
break;
-
+
case Ttop:
topwin();
replymsg(m);
break;
-
+
case Tresize:
resizewindow(m->rect);
replymsg(m);
/* T -> R msg */
if(m->type%2 == 0)
m->type++;
-
+
if(trace) fprint(2, "%ud [%d] -> %W\n", nsec()/1000000, threadid(), m);
/* copy to output buffer */
n = sizeW2M(m);
matchkbd(void)
{
Wsysmsg m;
-
+
if(kbd.stall)
return;
while(kbd.ri != kbd.wi && kbdtags.ri != kbdtags.wi){
matchmouse(void)
{
Wsysmsg m;
-
+
while(mouse.ri != mouse.wi && mousetags.ri != mousetags.wi){
m.type = Rrdmouse;
m.tag = mousetags.t[mousetags.ri++];
mousetrack(int x, int y, int b, uint ms)
{
Mouse *m;
-
+
if(x < mouserect.min.x)
x = mouserect.min.x;
if(x > mouserect.max.x)
blob - 7f0bff2117dcf9b801fc9c9ba9993a81c88dcd7b
blob + 654ab4af6b3967ebd61931292b2c2176dc7c6b12
--- src/cmd/devdraw/devdraw.c
+++ src/cmd/devdraw/devdraw.c
/*
* Replace the screen image because the screen
* was resized.
- *
+ *
* In theory there should only be one reference
* to the current screen image, and that's through
* client0's image 0, installed a few lines above.
- * Once the client drops the image, the underlying backing
+ * Once the client drops the image, the underlying backing
* store freed properly. The client is being notified
* about the resize through external means, so all we
* need to do is this assignment.
{
char cbuf[40], *err, ibuf[12*12+1], *s;
int c, ci, doflush, dstid, e0, e1, esize, j, m;
- int ni, nw, oesize, oldn, op, ox, oy, repl, scrnid, y;
+ int ni, nw, oesize, oldn, op, ox, oy, repl, scrnid, y;
uchar *a, refresh, *u;
u32int chan, value;
Client *client;
err = "negative ellipse thickness";
goto error;
}
-
+
drawpoint(&sp, a+29);
c = j;
if(*a == 'E')
ni = sprint(ibuf, "%11d %11d %11s %11d %11d %11d %11d %11d"
" %11d %11d %11d %11d ",
client->clientid,
- client->infoid,
+ client->infoid,
chantostr(cbuf, i->chan),
(i->flags&Frepl)==Frepl,
i->r.min.x, i->r.min.y, i->r.max.x, i->r.max.y,
- i->clipr.min.x, i->clipr.min.y,
+ i->clipr.min.x, i->clipr.min.y,
i->clipr.max.x, i->clipr.max.y);
free(client->readdata);
client->readdata = malloc(ni);
client->nreaddata = ni;
client->infoid = -1;
continue;
-
+
/* query: 'Q' n[1] queryspec[n] */
case 'q':
if(n < 2)
qunlock(&sdraw.lk);
return -1;
}
-
-
blob - 87df3f18c9512bba360673087f384f7f71786923
blob + f61392894d4cf635a5bb3cb13ca4c9fdd6b62ccd
--- src/cmd/devdraw/drawclient.c
+++ src/cmd/devdraw/drawclient.c
startsrv(void)
{
int pid, p[2];
-
+
if(pipe(p) < 0)
sysfatal("pipe");
if((pid=fork()) < 0)
cmdinit(int argc, char **argv)
{
Wsysmsg m;
-
+
memset(&m, 0, sizeof m);
m.op = Tinit;
m.winsize = "100x100";
cmdmouse(int argc, char **argv)
{
Wsysmsg m;
-
+
memset(&m, 0, sizeof m);
m.op = Trdmouse;
if(domsg(&m) < 0)
cmdkbd(int argc, char **argv)
{
Wsysmsg m;
-
+
memset(&m, 0, sizeof m);
m.op = Trdkbd;
if(domsg(&m) < 0)
}
exits(0);
}
-
blob - 09c67523c8663290490054889fd366ffdd2713c5
blob + 2fa9e29d26cf44f6868e112bb1a73bf2cfdaddb8
--- src/cmd/devdraw/latin1.c
+++ src/cmd/devdraw/latin1.c
else
return -5;
}
-
+
for(l=latintab; l->ld!=0; l++)
if(k[0] == l->ld[0]){
if(n == 1)
blob - abd202fb764ee06ce00b3cb65f82c284204b9c3d
blob + db34b6ecebc5c8fe646ae3c6cff752f3fda79474
--- src/cmd/devdraw/mklatinkbd.c
+++ src/cmd/devdraw/mklatinkbd.c
printtrie(b, t->link[i]);
if(t->n == 0)
return;
-
+
if(xflag) {
for(i=0; i<256; i++) {
if(t->r[i] == 0)
Bprint(b, " %k", *p);
Bprint(b, " %k : \"%C\" U%04X\n", i, t->r[i], t->r[i]);
}
- return;
+ return;
}
Bprint(b, "\t\"");
return fmtprint(f, "<%s>", xkey[i].s);
return fmtprint(f, "<%c>", c);
}
-
-
blob - e6ece33399007e8d27b1013ef23c828e10407623
blob + 29f33b7bfbc53e90d61e390d4425e8fa76af9d4f
--- src/cmd/devdraw/mouseswap.c
+++ src/cmd/devdraw/mouseswap.c
if(!map.init)
initmap();
-
+
nbut = 0;
for(i=0; i<Nbutton; i++)
if((but&(1<<i)) && map.b[i] >= 0)
blob - fd8b7ee164ccfdcb52970bc3daf9cb0d93e49ca8
blob + 08e0521fd5a0727496c3bb3c46b5bd38c0959947
--- src/cmd/devdraw/nowsys.c
+++ src/cmd/devdraw/nowsys.c
int n;
uchar buf[1024*1024];
Wsysmsg m;
-
+
ARGBEGIN{
case 'D':
break;
default:
usage();
}ARGEND
-
+
if(argc != 0)
usage();
blob - d3f08331659a0e2fad8261e34ff7e77276f51e62
blob + fdf7acecdae95f76540889079a1eb442e91e5066
--- src/cmd/devdraw/osx-draw.c
+++ src/cmd/devdraw/osx-draw.c
{
return _unloadmemimage(i, r, data, ndata);
}
-
blob - 1e7a93a1cb862387fda12eca24c572c3125ba272
blob + 4d350654dff4c4ad9fd02edc09dbe27335d55dfd
--- src/cmd/devdraw/snarf.c
+++ src/cmd/devdraw/snarf.c
case Expose:
_xexpose(xev);
break;
-
+
case DestroyNotify:
if(_xdestroy(xev))
exits(0);
break;
}
}
-
blob - a465f998b578c60d95ad5e48a15670e083fc3c79
blob + 9d85b4514998fe6bd97bf829d434c1b029f2074f
--- src/cmd/devdraw/x11-alloc.c
+++ src/cmd/devdraw/x11-alloc.c
}
_freememimage(m);
}
-
blob - 33e3170a52527aa897bf1460928201a8ca5eeb98
blob + 1666eceded666596d4e8b512a82bdf3438397062
--- src/cmd/devdraw/x11-cload.c
+++ src/cmd/devdraw/x11-cload.c
_xputxdata(i, r);
return n;
}
-
blob - 685ad88a76492416061b07d903a138ff74318265
blob + f3b6a68973ea2a1f1698ba1865353b4e99cf8bff
--- src/cmd/devdraw/x11-draw.c
+++ src/cmd/devdraw/x11-draw.c
*/
return 0;
}
-
blob - fc43a684f7c42dcfb4a19643c00377221f5bd5b2
blob + adead1eadddaed12e902108ba1e2a3ad969ee966
--- src/cmd/devdraw/x11-fill.c
+++ src/cmd/devdraw/x11-fill.c
Point p;
Xmem *xm;
XGC gc;
-
+
xm = m->X;
assert(xm != nil);
p = subpt(r.min, m->r.min);
XFillRectangle(_x.display, xm->pixmap, gc, p.x, p.y, Dx(r), Dy(r));
}
-
-
blob - 1a47be01d9f9a06a07876812d0b4aee53b53ad0c
blob + 61913f184fcdb8222aae3f4b4b82efc5e595f299
--- src/cmd/devdraw/x11-get.c
+++ src/cmd/devdraw/x11-get.c
uchar *p;
Point tp, xdelta, delta;
Xmem *xm;
-
+
xm = m->X;
if(xm == nil)
return nil;
XPutImage(_x.display, xm->pixmap, gc, xi, xdelta.x, xdelta.y, delta.x, delta.y,
Dx(r), Dy(r));
-
+
if(_x.usetable && m->chan==CMAP8){
for(y=r.min.y; y<r.max.y; y++)
for(x=r.min.x, p=byteaddr(m, Pt(x,y)); x<r.max.x; x++, p++)
xm->dirty = 1;
addrect(&xm->dirtyr, r);
}
-
-
-
blob - f09963dceb445638db517227eb2d7223b86df759
blob + 8935c9d15a1ebad457a251fb41cddbd0d4d4bc92
--- src/cmd/devdraw/x11-init.c
+++ src/cmd/devdraw/x11-init.c
xrootid = DefaultScreen(_x.display);
xrootwin = DefaultRootWindow(_x.display);
- /*
+ /*
* Figure out underlying screen format.
*/
if(XMatchVisualInfo(_x.display, xrootid, 24, TrueColor, &xvi)
/*
* Parse the various X resources. Thanks to Peter Canning.
*/
- char *screen_resources, *display_resources, *geom,
+ char *screen_resources, *display_resources, *geom,
*geomrestype, *home, *file, *dpitype;
XrmDatabase database;
XrmValue geomres, dpires;
* be the default depth. On such "suboptimal" systems, we have to allocate an
* empty color map anyway, according to Axel Belinfante.
*/
-static int
+static int
setupcmap(XWindow w)
{
char buf[30];
if(_x.depth >= 24) {
if(_x.usetable == 0)
- _x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocNone);
+ _x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocNone);
/*
* The pixel value returned from XGetPixel needs to
* be converted to RGB so we can call rgb2cmap()
* to translate between 24 bit X and our color. Unfortunately,
- * the return value appears to be display server endian
+ * the return value appears to be display server endian
* dependant. Therefore, we run some heuristics to later
* determine how to mask the int value correctly.
- * Yeah, I know we can look at _x.vis->byte_order but
+ * Yeah, I know we can look at _x.vis->byte_order but
* some displays say MSB even though they run on LSB.
* Besides, this is more anal.
*/
_x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocNone);
}else if(_x.vis->class == PseudoColor){
if(_x.usetable == 0){
- _x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocAll);
+ _x.cmap = XCreateColormap(_x.display, w, _x.vis, AllocAll);
XStoreColors(_x.display, _x.cmap, _x.map, 256);
for(i = 0; i < 256; i++){
_x.tox11[i] = i;
blob - 729f264735fd40ba4bb13263997d22c9bb4fc181
blob + bdf7d2b2e44465fc3f19cbc9a39cfade337a2084
--- src/cmd/devdraw/x11-itrans.c
+++ src/cmd/devdraw/x11-itrans.c
case XK_KP_End:
k = Kend;
break;
- case XK_Page_Up:
+ case XK_Page_Up:
case XK_KP_Page_Up:
k = Kpgup;
break;
case ButtonPress:
be = (XButtonEvent*)e;
- /*
+ /*
* Fake message, just sent to make us announce snarf.
* Apparently state and button are 16 and 8 bits on
* the wire, since they are truncated by the time they
/* get the property */
xdata = nil;
- XGetWindowProperty(_x.display, _x.drawable, prop, 0, SnarfSize/sizeof(ulong), 0,
+ XGetWindowProperty(_x.display, _x.drawable, prop, 0, SnarfSize/sizeof(ulong), 0,
AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
if((type != target && type != XA_STRING && type != _x.utf8string) || len == 0){
if(xdata)
data = nil;
goto out;
}
-
+
if((data = _xgetsnarffrom(w, clipboard, _x.utf8string, 10, 100)) == nil)
if((data = _xgetsnarffrom(w, clipboard, XA_STRING, 10, 100)) == nil){
/* nothing left to do */
a[3] = _x.compoundtext;
XChangeProperty(_x.display, xe->requestor, xe->property, XA_ATOM,
32, PropModeReplace, (uchar*)a, nelem(a));
- }else if(xe->target == XA_STRING
- || xe->target == _x.utf8string
- || xe->target == _x.text
+ }else if(xe->target == XA_STRING
+ || xe->target == _x.utf8string
+ || xe->target == _x.text
|| xe->target == _x.compoundtext
|| ((name = XGetAtomName(_x.display, xe->target)) && strcmp(name, "text/plain;charset=UTF-8") == 0)){
/* text/plain;charset=UTF-8 seems nonstandard but is used by Synergy */
CFRelease(flavors);
}
qunlock(&clip.lk);
- return nil;
+ return nil;
}
void
qunlock(&clip.lk);
return;
}
- cfdata = CFDataCreate(kCFAllocatorDefault,
+ cfdata = CFDataCreate(kCFAllocatorDefault,
(uchar*)clip.rbuf, runestrlen(clip.rbuf)*2);
if(cfdata == nil){
fprint(2, "apple pasteboard cfdatacreate failed\n");
blob - 108f153c79e876bd150c3b43da442d8d4853b657
blob + 853fa552d29861c170b397004d6e4c65e90517dd
--- src/cmd/devdraw/x11-keysym2ucs.c
+++ src/cmd/devdraw/x11-keysym2ucs.c
*/
#ifndef KEYSYM2UCS_INCLUDED
-
+
#include "x11-keysym2ucs.h"
#define VISIBLE /* */
blob - a7446f37dda49dee73b4b595e685401fd333f08a
blob + 895e110960501b7729cbe156f235a446254b8c26
--- src/cmd/devdraw/x11-load.c
+++ src/cmd/devdraw/x11-load.c
_xputxdata(i, r);
return n;
}
-
blob - 5cbdded84267122b86eac07b0ff296456c1691c1
blob + 5227f39b5c8a03bb0f2d1896ee96566d6a2634e5
--- src/cmd/devdraw/x11-pixelbits.c
+++ src/cmd/devdraw/x11-pixelbits.c
_xgetxdata(m, Rect(p.x, p.y, p.x+1, p.y+1));
return _pixelbits(m, p);
}
-
-
blob - 8141648271f611b386201430cfff131673e311bc
blob + 4d72415b18dd29d1978c44483a06aa3d495f1630
--- src/cmd/devdraw/x11-srv.c
+++ src/cmd/devdraw/x11-srv.c
/*
* Ignore arguments. They're only for good ps -a listings.
*/
-
+
notify(bell);
fdin.rp = fdin.wp = fdin.buf;
fdin.ep = fdin.buf+sizeof fdin.buf;
-
+
fdout.rp = fdout.wp = fdout.buf;
fdout.ep = fdout.buf+sizeof fdout.buf;
runmsg(&m);
fdin.rp += n;
}
-
+
/* slide data to beginning of buf */
fdslide(&fdin);
}
replyerror(Wsysmsg *m)
{
char err[256];
-
+
rerrstr(err, sizeof err);
m->type = Rerror;
m->error = err;
-/*
- * Handle a single wsysmsg.
+/*
+ * Handle a single wsysmsg.
* Might queue for later (kbd, mouse read)
*/
void
uchar buf[65536];
int n;
Memimage *i;
-
+
switch(m->type){
case Tinit:
memimageinit();
_xsetcursor(&m->cursor);
replymsg(m);
break;
-
+
case Tbouncemouse:
_xbouncemouse(&m->mouse);
replymsg(m);
else
replymsg(m);
break;
-
+
case Ttop:
_xtopwindow();
replymsg(m);
break;
-
+
case Tresize:
_xresizewindow(m->rect);
replymsg(m);
/* T -> R msg */
if(m->type%2 == 0)
m->type++;
-
+
/* fprint(2, "-> %W\n", m); */
/* copy to output buffer */
n = sizeW2M(m);
matchkbd(void)
{
Wsysmsg m;
-
+
if(kbd.stall)
return;
while(kbd.ri != kbd.wi && kbdtags.ri != kbdtags.wi){
matchmouse(void)
{
Wsysmsg m;
-
+
while(mouse.ri != mouse.wi && mousetags.ri != mousetags.wi){
m.type = Rrdmouse;
m.tag = mousetags.t[mousetags.ri++];
case Expose:
_xexpose(xev);
break;
-
+
case DestroyNotify:
if(_xdestroy(xev))
exits(0);
return;
sendmouse(m);
break;
-
+
case KeyRelease:
case KeyPress:
ke = (XKeyEvent*)xev;
kbd.stall = 1;
matchkbd();
break;
-
+
case FocusOut:
/*
* Some key combinations (e.g. Alt-Tab) can cause us
altdown = 0;
abortcompose();
break;
-
+
case SelectionRequest:
_xselect(xev);
break;
}
}
-
blob - d01a232ff99e9d228100ff1724e918f3c2a7f52f
blob + 2f6241ba9555d97f2a7c9428a40d7d12ff82bc7b
--- src/cmd/devdraw/x11-unload.c
+++ src/cmd/devdraw/x11-unload.c
_xgetxdata(i, r);
return _unloadmemimage(i, r, data, ndata);
}
-
blob - 9095c950d09f42ca5ebdc774b2c9b64f7a03f09b
blob + 82a7d32c1a7ca17e15dfc6fe4f69f4630d92b429
--- src/cmd/devdraw/x11-wsys.c
+++ src/cmd/devdraw/x11-wsys.c
XConfigureWindow(_x.display, _x.drawable, value_mask, &e);
XFlush(_x.display);
}
-
blob - d9cdca624f5314c9f4a7a4647810962c9d2609c9
blob + 3c8597c6fdce7e7a0a8e67575f1b1c4baff77925
--- src/cmd/dict/dict.c
+++ src/cmd/dict/dict.c
/*
* find the specified file and return a path.
- * default location is #9/dict, but can be
+ * default location is #9/dict, but can be
* in $dictdir instead.
*/
char*
{
static char *dict;
static int did;
-
+
if(!did){
dict = getenv("dictpath");
did = 1;
}
-
+
if(dict)
return smprint("%s/%s", dict, f);
return unsharp(smprint("#9/dict/%s", f));
blob - 81efe829b680e7300607a9d5d13d252324958454
blob + 5161456f87e7a89fb77d26d1da365c05ae3ad51d
--- src/cmd/dict/oed.c
+++ src/cmd/dict/oed.c
bbc1 single chem bond below
bbc2 double chem bond below
bbl1 chem bond like /
- bbl2 chem bond like //
+ bbl2 chem bond like //
bbr1 chem bond like \
bbr2 chem bond \\
bcop1 copper symbol. Cf copper
"tʃ ... chop (tʃɒp), ditch (dɪtʃ)\n"
"ʒ ... vision (ˈvɪʒən), déjeuner (deʒøne)\n"
;
-static char *prkey2 =
+static char *prkey2 =
"dʒ ... judge (dʒʌdʒ)\n"
"ŋ ... singing (ˈsɪŋɪŋ), think (θiŋk)\n"
"ŋg ... finger (ˈfiŋgə(r))\n"
"ɥ ... Fr. cuisine (kɥizin)\n"
"\n"
;
-static char *prkey3 =
+static char *prkey3 =
"II. VOWELS AND DIPTHONGS\n"
"\n"
"Short\n"
"yː ... Ger. grün (gryːn)\n"
"\n"
;
-static char *prkey5 =
+static char *prkey5 =
"Nasal\n"
"ɛ˜, æ˜ as in Fr. fin (fɛ˜, fæ˜)\n"
"ã ... Fr. franc (frã)\n"
"ɔə ... boar (bɔə(r))\n"
"\n"
;
-static char *prkey6 =
+static char *prkey6 =
"III. STRESS\n"
"\n"
"Main stress: ˈ preceding stressed syllable\n"
blob - cbdff9e6ad6dc261a198a68e0822d121cd727740
blob + 16a8a9133249a2d207034be703947cbcd10d97bd
--- src/cmd/dict/pcollinsg.c
+++ src/cmd/dict/pcollinsg.c
case TAGE: /* an extra one */
break;
-
+
case SPCS:
p = reach(p, 0xba);
r = looknassoc(numtab, asize(numtab), strtol(tag,0,0));
rprev = r;
}
}
-
+
}
if(rprev != NONE)
outrune(rprev);
blob - 8cdaec35e5022ec568218d546f9c3ddb1c1b5ed9
blob + 5c93382af5a46024959b16c4b5de0f0a9bd0c900
--- src/cmd/dict/pgw.c
+++ src/cmd/dict/pgw.c
if(c == '<' && Bgetc(bdict) == 'p' && Bgetc(bdict) == '>') {
c = Bgetc(bdict);
if(c == '<') {
- if (Bgetc(bdict) == 'h' && Bgetc(bdict) == 'w'
+ if (Bgetc(bdict) == 'h' && Bgetc(bdict) == 'w'
&& Bgetc(bdict) == '>')
n = 7;
}else if (c == '{')
"tʃ ... chop (tʃɒp), ditch (dɪtʃ)\n"
"ʒ ... vision (ˈvɪʒən), déjeuner (deʒøne)\n"
;
-static char *prkey2 =
+static char *prkey2 =
"dʒ ... judge (dʒʌdʒ)\n"
"ŋ ... singing (ˈsɪŋɪŋ), think (θiŋk)\n"
"ŋg ... finger (ˈfiŋgə(r))\n"
"ɥ ... Fr. cuisine (kɥizin)\n"
"\n"
;
-static char *prkey3 =
+static char *prkey3 =
"II. VOWELS AND DIPTHONGS\n"
"\n"
"Short\n"
"yː ... Ger. grün (gryːn)\n"
"\n"
;
-static char *prkey5 =
+static char *prkey5 =
"Nasal\n"
"ɛ˜, æ˜ as in Fr. fin (fɛ˜, fæ˜)\n"
"ã ... Fr. franc (frã)\n"
"ɔə ... boar (bɔə(r))\n"
"\n"
;
-static char *prkey6 =
+static char *prkey6 =
"III. STRESS\n"
"\n"
"Main stress: ˈ preceding stressed syllable\n"
blob - d953636588dbe5f673c61b41b57bd84d61eaf31a
blob + 6562315f7faa94f6a4b3e81aecc26e4215fdd7d0
--- src/cmd/dict/roget.c
+++ src/cmd/dict/roget.c
while(strncmp(p, " -- ", 4) != 0 && p < e.end){
while(isspace((uchar)*p) && p < e.end)
p++;
- if (*p == '[' || *p == '{'){
+ if (*p == '[' || *p == '{'){
c = (*p == '[')? ']': '}';
while(*p != c && p < e.end)
p++;
outchar(*p++);
}
return;
- }
+ }
while(p < e.end && !isspace((uchar)*p))
p++;
p += 4;
spc = 0;
}
-
+
if (p < e.end -2 && strncmp(p, "[ ", 4) == 0){ /* twiddle layout */
outchars(" [");
continue;
blob - 6ead3ed6d14c4057c98b887ddcbc22235670f4e5
blob + c25a31c07860c633ba222efe828d571943f5b47c
--- src/cmd/dict/world.c
+++ src/cmd/dict/world.c
0x26a, 0xf0, 0x292, 0xe3, 0x153, 0x169, 0x28c, 0x265,
/*c0*/ 0x280, 0xeb, 0x6c, 0x28c, 0xf5, 0xf1, 0x152, NONE,
NONE, 0x53, 0x73, 0x5a, 0x7a, NONE, NONE, NONE,
-/*d0*/ 0xdf, NONE, NONE, 0x101, 0x12b, 0x16b, 0x113, 0x14d,
+/*d0*/ 0xdf, NONE, NONE, 0x101, 0x12b, 0x16b, 0x113, 0x14d,
NONE, NONE, NONE, 0x20, NONE, NONE, NONE, NONE,
/*e0*/ 0x3b1, 0x3b2, 0x3b3, 0x3c0, 0x3a3, 0x3c3, 0xb5, 0x3c4,
blob - 93de4e378ae67e829bdea3a54dcff18b91420a55
blob + 75a725ffdc2de346ff1c73739dcaa7ef0c20f61f
--- src/cmd/diff/diffio.c
+++ src/cmd/diff/diffio.c
/*
* hashing has the effect of
* arranging line in 7-bit bytes and then
- * summing 1-s complement in 16-bit hunks
+ * summing 1-s complement in 16-bit hunks
*/
static int
readhash(Biobuf *bp, char *buf)
if(nchanges == 0)
return;
-
+
for(i=0; i<nchanges; ){
j = changeset(i);
a = changes[i].a-Lines;
blob - bb3fd11241b4607b8a973dac94b8fc3c88e8a780
blob + ed4d17b8e609b211d1c1b6ff57bbbce00dae048c
--- src/cmd/diff/diffreg.c
+++ src/cmd/diff/diffreg.c
* on the hash (called value). In particular, this
* collects the equivalence classes in file1 together.
* Subroutine equiv replaces the value of each line in
-* file0 by the index of the first element of its
+* file0 by the index of the first element of its
* matching equivalence in (the reordered) file1.
* To save space equiv squeezes file1 into a single
* array member in which the equivalence classes
* of "k-candidates". At step i a k-candidate is a matched
* pair of lines x,y (x in file0 y in file1) such that
* there is a common subsequence of lenght k
-* between the first i lines of file0 and the first y
+* between the first i lines of file0 and the first y
* lines of file1, but there is no such subsequence for
* any smaller y. x is the earliest possible mate to y
* that occurs in such a subsequence.
*
* Whenever any of the members of the equivalence class of
-* lines in file1 matable to a line in file0 has serial number
-* less than the y of some k-candidate, that k-candidate
-* with the smallest such y is replaced. The new
+* lines in file1 matable to a line in file0 has serial number
+* less than the y of some k-candidate, that k-candidate
+* with the smallest such y is replaced. The new
* k-candidate is chained (via pred) to the current
* k-1 candidate so that the actual subsequence can
* be recovered. When a member has serial number greater
* The core requirements for problems larger than somewhat
* are (in words) 2*length(file0) + length(file1) +
* 3*(number of k-candidates installed), typically about
-* 6n words for files of length n.
+* 6n words for files of length n.
*/
/* TIDY THIS UP */
struct cand {
long *ixnew; /*will be overlaid on file[1]*/
/* END OF SOME TIDYING */
-static void
+static void
sort(struct line *a, int n) /*shellsort CACM #201*/
{
int m;
break;
if(memcmp((void *)b1s, (void *)b2s, n) != 0){
return 1;
- }
+ }
nc += n;
b1s += n;
b2s += n;
}
if(b1e - b1s == b2e - b2s)
return 0;
- return 1;
+ return 1;
}
void
blob - 408ad90f517c0bf6d19086b55542ce37de553fa8
blob + 2697cb885c362b16acdfe2192b92e53583c86b2f
--- src/cmd/diff/main.c
+++ src/cmd/diff/main.c
}
}
-void
+void
done(int status)
{
rmtmpfiles();
sprint(pathname, "%s/%s", path, name);
return 0;
}
-
+
static char *
mktmpfile(int input, Dir **sb)
{
int i;
Dir *fsb, *tsb;
extern int _p9usepwlibrary;
-
+
_p9usepwlibrary = 0;
Binit(&stdout, 1, OWRITE);
progname = *argv;
break;
case 'm':
- mflag = 1;
+ mflag = 1;
break;
case 'h':
blob - d576d24fe0867036d8a128abd589f5ea8948c626
blob + 3a1356105dacbaf503ae316a0133d4f93d2b511b
--- src/cmd/disk/mkext.c
+++ src/cmd/disk/mkext.c
default:
usage();
}ARGEND
-
+
Binits(&bin, 0, OREAD, binbuf, sizeof binbuf);
while(p = Brdline(&bin, '\n')){
p[Blinelen(&bin)-1] = '\0';
blob - 48de702271cb6e92e574964d7442b4ccb3c493cf
blob + 2edb37f403be594eb1937b27178ce6054fd891a0
--- src/cmd/disk/mkfs.c
+++ src/cmd/disk/mkfs.c
usage();
}ARGEND
- if(!argc)
+ if(!argc)
usage();
buf = emalloc(buflen);
strcpy(oldfile, f->old);
}else
sprint(oldfile, "%s%s", oldroot, f->new);
- if(strlen(newfile) >= sizeof newfile
+ if(strlen(newfile) >= sizeof newfile
|| strlen(oldfile) >= sizeof oldfile)
error("name overfile");
}
blob - 3d0e14e8ca2bd49555ea0fe4d13fc5d1b9a57b8c
blob + 4d56322b61293263e6374ed32d7e0ffb8f662bdb
--- src/cmd/draw/cmapcube.c
+++ src/cmd/draw/cmapcube.c
line3(v[0x36], v[0x32]);
line3(v[0x32], v[0x3F]);
line3(v[0x3F], v[0]);
-
+
line3(v[0xF0], v[0xF3]);
line3(v[0xF3], v[0xFF]);
line3(v[0xFF], v[0xFC]);
blob - 10a08f77deddeea9e1a7883f6c6bfc3d5bf1afec
blob + d6d89722faf1fc1d468eb3d874af18d73c689e99
--- src/cmd/draw/crop.c
+++ src/cmd/draw/crop.c
bottom = y;
}
}
-
+
if(n != nil)
freememimage(n);
return Rect(left, top, right+1, bottom+1);
blob - 0794f1006af91009413f82ed437e6ca1ac31b2b3
blob + 0f5e69055526463ed82f782e1652577f61dfe02f
--- src/cmd/draw/gview.c
+++ src/cmd/draw/gview.c
for (p=fps->p; p!=0; p=p->link)
p->clr = clr;
}
-
+
void do_recolor(int but, Mouse* m, int alluniv)
{
case Erecolor: a->fp->clr = a->clr;
eresized(0);
break;
- case Edelete:
+ case Edelete:
a->fp->link = univ.p;
univ.p = a->fp;
grow_bb(&univ.bb, &a->fp->bb);
blob - ea36e28df73527887bfc57ebf240ab5d8a95b967
blob + ee112194f2b099312feeb5fdbbbb7723a449c8e7
--- src/cmd/draw/mc.c
+++ src/cmd/draw/mc.c
}else
linewidth = ws.ws_col;
}
-
blob - 74b8b76c72de390cb231720bc85e2d1e3a047ba8
blob + 3b6471b79d2eb6478a41c75bcb4c838d3554fec9
--- src/cmd/draw/stats.c
+++ src/cmd/draw/stats.c
};
char*
-labels[Nvalue] =
+labels[Nvalue] =
{
"802.11",
"battery",
"sys",
"syscall",
"user"
-};
+};
struct Graph
{
if(m->last[i] == 0)
m->last[i] = m->val[i][0];
-
+
if(i == Vload){
/*
* Invert the ewma to obtain the 5s load statistics.
*q = 0;
return 1;
}
-
blob - fef6d2dd16a0f3e825cfac058cd85e95075592a2
blob + f67b10417fdc06d02ed48a425e58c0555b218ce3
--- src/cmd/draw/statusbar.c
+++ src/cmd/draw/statusbar.c
p.x = r.min.x+4;
p.y += display->defaultfont->height+4;
-
+
q = subpt(r.max, Pt(4,4));
rbar = Rpt(p, q);
border(screen, rbar, -2, dark, ZP);
lastp = -1;
flushimage(display, 1);
- drawbar();
+ drawbar();
}
void
keyboardthread(void *v)
-{
+{
Rune r;
while(recv(kc->c , &r) == 1){
void
mousethread(void *v)
-{
+{
USED(v);
-
+
while(recv(mc->c, 0) == 1); /* to unblock mc->c */
}
int lfd;
p = "300x40@100,100";
-
+
ARGBEGIN{
case 'W':
p = ARGF();
}
proccreate(updateproc, nil, STACK);
}
-
blob - caac0be66e713101ac5449cfa6e1b09d344173ab
blob + 9aa4de7980962ee5f1b00c8d5c28143e995099e8
--- src/cmd/draw/tcolors.c
+++ src/cmd/draw/tcolors.c
while(recv(mousectl->resizec, &x) >= 0)
eresized(1);
}
-
blob - 89fdef32a1b84e2532a3142148ba6befa1de921d
blob + 0a71e2dd81b588ccf211458eae62fab1cc6da91d
--- src/cmd/draw/tweak.c
+++ src/cmd/draw/tweak.c
Cursor pixel = {
{-7, -7},
{0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe, 0xf8, 0x1f,
- 0xf0, 0x0f, 0xe0, 0x07, 0xe0, 0x07, 0xfe, 0x7f,
- 0xfe, 0x7f, 0xe0, 0x07, 0xe0, 0x07, 0xf0, 0x0f,
+ 0xf0, 0x0f, 0xe0, 0x07, 0xe0, 0x07, 0xfe, 0x7f,
+ 0xfe, 0x7f, 0xe0, 0x07, 0xe0, 0x07, 0xf0, 0x0f,
0x78, 0x1f, 0x7f, 0xfe, 0x3f, 0xfc, 0x1f, 0xf8, },
- {0x00, 0x00, 0x0f, 0xf0, 0x31, 0x8c, 0x21, 0x84,
- 0x41, 0x82, 0x41, 0x82, 0x41, 0x82, 0x40, 0x02,
- 0x40, 0x02, 0x41, 0x82, 0x41, 0x82, 0x41, 0x82,
+ {0x00, 0x00, 0x0f, 0xf0, 0x31, 0x8c, 0x21, 0x84,
+ 0x41, 0x82, 0x41, 0x82, 0x41, 0x82, 0x40, 0x02,
+ 0x40, 0x02, 0x41, 0x82, 0x41, 0x82, 0x41, 0x82,
0x21, 0x84, 0x31, 0x8c, 0x0f, 0xf0, 0x00, 0x00, }
};
Cursor busy = {
{-7, -7},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0c, 0x00, 0x8e, 0x1d, 0xc7,
- 0xff, 0xe3, 0xff, 0xf3, 0xff, 0xff, 0x7f, 0xfe,
- 0x3f, 0xf8, 0x17, 0xf0, 0x03, 0xe0, 0x00, 0x00,},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xe3, 0xff, 0xf3, 0xff, 0xff, 0x7f, 0xfe,
+ 0x3f, 0xf8, 0x17, 0xf0, 0x03, 0xe0, 0x00, 0x00,},
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x82,
- 0x04, 0x41, 0xff, 0xe1, 0x5f, 0xf1, 0x3f, 0xfe,
+ 0x04, 0x41, 0xff, 0xe1, 0x5f, 0xf1, 0x3f, 0xfe,
0x17, 0xf0, 0x03, 0xe0, 0x00, 0x00, 0x00, 0x00,}
};
Cursor skull = {
{-7,-7},
- {0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0xe7, 0xe7,
- 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0x1f, 0xf8,
- 0x0f, 0xf0, 0x3f, 0xfc, 0xff, 0xff, 0xff, 0xff,
+ {0x00, 0x00, 0x00, 0x00, 0xc0, 0x03, 0xe7, 0xe7,
+ 0xff, 0xff, 0xff, 0xff, 0x3f, 0xfc, 0x1f, 0xf8,
+ 0x0f, 0xf0, 0x3f, 0xfc, 0xff, 0xff, 0xff, 0xff,
0xef, 0xf7, 0xc7, 0xe3, 0x00, 0x00, 0x00, 0x00,},
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0x03,
0xE7, 0xE7, 0x3F, 0xFC, 0x0F, 0xF0, 0x0D, 0xB0,
char buf[256];
l1[0] = 0;
- sprint(buf, "depth:%d r:%d %d %d %d ",
+ sprint(buf, "depth:%d r:%d %d %d %d ",
t->b->depth, t->b->r.min.x, t->b->r.min.y,
t->b->r.max.x, t->b->r.max.y);
if(t->parent)
}
br = t->b->r;
if(t->s == 0){
- c = -1;
+ c = -1;
/* if big enough to bother, sweep box */
if(Dx(br)<=16 && Dy(br)<=16)
r = br;
blob - 25b69692a5ba6285467a46ae10441f1d5eed4d24
blob + aa620b04ac8ab438cdde85e5c63c8c8d015025c5
--- src/cmd/echo.c
+++ src/cmd/echo.c
if(i < argc-1)
*p++ = ' ';
}
-
+
if(!nflag)
*p++ = '\n';
blob - 4084994cc38020b24437f3fd68c62c7513441639
blob + 8b0f36e547b8bf8e204a624715d67349221599e0
--- src/cmd/ed.c
+++ src/cmd/ed.c
a1 = dol;
if((addr2=a1) == 0) {
given = 0;
- addr2 = dot;
+ addr2 = dot;
} else
given = 1;
if(addr1 == 0)
i++;
if(fullrune(s, i))
break;
-
+
}
chartorune(&r, s);
lastc = r;
getblock(int atl, int iof)
{
int bno, off;
-
+
static uchar ibuff[BLKSIZE];
static uchar obuff[BLKSIZE];
}
loc1 = loc2 = 0;
return 0;
-
+
}
void
blob - 10dc8c75c0d6ab96a6106fba5dd4ce2aaf902ad7
blob + 54f48f798d94787ee44466f58d9541dc4953a952
--- src/cmd/eqn/diacrit.c
+++ src/cmd/eqn/diacrit.c
nrwid(c, ps, c);
if (lfont[p1] != ITAL)
printf(".nr %d 0\n", t);
- printf(".as %d \\h'-\\n(%du-\\n(%du/2u+\\n(%du'\\v'0-\\n(10u'\\*(%d",
+ printf(".as %d \\h'-\\n(%du-\\n(%du/2u+\\n(%du'\\v'0-\\n(10u'\\*(%d",
p1, p1, c, t, c);
printf("\\v'\\n(10u'\\h'-\\n(%du+\\n(%du/2u-\\n(%du'\n", c, p1, t);
if (type != UNDER && type != UTILDE)
blob - 6ec013bbca2cc0db5b9abaa46d4c495f5e0fe18a
blob + 98006aa9a70ad052c0004da3dba8729da4f109bb
--- src/cmd/eqn/eqnbox.c
+++ src/cmd/eqn/eqnbox.c
yyval = p1;
b = max(ebase[p1], ebase[p2]);
- eht[yyval] = h = b + max(eht[p1]-ebase[p1],
+ eht[yyval] = h = b + max(eht[p1]-ebase[p1],
eht[p2]-ebase[p2]);
ebase[yyval] = b;
dprintf(".\tS%d <- %d %d; b=%g, h=%g\n", (int)yyval, p1, p2, b, h);
blob - 3fb01119cc69e9a78b43df030fee71ec2a24fa2b
blob + 961c7bb21564c686fdceaf843be425754a7f50d0
--- src/cmd/eqn/font.c
+++ src/cmd/eqn/font.c
} else if (strcmp(temp, "R") == 0 || strncmp(temp, "ro", 2) == 0) {
ft = ROM;
strcpy(temp, "1");
- } else {
+ } else {
ft = ROM; /* assume it's a roman style */
}
ftstack[0].ft = ft;
blob - cf9c96e50b2f8cc6bbbea185ee9862ddb9c4155a
blob + 5dda828c96295b87ddcba3e6f63d7dc11a98d5d5
--- src/cmd/eqn/fromto.c
+++ src/cmd/eqn/fromto.c
printf(".ds %d ", (int)yyval); /* bottom of middle box */
if (p2 > 0) {
t = eht[p2]-ebase[p2]+b1;
- printf("\\v'%gm'\\h'\\n(%du-\\n(%du/2u'%s\\*(%d%s",
+ printf("\\v'%gm'\\h'\\n(%du-\\n(%du/2u'%s\\*(%d%s",
REL(t,ps), (int)yyval, p2, DPS(ps,subps), p2, DPS(subps,ps));
- printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
+ printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
(int)yyval, p2, REL(-t,ps));
}
- printf("\\h'\\n(%du-\\n(%du/2u'\\*(%d\\h'\\n(%du-\\n(%du/2u'\\\n",
+ printf("\\h'\\n(%du-\\n(%du/2u'\\*(%d\\h'\\n(%du-\\n(%du/2u'\\\n",
(int)yyval, p1, p1, (int)yyval, p1);
if (p3 >0) {
t = h1-b1+ebase[p3];
- printf("\\v'%gm'\\h'-\\n(%du-\\n(%du/2u'%s\\*(%d%s\\h'\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
+ printf("\\v'%gm'\\h'-\\n(%du-\\n(%du/2u'%s\\*(%d%s\\h'\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
REL(-t,ps), (int)yyval, p3, DPS(ps,subps), p3, DPS(subps,ps), (int)yyval, p3, REL(t,ps));
}
printf("\n");
ebase[yyval] = b + b1;
- dprintf(".\tS%d <- %d from %d to %d; h=%g b=%g\n",
+ dprintf(".\tS%d <- %d from %d to %d; h=%g b=%g\n",
(int)yyval, p1, p2, p3, eht[yyval], ebase[yyval]);
sfree(p1);
if (p2 > 0)
blob - 3d0cef7479c5aee27a9b976546ba5d77b4c75a3f
blob + f5e42758fc54bc5a9315ecac3425f05dfc472e73
--- src/cmd/eqn/funny.c
+++ src/cmd/eqn/funny.c
printf(".ds %d %s\n", (int)yyval, f);
eht[yyval] = EM(1.0, ps+Funnyps) - EM(Funnyht, ps);
ebase[yyval] = EM(Funnybase, ps);
- dprintf(".\tS%d <- %s; h=%g b=%g\n",
+ dprintf(".\tS%d <- %s; h=%g b=%g\n",
(int)yyval, f, eht[yyval], ebase[yyval]);
lfont[yyval] = rfont[yyval] = ROM;
}
blob - 25f7eee327035a0d4934b007859841ba3bf6f21a
blob + 816218c026962d94991b50454a9729dd766f88a8
--- src/cmd/eqn/main.c
+++ src/cmd/eqn/main.c
printf(".lf %d\n", curfile->lineno+1);
if (curfile->lineno > n+3)
fprintf(stderr, "eqn warning: multi-line %c...%c, file %s:%d,%d\n",
- lefteq, righteq, curfile->fname, n, curfile->lineno);
+ lefteq, righteq, curfile->fname, n, curfile->lineno);
sfree(ds);
if (sz1) sfree(sz1);
}
} else {
*lb++ = dn + '0';
}
- *lb++ = '\0';
+ *lb++ = '\0';
return p;
}
} else {
*lb++ = dn + '0';
}
- *lb++ = '\0';
+ *lb++ = '\0';
return p;
}
blob - c97b036ca8ee2f520857f95c466271d0e88efc66
blob + 3976350882ef081e000c9c0555e33706b2c1935c
--- src/cmd/eqn/mbwc.c
+++ src/cmd/eqn/mbwc.c
}
return p-s;
}
-
blob - 06448adda02b330587a28563428e5efd5f7c6296
blob + b6462c78b3862f3f227428e0cc1a1a65c483ed86
--- src/cmd/eqn/move.c
+++ src/cmd/eqn/move.c
printf("\\v'-%gm'\\*(%d\\v'%gm'\n", a, p, a);
else if (dir == DOWN)
printf("\\v'%gm'\\*(%d\\v'-%gm'\n", a, p, a);
- dprintf(".\tmove %d dir %d amt %g; h=%g b=%g\n",
+ dprintf(".\tmove %d dir %d amt %g; h=%g b=%g\n",
p, dir, a, eht[yyval], ebase[yyval]);
}
blob - 575d1c8e6ada0273149e8cceb053778044dd95c6
blob + 0d519dd50b8e7aded4156637562020283976798b
--- src/cmd/eqn/over.c
+++ src/cmd/eqn/over.c
d = EM(Overgap, ps);
h = eht[p1] + eht[p2] + d;
b = eht[p2] - d;
- dprintf(".\tS%d <- %d over %d; b=%g, h=%g\n",
+ dprintf(".\tS%d <- %d over %d; b=%g, h=%g\n",
(int)yyval, p1, p2, b, h);
nrwid(p1, ps, p1);
nrwid(p2, ps, p2);
printf(".if \\n(%d>\\n(%d .nr %d \\n(%d\n", p2, treg, treg, p2);
printf(".nr %d \\n(%d+%gm\n", treg, treg, Overwid);
d2 = eht[p2]-ebase[p2]-d; /* denom */
- printf(".ds %d \\v'%gm'\\h'\\n(%du-\\n(%du/2u'\\*(%d\\v'%gm'\\\n",
+ printf(".ds %d \\v'%gm'\\h'\\n(%du-\\n(%du/2u'\\*(%d\\v'%gm'\\\n",
(int)yyval, REL(d2,ps), treg, p2, p2, REL(-d2,ps));
d1 = 2 * d + ebase[p1]; /* num */
- printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\*(%d\\v'%gm'\\\n",
+ printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\*(%d\\v'%gm'\\\n",
p2, p1, REL(-d1,ps), p1, REL(d1,ps));
- printf("\\h'-\\n(%du-\\n(%du/2u+%gm'\\v'%gm'\\l'\\n(%du-%gm'\\h'%gm'\\v'%gm'\n",
+ printf("\\h'-\\n(%du-\\n(%du/2u+%gm'\\v'%gm'\\l'\\n(%du-%gm'\\h'%gm'\\v'%gm'\n",
treg, p1, Overline, REL(-d,ps),
treg, 2*Overline, Overline, REL(d,ps));
ebase[yyval] = b;
blob - 4a9fea0bb93383c3d0a01cbb919cb33d39fe6051
blob + e7d7d7ce3b3e78ed6a51b1e56cb5f52e62444198
--- src/cmd/eqn/paren.c
+++ src/cmd/eqn/paren.c
printf("\\v'%gm'", -bv);
}
printf("\n");
- dprintf(".\tcurly: h=%g b=%g n=%d v=%g l=%c, r=%c\n",
+ dprintf(".\tcurly: h=%g b=%g n=%d v=%g l=%c, r=%c\n",
eht[yyval], ebase[yyval], n, v, leftc, rightc);
}
blob - a8901721782f6055dd9d7052b723e032a32149df
blob + 8052e5c41f9efe19b3aeb1cdff18b0f858c4855c
--- src/cmd/eqn/pile.c
+++ src/cmd/eqn/pile.c
printf(".nr %d \\n(%d\n", (int)yyval, lp[p1]);
for (i = p1+1; i < p2; i++) {
nrwid(lp[i], ps, lp[i]);
- printf(".if \\n(%d>\\n(%d .nr %d \\n(%d\n",
+ printf(".if \\n(%d>\\n(%d .nr %d \\n(%d\n",
lp[i], (int)yyval, (int)yyval, lp[i]);
}
- printf(".ds %d \\v'%gm'\\h'%du*\\n(%du'\\\n", (int)yyval, REL(ebase[yyval],ps),
+ printf(".ds %d \\v'%gm'\\h'%du*\\n(%du'\\\n", (int)yyval, REL(ebase[yyval],ps),
type==RCOL ? 1 : 0, (int)yyval);
sb = 0; /* sum of box hts */
for (i = p2-1; i >= p1; i--) {
bi = sb + ebase[lp[i]];
switch (type) {
case LCOL:
- printf("\\v'%gm'\\*(%d\\h'-\\n(%du'\\v'%gm'\\\n",
+ printf("\\v'%gm'\\*(%d\\h'-\\n(%du'\\v'%gm'\\\n",
REL(-bi,ps), lp[i], lp[i], REL(bi,ps));
break;
case RCOL:
- printf("\\v'%gm'\\h'-\\n(%du'\\*(%d\\v'%gm'\\\n",
+ printf("\\v'%gm'\\h'-\\n(%du'\\*(%d\\v'%gm'\\\n",
REL(-bi,ps), lp[i], lp[i], REL(bi,ps));
break;
case CCOL:
case COL:
- printf("\\v'%gm'\\h'\\n(%du-\\n(%du/2u'\\*(%d",
+ printf("\\v'%gm'\\h'\\n(%du-\\n(%du/2u'\\*(%d",
REL(-bi,ps), (int)yyval, lp[i], lp[i]);
- printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
+ printf("\\h'-\\n(%du-\\n(%du/2u'\\v'%gm'\\\n",
(int)yyval, lp[i], REL(bi,ps));
break;
}
sb += eht[lp[i]] + gap;
}
- printf("\\v'%gm'\\h'%du*\\n(%du'\n", REL(-ebase[yyval],ps),
+ printf("\\v'%gm'\\h'%du*\\n(%du'\n", REL(-ebase[yyval],ps),
type!=RCOL ? 1 : 0, (int)yyval);
for (i = p1; i < p2; i++)
sfree(lp[i]);
blob - 970c13e7cb6e4e4718e4c50eb61b86cfad5e909e
blob + 34f0408089c8a030c4dfca09b4a5507c2cfb06ab
--- src/cmd/eqn/shift.c
+++ src/cmd/eqn/shift.c
sh1 = pad(n);
rclass[p1] = rclass[p2]; /* OTHER leaves too much after sup */
}
- dprintf(".\tS%d <- %d shift %g %d; b=%g, h=%g, ps=%d, subps=%d\n",
+ dprintf(".\tS%d <- %d shift %g %d; b=%g, h=%g, ps=%d, subps=%d\n",
(int)yyval, p1, shval, p2, ebase[yyval], eht[yyval], ps, subps);
sh2 = Sub2space; /* was Sub2space; */
- printf(".as %d \\v'%gm'%s%s\\*(%d%s%s\\v'%gm'\n",
+ printf(".as %d \\v'%gm'%s%s\\*(%d%s%s\\v'%gm'\n",
(int)yyval, REL(shval,ps), DPS(ps,subps), sh1, p2,
DPS(subps,ps), sh2, REL(-shval,ps));
rfont[p1] = 0;
nrwid(p3, subps, p3);
printf(".nr %d \\n(%d\n", treg, p3);
printf(".if \\n(%d>\\n(%d .nr %d \\n(%d\n", p2, treg, treg, p2);
- printf(".as %d %s\\v'%gm'\\*(%d\\v'%gm'\\h'-\\n(%du'\\\n",
+ printf(".as %d %s\\v'%gm'\\*(%d\\v'%gm'\\h'-\\n(%du'\\\n",
p1, DPS(ps,subps), REL(subsh,subps), p2, REL(-subsh,subps), p2);
- printf("\\v'%gm'\\*(%d\\v'%gm'\\h'-\\n(%du+\\n(%du'%s%s\n",
+ printf("\\v'%gm'\\*(%d\\v'%gm'\\h'-\\n(%du+\\n(%du'%s%s\n",
REL(supsh,subps), p3, REL(-supsh,subps), p3, treg, DPS(subps,ps), Sub2space);
if (rfont[p2] == ITAL)
rfont[yyval] = 0; /* lie */
blob - 01837e144020dbb99eceba67dc7f64a12cc8d88e
blob + 3e57b4dedd26ab4c22114602cbbd65fe3b30313d
--- src/cmd/eqn/size.c
+++ src/cmd/eqn/size.c
{
/* old size in p1, new in ps */
yyval = p2;
- dprintf(".\tS%d <- \\s%d %d \\s%d; b=%g, h=%g\n",
+ dprintf(".\tS%d <- \\s%d %d \\s%d; b=%g, h=%g\n",
(int)yyval, ps, p2, p1, ebase[yyval], eht[yyval]);
if (szstack[nszstack] != 0) {
printf(".ds %d %s\\*(%d\\s\\n(%d\n", (int)yyval, ABSPS(ps), p2, 99-nszstack);
blob - 69359b67336cae15b1783351d8fdb8d12960df96
blob + 0963fe45f6ffc6d5d621684a6a3075a2baf32f3e
--- src/cmd/eqn/sqrt.c
+++ src/cmd/eqn/sqrt.c
eht[yyval] = EM(1.15, nps);
else /* DEV202, DEVPOST */
eht[yyval] = EM(1.15, nps);
- dprintf(".\tS%d <- sqrt S%d;b=%g, h=%g, nps=%d\n",
+ dprintf(".\tS%d <- sqrt S%d;b=%g, h=%g, nps=%d\n",
(int)yyval, p2, ebase[yyval], eht[yyval], nps);
printf(".as %d \\|\n", (int)yyval);
nrwid(p2, ps, p2);
blob - c016cca085cc3ea4fcb3b55ea06fc8b2aed10aad
blob + 4ca0bbd9d3501a2988ae37eae9470d4f78d415e8
--- src/cmd/eqn/text.c
+++ src/cmd/eqn/text.c
cadd(c);
psp++;
} else {
- cadd(c);
+ cadd(c);
}
return f;
case '-':
if (n < 0) {
sprintf(buf, "\\h'-%du*\\w'\\^'u'", -n);
return buf;
- }
+ }
for ( ; n > 1; n -= 2)
strcat(buf, "\\|");
if (n > 0)
blob - a24a391ad60b86091ff3b14d57a243f59643fad1
blob + 5043aa782f92b07533a8d70e9fdc5f71f3d14c46
--- src/cmd/faces/facedb.c
+++ src/cmd/faces/facedb.c
continue;
/*
- * if it's less than 30 seconds since we read it, or it
+ * if it's less than 30 seconds since we read it, or it
* hasn't changed, send back our copy
*/
if(time(0) - r->rdtime < 30)
{
static char buf[1024];
char *file, *p, *nextp, *q;
-
+
if((file = readfile(dict)) == nil)
return nil;
estrstrdup(char *a, char *b)
{
char *t;
-
+
t = emalloc(strlen(a)+strlen(b)+1);
strcpy(t, a);
strcat(t, b);
int fd;
int i, n;
Dir *d;
-
+
/*
* If this directory has a .machinelist, use it.
*/
return x;
}
free(dict);
-
+
/*
* If not, recurse into subdirectories.
* Ignore 48x48xN directories for now.
free(d);
}
close(fd);
-
+
/*
* Handle 48x48xN directories in the right order.
*/
return;
if(++nsaved > Nsave)
clearsaved();
-}
+}
static Image*
myallocimage(ulong chan)
}
return img;
}
-
+
static Image*
readbit(int fd, ulong chan)
mask = myallocimage(GREY1);
if(mask == nil)
goto Done;
- if(unloadimage(face, face->r, data, Facesize*Facesize) != Facesize*Facesize){
+ if(unloadimage(face, face->r, data, Facesize*Facesize) != Facesize*Facesize){
freeimage(mask);
goto Done;
}
bits = 0;
p = mdata;
for(y=0; y<Facesize; y++){
- for(x=0; x<Facesize; x++){
+ for(x=0; x<Facesize; x++){
bits <<= 1;
if(data[Facesize*y+x] != 0xFF)
bits |= 1;
blob - bb36ed7cef322964ac1c0afa71314f7f97db2ac2
blob + 30343c745d5505da1c8ec736725b6b26c77dc521
--- src/cmd/faces/main.c
+++ src/cmd/faces/main.c
Infolines = 9,
HhmmTime = 18*60*60, /* max age of face to display hh:mm time */
-
+
STACK = 32768
};
continue;
if(((long)(now - f->time) <= HhmmTime) != f->recent)
drawface(f, i);
- }
+ }
}
void
return;
}else{
for(i=first; i<last; i++) /* clear vwhois faces */
- if(ptinrect(p, facerect(i-first))
+ if(ptinrect(p, facerect(i-first))
&& strstr(faces[i]->str[Sshow], "/XXXvwhois")){
lockdisplay(display);
delface(i);
blob - 6d82c779f866639c06d7df1a403232dcf4ae796b
blob + b2fcfa85f1ff2990eccf24993cb922f5c83a4cf7
--- src/cmd/faces/plumb.c
+++ src/cmd/faces/plumb.c
static char* months[] = {
"jan", "feb", "mar", "apr",
- "may", "jun", "jul", "aug",
+ "may", "jun", "jul", "aug",
"sep", "oct", "nov", "dec"
};
blob - 22f57549cfd7aa4c1fca773c40b643e9030d1cd0
blob + 5f3e7fde9c862a66f6387dbd22272487cefb614e
--- src/cmd/faces/util.c
+++ src/cmd/faces/util.c
}
return t;
}
-
blob - 32d580cdfc26bc4b7f539cf983d2d5761e0fa032
blob + 0ee1d1cfc797b924ac64b124ecc84f4ac743d9d4
--- src/cmd/file.c
+++ src/cmd/file.c
"common", Fword,
"con", Lword,
"data", Fword,
- "dimension", Fword,
+ "dimension", Fword,
"double", Cword,
"extern", Cword,
"bio", I2,
enum {
Normal = 0,
First, /* first entry for language spanning several ranges */
- Multi, /* later entries " " " ... */
+ Multi, /* later entries " " " ... */
Shared, /* codes used in several languages */
};
int low;
int high;
char *name;
-
+
} language[] =
{
Normal, 0, 0x0080, 0x0080, "Extended Latin",
Shared, 0, 0x4e00, 0x9fff, "CJK",
Normal, 0, 0, 0, 0, /* terminal entry */
};
-
-
+
+
enum
{
Fascii, /* printable ascii */
* lookup dictionary words
*/
memset(wfreq, 0, sizeof(wfreq));
- if(guess == Fascii || guess == Flatin || guess == Futf)
+ if(guess == Fascii || guess == Flatin || guess == Futf)
wordfreq();
/*
* call individual classify routines
}
return 0;
}
-
+
int
long0(void)
{
}
if(wfreq[Alword] > 0)
print("alef program\n");
- else
+ else
print("c program\n");
return 1;
}
s++; /* skip letter */
d += strtoul(s, &s, 10);
}
-
+
switch(d){
case 32:
case 24:
blob - 1c4de8714e9e16cd7dd2c9e0f935c54b64aebb12
blob + 047da847dff8f2e15702198acb17a9be78282290
--- src/cmd/fmt.c
+++ src/cmd/fmt.c
ind -= ind%maxtab;
break;
}
-
+
/* plain white space doesn't change the indent */
*linep = "";
return indent;
blob - 37f0da32dcaf4191d130ff3c240ab7e557cc4792
blob + ebab624975823d8d7fa561bec2597c9b75efd3ae
--- src/cmd/fontsrv/main.c
+++ src/cmd/fontsrv/main.c
vlong length;
XFont *f;
char buf[100];
-
+
q.type = 0;
q.vers = 0;
q.path = path;
snprint(buf, sizeof buf, "%lld%s", QSIZE(path), QANTIALIAS(path) ? "a" : "");
name = buf;
break;
-
+
case Qfontfile:
f = &xfont[QFONT(path)];
load(f);
name = buf;
break;
}
-
+
if(qid)
*qid = q;
if(dir) {
{
vlong path;
Fid *f;
-
+
f = v;
path = f->qid.path;
if(i >= 2*nelem(sizes))
responderrstr(Req *r)
{
char err[ERRMAX];
-
+
rerrstr(err, sizeof err);
respond(r, err);
}
char *data;
Memsubfont *sf;
Memimage *m;
-
+
path = r->fid->qid.path;
switch(QTYPE(path)) {
case Qroot:
xdestroyfid(Fid *fid)
{
Memsubfont *sf;
-
+
sf = fid->aux;
if(sf == nil)
return;
// root
memset(&fid, 0, sizeof fid);
- dostat(0, &fid.qid, nil);
+ dostat(0, &fid.qid, nil);
qid = fid.qid;
path0 = path;
*p++ = '/';
path = p;
}
-
+
memset(&r, 0, sizeof r);
xsrv.fake = 1;
default:
usage();
}ARGEND
-
+
xsrv.attach = xattach;
xsrv.open = xopen;
xsrv.read = xread;
memimageinit();
loadfonts();
qsort(xfont, nxfont, sizeof xfont[0], fontcmp);
-
+
if(pflag) {
if(argc != 1 || chatty9p || chattyfuse)
usage();
return nn;
}
-
blob - c01ae6ce5d9dd2a8bac530e881368959698d6154
blob + b4dadd90a0a2fc4954636a0fbdef626817593792
--- src/cmd/fontsrv/osx.c
+++ src/cmd/fontsrv/osx.c
char *p;
int n;
- n = CFStringGetLength(s)*8;
+ n = CFStringGetLength(s)*8;
p = malloc(n);
CFStringGetCString(s, p, n, kCFStringEncodingUTF8);
return p;
if(f == nil)
continue;
s = CTFontDescriptorCopyAttribute(f, kCTFontNameAttribute);
- xfont[nxfont].name = mac2c(s);
+ xfont[nxfont].name = mac2c(s);
CFRelease(s);
nxfont++;
}
CTLineRef line;
str = c2mac(lines[i]);
-
+
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
r.size.width += r.origin.x;
r.size.height += r.origin.y;
CFRelease(line);
-
+
// fprint(2, "%s: %g %g %g %g\n", lines[i], r.origin.x, r.origin.y, r.size.width, r.size.height);
-
+
if(i == 0)
bbox = r;
if(bbox.origin.x > r.origin.x)
- bbox.origin.x = r.origin.x;
+ bbox.origin.x = r.origin.x;
if(bbox.origin.y > r.origin.y)
- bbox.origin.y = r.origin.y;
+ bbox.origin.y = r.origin.y;
if(bbox.size.width < r.size.width)
bbox.size.width = r.size.width;
if(bbox.size.height < r.size.height)
*height = bbox.size.height + 0.999999;
*ascent = *height - (-bbox.origin.y + 0.999999);
-
+
CGContextRelease(ctxt);
CFRelease(font);
}
CFRelease(desc);
if(font == nil)
return nil;
-
-
+
+
bbox = CTFontGetBoundingBox(font);
x = (int)(bbox.size.width*2 + 0.99999999);
sprint(buf, "%C", (Rune)mapUnicode(name, i));
str = c2mac(buf);
-
+
// See https://developer.apple.com/library/ios/documentation/StringsTextFonts/Conceptual/CoreText_Programming/LayoutOperations/LayoutOperations.html#//apple_ref/doc/uid/TP40005533-CH12-SW2
attrs = CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys,
(const void**)&values, sizeof(keys) / sizeof(keys[0]),
CGContextSetTextPosition(ctxt, 0, y0);
r = CTLineGetImageBounds(line, ctxt);
memfillcolor(mc, DBlack);
- CTLineDraw(line, ctxt);
+ CTLineDraw(line, ctxt);
CFRelease(line);
fc->x = x;
if(i == 0) {
drawpjw(m, fc, x, (int)(bbox.size.width + 0.99999999), y, y - y0);
x += fc->width;
- }
+ }
continue;
}
sf->ascent = Dy(m1->r) - y0;
sf->info = fc0;
sf->bits = m1;
-
+
return sf;
}
blob - 30ebbed2c7f7ca48466a26a8c5ff40179121e771
blob + 82e8cfa1de4d7839f80a81fde148c9259adb385d
--- src/cmd/fontsrv/pjw.c
+++ src/cmd/fontsrv/pjw.c
Memimage *pm, *pm1, *pm2;
Rectangle r;
int margin;
-
+
w = width;
// assume margin below baseline is
close(p[0]);
if(pm == nil)
goto Error;
-
+
pm1 = allocmemimage(pm->r, GREY8);
memimagedraw(pm1, pm1->r, pm, pm->r.min, nil, ZP, S);
pm2 = resample(w, w, pm1);
return f;
}
-/*
+/*
* i0(x) is the modified Bessel function, Σ (x/2)^2L / (L!)²
* There are faster ways to calculate this, but we precompute
* into a table so let's keep it simple.
blob - ac7242513af3f692c53814f9d4cea331b67461d3
blob + 121e5b66c34c59ef378f032daaae7f15ccb72a2b
--- src/cmd/fossil/9fsys.c
+++ src/cmd/fossil/9fsys.c
{
char *usage = "usage: [fsys name] sync";
int n;
-
+
ARGBEGIN{
default:
return cliError(usage);
mbDelete(mb, i);
mbPack(mb);
- blockDirty(b);
+ blockDirty(b);
}
static void
consPrint("%#ux is already closed\n", b->addr);
return;
}
- if(epoch){
+ if(epoch){
l.state |= BsClosed;
l.epochClose = epoch;
}else
l.state = BsFree;
-
+
if(!blockSetLabel(b, &l, 0))
consPrint("%#ux setlabel: %r\n", b->addr);
}
blob - b4023e8bead490532f0da83787289c83f2fd1e82
blob + 4f9607294afc53756669fd8a13a2940fb9c393ac
--- src/cmd/fossil/9lstn.c
+++ src/cmd/fossil/9lstn.c
Lstn *lstn;
int dfd, lfd;
char newdir[NETPATHLEN];
-
+
threadsetname("listen");
lstn = a;
blob - 6738670e0e2e19d6527e05673dc9836f9cdcea1e
blob + e15622afae990e93ee8e96563c34a2a3f3afe0a6
--- src/cmd/fossil/9p.c
+++ src/cmd/fossil/9p.c
/*
* Check remote IP address against /mnt/ipok.
* Sources.cs.bell-labs.com uses this to disallow
- * network connections from Sudan, Libya, etc.,
+ * network connections from Sudan, Libya, etc.,
* following U.S. cryptography export regulations.
*/
static int
}
if(access("/mnt/ipok/ok", AEXIST) < 0){
/* mount closes the fd on success */
- if((fd = open("/srv/ipok", ORDWR)) >= 0
+ if((fd = open("/srv/ipok", ORDWR)) >= 0
&& mount(fd, -1, "/mnt/ipok", MREPL, "") < 0)
close(fd);
if(access("/mnt/ipok/ok", AEXIST) < 0){
blob - dbf628c5b44117d0c24f945a6dec2362ee794017
blob + d820f20810cdb40380b61525098909d87e2d5375
--- src/cmd/fossil/9ping.c
+++ src/cmd/fossil/9ping.c
int n = 1000, m;
int s = 1;
double *t, t0, t1;
- uchar *buf;
+ uchar *buf;
double a, d, max, min;
m = OREAD;
buf = malloc(s);
t = malloc(n*sizeof(double));
-
+
t0 = nsec();
for(i=0; i<n; i++){
if(m == OREAD){
}
a /= n;
-
+
for(i=0; i<n; i++)
d += (a - t[i]) * (a - t[i]);
d /= n;
blob - 7a88f23e0d0613ba39e957dd897d5a11bcf45faa
blob + 451fe628978efec48f0f4eac884fec1bdd3bcf89
--- src/cmd/fossil/archive.c
+++ src/cmd/fossil/archive.c
blockDirty(b);
/*
* If b is in the active tree, then we need to note that we've
- * just removed addr from the active tree (replacing it with the
+ * just removed addr from the active tree (replacing it with the
* copy we just stored to Venti). If addr is in other snapshots,
* this will close addr but not free it, since it has a non-empty
* epoch range.
*
* If b is in the active tree but has been copied (this can happen
* if we get killed at just the right moment), then we will
- * mistakenly leak its kids.
+ * mistakenly leak its kids.
*
* The children of an archive directory (e.g., /archive/2004/0604)
* are not treated as in the active tree.
blob - 8cd0956ee391ddd43fcbfd0ed395d76f4be681fa
blob + 7dcd6b2de2f0174d7c46c46a876c28a26fdbeeff
--- src/cmd/fossil/bwatch.c
+++ src/cmd/fossil/bwatch.c
}
}
/*
- * and child
+ * and child
*/
static void
_bwatchResetChild(uchar *score)
}else
w->b[i] = w->b[--w->nb];
}
-
blob - 23f89461ee488c08dec00fce2136fb35e4e3e33c
blob + 6707d50ae4c2e5e98e05595b08df1c06e644273e
--- src/cmd/fossil/cache.c
+++ src/cmd/fossil/cache.c
/*
* Mark an in-memory block as dirty. If there are too many
- * dirty blocks, start writing some out to disk.
- *
+ * dirty blocks, start writing some out to disk.
+ *
* If there were way too many dirty blocks, we used to
- * try to do some flushing ourselves, but it's just too dangerous --
+ * try to do some flushing ourselves, but it's just too dangerous --
* it implies that the callers cannot have any of our priors locked,
* but this is hard to avoid in some cases.
*/
}
/*
- * The active file system is a tree of blocks.
+ * The active file system is a tree of blocks.
* When we add snapshots to the mix, the entire file system
* becomes a dag and thus requires a bit more care.
- *
+ *
* The life of the file system is divided into epochs. A snapshot
* ends one epoch and begins the next. Each file system block
* is marked with the epoch in which it was created (b.epoch).
* When the block is unlinked from the file system (closed), it is marked
- * with the epoch in which it was removed (b.epochClose).
- * Once we have discarded or archived all snapshots up to
+ * with the epoch in which it was removed (b.epochClose).
+ * Once we have discarded or archived all snapshots up to
* b.epochClose, we can reclaim the block.
*
* If a block was created in a past epoch but is not yet closed,
* lbb (bb's label block).
*
* (2) We have to mark b as closed, but only after we switch
- * the pointer, so lb must be written out after p. In fact, we
+ * the pointer, so lb must be written out after p. In fact, we
* can't even update the in-memory copy, or the cache might
* mistakenly give out b for reuse before p gets written.
*
* to arrange for (2) to happen once p is written.
*
* Until (2) happens, some pieces of the code (e.g., the archiver)
- * still need to know whether a block has been copied, so we
+ * still need to know whether a block has been copied, so we
* set the BsCopied bit in the label and force that to disk *before*
* the copy gets written out.
*/
blockRemoveLink(Block *b, u32int addr, int type, u32int tag, int recurse)
{
BList *p, **pp, bl;
-
+
/* remove bb from prior list */
for(pp=&b->prior; (p=*pp)!=nil; ){
if(p->part == PartData && p->addr == addr){
b->utail = p;
}
-/*
+/*
* Process removal of a single block and perhaps its children.
*/
static void
/*
* No free BLists. What are our options?
*/
-
+
/* Block has no priors? Just write it. */
if(b->prior == nil){
qunlock(&c->lk);
blob - c003f70693886c64e35dd14447649feb23285de8
blob + 2068a617624ef2745c04b76b46d4d9cae297556f
--- src/cmd/fossil/flchk.c
+++ src/cmd/fossil/flchk.c
int csize = 1000;
VtConn *z;
char *host = nil;
-
+
fsck.useventi = 1;
Binit(&bout, 1, OWRITE);
ARGBEGIN{
threadexitsall(0);
}
-
blob - ac466bdd5bb2145527532bff4c49bfdc8b9d7e89
blob + 128227d8a48bf5cc7b258d5adf112e221a5acb30
--- src/cmd/fossil/flfmt9660.c
+++ src/cmd/fossil/flfmt9660.c
/*
* Initialize a fossil file system from an ISO9660 image already in the
* file system. This is a fairly bizarre thing to do, but it lets us generate
- * installation CDs that double as valid Plan 9 disk partitions.
+ * installation CDs that double as valid Plan 9 disk partitions.
* People having trouble booting the CD can just copy it into a disk
* partition and you've got a working Plan 9 system.
*
c = (Cdir*)((uchar*)c+c->len); /* skip dotdot */
/* oops: might happen if leftmost directory is empty or leftmost file is zero length! */
if(little(c->dloc, 4) == 0)
- sysfatal("error parsing cd image or unfortunate cd image");
+ sysfatal("error parsing cd image or unfortunate cd image");
}
return little(c->dloc, 4);
}
blob - 5f8a1cfd099039eea3397bf28637e984207a4ed7
blob + d1baf736bf4102f83560e2bb6a934eb0b6147591
--- src/cmd/fossil/fs.c
+++ src/cmd/fossil/fs.c
* It is important that we maintain the invariant that:
* if both b and bb are marked as Active with start epoch e
* and b points at bb, then no other pointers to bb exist.
- *
+ *
* When bb is unlinked from b, its close epoch is set to b's epoch.
* A block with epoch == close epoch is
* treated as free by cacheAllocBlock; this aggressively
periodicKill(s->tick);
vtfree(s);
}
-
blob - 9f98c03fe178aa06faf985a2d26e47246fbfad41
blob + e0e7b17eb2d184733d3a0bb6da9b7f21f3499c22
--- src/cmd/fossil/nobwatch.c
+++ src/cmd/fossil/nobwatch.c
{
USED(b);
}
-
blob - b27f90b86f2a16992d73a7622d64aeef203d7cb4
blob + 75077a05df39bc5e00be41e16543f63538de30fa
--- src/cmd/fossil/pack.c
+++ src/cmd/fossil/pack.c
werrstr(EBadSuper);
return 0;
}
-
blob - 634f975d8dd53388ad565fcf8d33223ab30f7ae7
blob + 6164eca22725dcdf03cf5ea2373c7ad5f49ab4b1
--- src/cmd/fossil/periodic.c
+++ src/cmd/fossil/periodic.c
}
periodicFree(p);
}
-
blob - 8cf63b4f62d35bbdac8ff72bec377151056c5b61
blob + 97e455411c42d83e64936c2b8213c2c5cf31b7ea
--- src/cmd/fossil/srcload.c
+++ src/cmd/fossil/srcload.c
case 'l':
length = atoi(ARGF());
break;
- case 'b':
+ case 'b':
block = atoi(ARGF());
break;
case 'u':
fprint(2, "count = %d\n", count(r, 1));
fprint(2, "total time = %ld\n", time(0)-t);
-
+
fsClose(fs);
vtDetach();
exits(0);
int i, n;
Source *ss;
Entry e;
-
+
if(depth > maxdepth)
maxdepth = depth;
}
if(i == n)
return 0;
-
+
for(;;){
ss = sourceOpen(s, nrand(n), OReadWrite);
if(ss == nil)
blob - ed18febc4814db71aee5ee49b05acbe104826e40
blob + 659e538097b54165f93ef9d8a97b0ba37586f59a
--- src/cmd/fossil/view.c
+++ src/cmd/fossil/view.c
}
/*
- * visualizer
+ * visualizer
*/
#pragma varargck argpos stringnode 1
}
typedef struct Xentry Xentry;
-struct Xentry
+struct Xentry
{
Tnode t;
Entry e;
if((i & 1) == 0)
c <<= 4;
-
+
score[i>>1] |= c;
}
return 1;
o.y += (display->defaultfont->height-Nubheight)/2;
draw(m, rectaddpt(Rect(0,0,1,Nubheight), o), display->black, clipr, ZP);
draw(m, rectaddpt(Rect(0,0,Nubwidth,1), o), display->black, clipr, o);
- draw(m, rectaddpt(Rect(Nubwidth-1,0,Nubwidth,Nubheight), o),
+ draw(m, rectaddpt(Rect(Nubwidth-1,0,Nubwidth,Nubheight), o),
display->black, clipr, addpt(o, Pt(Nubwidth-1, 0)));
draw(m, rectaddpt(Rect(0, Nubheight-1, Nubwidth, Nubheight), o),
display->black, clipr, addpt(o, Pt(0, Nubheight-1)));
blob - 632e3e5e5201c96941b3ecfdbe8c7d6416368c90
blob + 8fb1ceb712125fbbe755d47b06345992c90b1605
--- src/cmd/fossil/walk.c
+++ src/cmd/fossil/walk.c
w->n++;
return 1;
}
-
blob - 7c7d17875fd3d9c1ec35f7840053ce1f463a0059
blob + e97398a27fa0508ec14dfdefb482613630c5c4ce
--- src/cmd/getflags.c
+++ src/cmd/getflags.c
{
char *p;
Rune rr;
-
+
for(p=flags; p!=(char*)1; p=strchr(p, ',')+1){
chartorune(&rr, p);
if(rr == r)
return p;
}
- return nil;
+ return nil;
}
int
char *flags, *p, buf[512];
int i, n;
Fmt fmt;
-
- doquote = needsrcquote;
+
+ doquote = needsrcquote;
quotefmtinstall();
argv0 = argv[0]; /* for sysfatal */
-
+
flags = getenv("flagfmt");
if(flags == nil){
fprint(2, "$flagfmt not set\n");
fmtprint(&fmt, "%s%q", i ? " " : "", EARGF(usage()));
fmtprint(&fmt, ")\n");
}ARGEND
-
+
fmtprint(&fmt, "*=(");
for(i=0; i<argc; i++)
fmtprint(&fmt, "%s%q", i ? " " : "", argv[i]);
blob - 7a68a69277f0bdf1473ea2912fdeac3ae663fe69
blob + a3c215bd6945a500a16d64878d718ee4f2a78d34
--- src/cmd/grap/misc.c
+++ src/cmd/grap/misc.c
Point makepoint(Obj *s, double x, double y) /* make a Point */
{
Point p;
-
+
dprintf("makepoint: %s, %g,%g\n", s->name, x, y);
p.obj = s;
p.x = x;
blob - a7497e44d3784224fa5e5c2ec64bb8814ffbf414
blob + 0d4d4ab763a1d453e55271cc09c7f9ad5d2a49c3
--- src/cmd/grap/print.c
+++ src/cmd/grap/print.c
for (p = objlist; p; p = p->next) {
dprintf("print: name = <%s>, type = %d\n", p->name, p->type);
if (p->type == NAME) {
- Point pt, pt1;
+ Point pt, pt1;
pt = p->pt;
pt1 = p->pt1;
fprintf(tfd, "\t# %s %g .. %g, %g .. %g\n",
p->pt1.y = pow(10.0, pt1.y);
}
dfp = setauto();
- }
+ }
dx = pt1.x - pt.x;
dy = pt1.y - pt.y;
xfac = dx > 0 ? frame_wid/dx : frame_wid/2;
FILE *fp;
snprintf(buf, sizeof buf, "define pid /%d/\n", getpid());
- pbstr(buf);
+ pbstr(buf);
if (lib != 0) {
if ((fp = fopen(lib_defines, "r")) != NULL) {
snprintf(buf1, sizeof buf, "copy \"%s\"\n", lib_defines);
blob - 7da0b81b359e869f3e8920876d820372c9cdbd2d
blob + 1dba7dfcca46b2ca8eb4854118e020a9a9e79526
--- src/cmd/graph/graph.c
+++ src/cmd/graph/graph.c
float xquant; /*quantum*/
float xoff; /*screen offset fraction*/
float xsize; /*screen fraction*/
- int xbot,xtop; /*screen coords of border*/
+ int xbot,xtop; /*screen coords of border*/
float xmult; /*scaling constant*/
} xd,yd;
struct val {
initpalette(void)
{
int i;
-
+
for(i=0; i<nelem(colors); i++){
palette[(uchar)colors[i][0]].name = colors[i];
palette[(uchar)colors[i][0]].next = colors[i][0];
if(ub > 0) {
ub = 2*ub;
lb = 0;
- }
+ }
else
if(lb < 0) {
lb = 2*lb;
ub = 0;
- }
+ }
else {
ub = 1;
lb = -1;
if(mode==0)
point(ix,iy);
return(1);
- }
+ }
else {
move(ix,iy);
text(k>=0?labels+k:plotsymb);
blob - 777bd1e8b04d165161aea8558b5c64b1490ef17c
blob + ac86b86d41e26cd793b55af00e5cbf35b60d3f10
--- src/cmd/grep/grep.h
+++ src/cmd/grep/grep.h
{
Rune lo;
Rune hi;
- } x;
+ } x;
Rune val; /* char */
} u;
Re* next;
blob - bb348bc8837b31d155d549d0b80180efda6e8bf0
blob + d9ef2e2246aee8535dce0f29f82e2b9d22d84f7f
--- src/cmd/gzip/gunzip.c
+++ src/cmd/gzip/gunzip.c
vfprint(2, fmt, arg);
va_end(arg);
fprint(2, "\n");
-
+
if(delfile != nil){
fprint(2, "gunzip: removing output file %s\n", delfile);
remove(delfile);
blob - 5480ba8454136bf90b228b234357d509525831e0
blob + d25fa36992ca7143b6ac5e10add306b0f99721fe
--- src/cmd/gzip/zip.c
+++ src/cmd/gzip/zip.c
zh->madevers = (2 * 10) + 0;
zh->extos = ZDos;
zh->extvers = (2 * 10) + 0;
-
+
t = localtime(dir->mtime);
zh->modtime = (t->hour<<11) | (t->min<<5) | (t->sec>>1);
zh->moddate = ((t->year-80)<<9) | ((t->mon+1)<<5) | t->mday;
blob - c30bb0b34687b98fe102e9fdaaee30ae60f375b7
blob + f99b9647ca81bd9a6caafaa81d1ada42bc1f489b
--- src/cmd/hget.c
+++ src/cmd/hget.c
else
p = seprint(p, e, "%s", t);
u.postbody = postbody;
-
+
break;
default:
usage();
if(argc != 1)
usage();
-
+
out.fd = 1;
out.written = 0;
out.offset = 0;
if(p = strchr(u->host, ':')) {
*p++ = 0;
u->port = p;
- } else
+ } else
u->port = method[u->method].name;
if(*(u->host) == 0){
cfd = -1;
}
}
-
+
dfprint(fd, "\r\n", u->host);
auth = 0;
case 503: /* Service unavailable */
sysfatal("Service unavailable");
-
+
default:
sysfatal("Unknown response code %d", code);
}
hhetag(char *p, URL *u, Range *r)
{
USED(r);
-
+
if(u->etag != nil){
if(strcmp(u->etag, p) != 0)
sysfatal("file changed underfoot");
int i;
USED(r);
-
+
i = getfields(p, fields, 6, 1, " \t");
if(i < 5)
return;
hhclen(char *p, URL *u, Range *r)
{
USED(u);
-
+
r->end = atoi(p);
}
hhuri(char *p, URL *u, Range *r)
{
USED(r);
-
+
if(*p != '<')
return;
u->redirect = strdup(p+1);
hhlocation(char *p, URL *u, Range *r)
{
USED(r);
-
+
u->redirect = strdup(p);
}
char *f[4];
UserPasswd *up;
char *s, cred[64];
-
+
USED(r);
if (cistrncmp(p, "basic ", 6) != 0)
close(ctl);
return Eof;
}
-
+
/* first try passive mode, then active */
data = passive(ctl, u);
if(data < 0){
}
close(afd);
close(lcfd);
-
+
return dfd;
}
md5dup(DigestState *state)
{
DigestState *s2;
-
+
s2 = malloc(sizeof(DigestState));
if(s2 == nil)
sysfatal("malloc: %r");
}
return n + d;
}
-
blob - 46fd3f8a11d2da2340e3d4c70d144b18d26a63f2
blob + f6b81ed8bd017056a68725b87b7a80b7e3c7d75d
--- src/cmd/hist.c
+++ src/cmd/hist.c
main(int argc, char *argv[])
{
int i;
-
+
sys = sysname();
if(strncmp(sys, "amsterdam", 9) == 0) /* BUG */
sys = "am";
blob - e2d4c5ea381824c4e18b2f5a3976fb6c3ecee8eb
blob + af60c194c0ce81d66f064439f6a6eca940710e9f
--- src/cmd/hoc/code.c
+++ src/cmd/hoc/code.c
}
void
-ifcode(void)
+ifcode(void)
{
Datum d;
Inst *savepc = pc; /* then part */
execute(savepc+3); /* condition */
d = pop();
if (d.val)
- execute(*((Inst **)(savepc)));
+ execute(*((Inst **)(savepc)));
else if (*((Inst **)(savepc+1))) /* else part? */
execute(*((Inst **)(savepc+1)));
if (!returning)
}
void
-bltin(void)
+bltin(void)
{
Datum d;
}
void
-prstr(void) /* print string value */
+prstr(void) /* print string value */
{
print("%s", (char *) *pc++);
}
blob - 0a777b0d503900f90f6e28269503aaf556c3a42f
blob + d0e01ab18b9a9778117384e8a36dd53ab2fcff64
--- src/cmd/hoc/symbol.c
+++ src/cmd/hoc/symbol.c
for (sp = symlist; sp != (Symbol *) 0; sp = sp->next)
if (strcmp(sp->name, s) == 0)
return sp;
- return 0; /* 0 ==> not found */
+ return 0; /* 0 ==> not found */
}
Symbol*
blob - 173fdc9611421aa70cdd8b74ee650148d446f9fb
blob + a4209178979dea8d272e278623179f6887387023
--- src/cmd/htmlroff/a.h
+++ src/cmd/htmlroff/a.h
UPI = 720, /* units per inch */
UPX = 10, /* units per pixel */
-
+
/* special input modes */
CopyMode = 1<<1,
ExpandMode = 1<<2,
ArgMode = 1<<3,
HtmlMode = 1<<4,
-
+
MaxLine = 1024
};
blob - 151c9339f3da835aa05d8d2ad0d071013518a3f2
blob + 9e213e139462744000fe40d0254f7d68ba7e216e
--- src/cmd/htmlroff/char.c
+++ src/cmd/htmlroff/char.c
static Rune **tcscache[256];
int p[2];
char *q;
-
+
if(r == '\n')
return L("\n");
char *file, *f[10], *p, s[3];
int i, nf;
Biobuf *b;
-
+
if(rs[0] >= Runeself || rs[1] >= Runeself)
return Runeerror;
s[0] = rs[0];
}
}
Bterm(b);
-
+
if(ntrtab >= nelem(trtab))
fprint(2, "%s: trtab too small\n", argv0);
}
-
+
for(i=0; i<ntrtab; i++)
if(strcmp(s, trtab[i].t) == 0)
return trtab[i].r;
return Runeerror;
}
-
blob - 810959957eb2cf384056cba97d03f7af45eafff6
blob + 98b123f84838fe95d00515de5b665f101e805859
--- src/cmd/htmlroff/html.c
+++ src/cmd/htmlroff/html.c
{
Rune *t;
Rune *p0, *p;
-
+
t = runemalloc(sizeof(Rune));
if(s == nil)
return t;
runemove(t+2, p0, p-p0);
t[2+(p-p0)] = Ugt;
}
-
+
if(*p == Ugt && p>s && *(p-1) == '/'){
close:
for(p0=t+1; *p0 && *p0 != Ult; p0++)
runemove(t, p0, runestrlen(p0)+1);
}
}
- return t;
+ return t;
}
void
closehtml(void)
{
Tag *t, *next;
-
+
br();
hideihtml();
for(t=tagstack; t; t=next){
r_html(Rune *name)
{
Rune *id, *line, *p;
-
+
id = copyarg();
line = readline(HtmlMode);
for(p=line; *p; p++){
addesc('`', e_btick, CopyMode);
addesc('-', e_minus, CopyMode);
addesc('@', e_at, CopyMode);
-
+
ds(L("font"), L(defaultfont));
}
-
blob - 99e0d56e9d806cc79794bfee92724380b94c0b3a
blob + a4c4bc3a391ddc7df442f49a50d26f5ea42445d9
--- src/cmd/htmlroff/input.c
+++ src/cmd/htmlroff/input.c
Istack *is;
Biobuf *b;
char *t;
-
+
t = esmprint("%S", s);
if((b = Bopen(t, OREAD)) == nil){
free(t);
int
_inputstdin(void (*push)(Istack*))
-{
+{
Biobuf *b;
Istack *is;
_inputstring(Rune *s, void (*push)(Istack*))
{
Istack *is;
-
+
is = emalloc(sizeof *is);
is->s = erunestrdup(s);
is->p = is->s;
{
Rune r;
int c;
-
+
top:
if(istack == nil)
return -1;
sysfatal("getrune - can't happen");
}
if(r == '\n')
- istack->lineno++;
+ istack->lineno++;
return r;
}
linefmt(Fmt *f)
{
Istack *is;
-
+
for(is=istack; is && !is->b; is=is->next)
;
if(is)
setlinenumber(Rune *s, int n)
{
Istack *is;
-
+
for(is=istack; is && !is->name; is=is->next)
;
if(is){
blob - b6af1e7b405495ec02c6b434d5aa37df656794c9
blob + bd77a225abf19791619f516192fcda84e5357342
--- src/cmd/htmlroff/main.c
+++ src/cmd/htmlroff/main.c
char *p;
Rune *r;
Rune buf[2];
-
+
Binit(&bout, 1, OWRITE);
fmtinstall('L', linefmt);
quotefmtinstall();
-
+
tmacdir = unsharp("#9/tmac");
dostdin = 0;
ARGBEGIN{
}
if(argc == 0 || dostdin)
queuestdin();
-
+
run();
Bprint(&bout, "\n");
Bterm(&bout);
exits(nil);
}
-
blob - bdc51a3e18445698250613de211cc1e9022b92b7
blob + 34b794be7227bb43d8c72a245901d92dd43b83bd
--- src/cmd/htmlroff/roff.c
+++ src/cmd/htmlroff/roff.c
addraw(Rune *name, void (*f)(Rune*))
{
Raw *r;
-
+
if(nraw >= nelem(raw)){
fprint(2, "too many raw requets\n");
return;
delraw(Rune *name)
{
int i;
-
+
for(i=0; i<nraw; i++){
if(runestrcmp(raw[i].name, name) == 0){
if(i != --nraw){
renraw(Rune *from, Rune *to)
{
int i;
-
+
delraw(to);
for(i=0; i<nraw; i++)
if(runestrcmp(raw[i].name, from) == 0){
renreq(Rune *from, Rune *to)
{
int i;
-
+
delreq(to);
for(i=0; i<nreq; i++)
if(runestrcmp(req[i].name, from) == 0){
addesc(Rune r, int (*f)(void), int mode)
{
Esc *e;
-
+
if(nesc >= nelem(esc)){
fprint(2, "too many escapes\n");
return;
static Rune buf[MaxLine];
int c;
Rune *r;
-
+
if(_readx(buf, sizeof buf, ArgMode, 0) < 0)
return nil;
r = runestrstr(buf, L("\\\""));
;
ungetrune('\n');
}
- r = erunestrdup(buf);
+ r = erunestrdup(buf);
return r;
}
*w++ = *p;
}
*w = 0;
- }
+ }
}else{
/* unquoted argument - need to watch out for \" comment */
for(; *p; p++){
raw[i].f(raw[i].name);
free(a);
return;
- }
+ }
}
/*
runinput(void)
{
int c;
-
+
bol = 1;
for(;;){
c = getnext();
t20init();
htmlinit();
hideihtml();
-
+
addreq(L("margin"), r_margin, 1);
nr(L(".margin"), 1);
nr(L(".paragraph"), 1);
inroman(Rune r)
{
int f;
-
+
f = getnr(L(".f"));
nr(L(".f"), 1);
runmacro1(L("font"));
outhtml(Rune *s)
{
Rune r;
-
+
for(; *s; s++){
switch(r = *s){
case '<':
blob - 8236694de7c081d02882eb9b403244632fcda360
blob + c68ada77bef70c0912cce1cbd104dca5d6580a8a
--- src/cmd/htmlroff/t1.c
+++ src/cmd/htmlroff/t1.c
#include "a.h"
-
+
/*
* Section 1 - General Explanation.
*/
scale2units(char c)
{
int x;
-
+
switch(c){
case 'i': /* inch */
return UPI;
runestrtol(Rune *a, Rune **p)
{
long n;
-
+
n = 0;
while('0' <= *a && *a <= '9'){
n = n*10 + *a-'0';
*pline = p;
return x;
}
-
+
while(*p){
switch(*p++) {
case '+':
t1init(void)
{
Tm tm;
-
+
tm = *localtime(time(0));
nr(L("dw"), tm.wday+1);
nr(L("dy"), tm.mday);
nr(L("mo"), tm.mon);
nr(L("yr"), tm.year%100);
}
-
blob - 4aa745324101a24e39811b8b3be69b94953f5453
blob + 64d63f41472828f22d09600b3fb23e19cda3f6ae
--- src/cmd/htmlroff/t10.c
+++ src/cmd/htmlroff/t10.c
e_bang(void)
{
Rune *line;
-
+
line = readline(CopyMode);
out(line);
outrune('\n');
e_X(void)
{
int c, c1;
-
+
c1 = getrune();
if(c1 < 0 || c1 == '\n') {
c = c1;
r_comment(Rune *name)
{
int c;
-
+
USED(name);
while((c = getrune()) >= 0 && c != '\n')
;
addreq(L("tr"), r_warn, -1);
addreq(L("ul"), r_nop, -1);
addraw(L("\\\""), r_comment);
-
+
addesc('!', e_bang, 0);
addesc('X', e_X, 0);
addesc('\"', e_quote, CopyMode|ArgMode);
addesc('\n', e_newline, CopyMode|ArgMode|HtmlMode);
addesc('e', e_e, 0);
}
-
blob - dd1dd75b78f5dc9e3e3e6a0984dbc13e84dc24c7
blob + 2e273ac4d65facd56276ec1ae925725e7d0ed9ed
--- src/cmd/htmlroff/t11.c
+++ src/cmd/htmlroff/t11.c
addesc('r', e_r, 0);
addesc('k', e_k, 0);
}
-
blob - 0fadab3ad296a6f1cbe2dcd29706576cdd6596b0
blob + b2922f6a61e7e4a24a7843c27c2f27cb9685961f
--- src/cmd/htmlroff/t13.c
+++ src/cmd/htmlroff/t13.c
addreq(L("hy"), r_nop, -1);
addreq(L("hc"), r_nop, -1);
addreq(L("hw"), r_nop, -1);
-
+
addesc('%', e_nop, 0);
}
-
blob - 1dab3516747297a15609938fe81351338c5b05f4
blob + 4242dd7063a30f34ae6a4eea9f8182e810e37999
--- src/cmd/htmlroff/t14.c
+++ src/cmd/htmlroff/t14.c
r_lt(int argc, Rune **argv)
{
Rune *p;
-
+
if(argc < 2)
nr(L(".lt"), evalscale(L("6.5i"), 'm'));
else{
addreq(L("pc"), r_nop, -1); /* page number char */
addreq(L("lt"), r_lt, -1);
}
-
blob - fbfd5128fc2cb642890ea0cb1f425f82a8a376a2
blob + 221f642e61167d248ee306062f5a9a9c7c058efb
--- src/cmd/htmlroff/t15.c
+++ src/cmd/htmlroff/t15.c
addreq(L("nm"), r_warn, -1);
addreq(L("nn"), r_warn, -1);
}
-
blob - 3a9c427e8a4e1d52ec8dac1815f8c832ad6c8020
blob + 9389a59afccc44a79f0dcd51d19ee74821d37337
--- src/cmd/htmlroff/t16.c
+++ src/cmd/htmlroff/t16.c
startbody(void)
{
int c;
-
+
while((c = getrune()) == ' ' || c == '\t')
;
ungetrune(c);
int c, cc, neg, nc;
Rune line[MaxLine], *p, *e, *q;
Rune *a;
-
+
while((c = getnext()) == ' ' || c == '\t')
;
neg = 0;
free(a);
return c;
}
-
+
switch(c){
case ' ':
case '\n':
return (q-line == p-(q+1)
&& memcmp(line, q+1, (q-line)*sizeof(Rune))==0) ^ neg;
}
-
+
void
r_if(Rune *name)
{
int n;
-
+
n = ifeval();
if(runestrcmp(name, L("ie")) == 0){
if(niftrue >= nelem(iftrue))
r_el(Rune *name)
{
USED(name);
-
+
if(niftrue <= 0){
warn("%Cel underflow", dot);
return;
addraw(L("if"), r_if);
addraw(L("ie"), r_if);
addraw(L("el"), r_el);
-
+
addesc('{', e_nop, HtmlMode|ArgMode);
addesc('}', e_nop, HtmlMode|ArgMode);
}
blob - bbd095d54250a8ea9b63c1c4f5c88b00ba7929b9
blob + 74096c5ce7b8477472eb3bcd2a006277fd2fad28
--- src/cmd/htmlroff/t17.c
+++ src/cmd/htmlroff/t17.c
{
int i;
Env *e;
-
+
if(argc == 1){
if(nevstack <= 0){
if(verbose) warn(".ev stack underflow");
t17init(void)
{
int i;
-
+
for(i=0; i<nelem(env); i++)
env[i] = defenv;
blob - f5c74a1fe4b6a9a8bb113116fd82e7cd2ef35c4e
blob + 51f08219c40aca87d46433bac18b60ab809f390b
--- src/cmd/htmlroff/t18.c
+++ src/cmd/htmlroff/t18.c
Fmt fmt;
static int didstdin;
static Biobuf bstdin;
-
+
/*
* print prompt, then read until double newline,
* then run the text just read as though it were
else
fprint(2, "%c", 7/*BEL*/);
}
-
+
if(!didstdin){
Binit(&bstdin, 0, OREAD);
didstdin = 1;
{
USED(argc);
USED(argv);
-
+
while(popinput())
;
}
blob - a4cc18f443d9c8516e72e8b0d3d5b9172966eaaa
blob + bd633834fc0d012e07866e98be3751ecc31a96ae
--- src/cmd/htmlroff/t19.c
+++ src/cmd/htmlroff/t19.c
r_nx(int argc, Rune **argv)
{
int n;
-
+
if(argc == 1){
while(popinput())
;
Rune *cmd, *stop, *line;
int n, pid, p[2], len;
Waitmsg *w;
-
+
USED(name);
if(pipe(p) < 0){
warn("pipe: %r");
fprint(p[1], ".ll 8i\n");
fprint(p[1], ".pl 30i\n");
while((line = readline(~0)) != nil){
- if(runestrncmp(line, stop, len) == 0
+ if(runestrncmp(line, stop, len) == 0
&& (line[len]==' ' || line[len]==0 || line[len]=='\t'
|| (line[len]=='\\' && line[len+1]=='}')))
break;
free(cmd);
free(w);
}
-}
+}
void
t19init(void)
addraw(L("inputpipe"), r_inputpipe);
addraw(L("pi"), r_pi);
addreq(L("cf"), r_cf, 1);
-
+
nr(L("$$"), getpid());
}
-
blob - daac3ea120b3c9fe3dc6e81e950d5d7dc4784a8b
blob + 1831660ed46c422d16dff72528d221a221af2184
--- src/cmd/htmlroff/t2.c
+++ src/cmd/htmlroff/t2.c
/*
* Section 2 - Font and character size control.
*/
-
+
/* 2.1 - Character set */
/* XXX
*
* \C'name' - character named name
* \N'n' - character number
* \(xx - two-letter character
- * \-
+ * \-
* \`
* \'
* `
static Rune buf[MaxLine];
int c;
Rune *p, *e;
-
+
p = buf;
e = p + nelem(buf) - 1;
-
+
if(getrune() != '\'')
return nil;
while(p < e){
{
int c, cc;
Rune buf[2], r;
-
+
if((c = getrune()) < 0 || c == '\n')
goto error;
if((cc = getrune()) < 0 || cc == '\n')
if(r == Runeerror)
warn("unknown char %C(%C%C", backslash, c, cc);
return r;
-
+
error:
warn("malformed %C(xx", backslash);
return 0;
{
int i;
int fn;
-
+
if(f && runestrcmp(f, L("P")) == 0)
f = nil;
if(f == nil)
}
runestrecpy(fonttab[i], fonttab[i]+sizeof fonttab[i], f);
}
-
+
int
e_f(void)
{
r_ps(int argc, Rune **argv)
{
Rune *p;
-
+
if(argc == 1 || argv[1][0] == 0)
ps(0);
else{
e_s(void)
{
int c, cc, ccc, n, twodigit;
-
+
c = getnext();
if(c < 0)
return 0;
fp(3, L("B"));
fp(4, L("BI"));
fp(5, L("CW"));
-
+
nr(L(".s"), 10);
nr(L(".s0"), 10);
addesc('N', e_N, 0);
/* \- \' \` are handled in html.c */
}
-
blob - 62ea914fc04a0994d371db81aa6d80823615932e
blob + 00e3145567b3fff8dac78789b76de4637d26a282
--- src/cmd/htmlroff/t20.c
+++ src/cmd/htmlroff/t20.c
r_pm(int argc, Rune **argv)
{
int i;
-
+
if(argc == 1){
printds(0);
return;
r_tm(Rune *name)
{
Rune *line;
-
+
USED(name);
-
+
line = readline(CopyMode);
fprint(2, "%S\n", line);
free(line);
r_ab(Rune *name)
{
USED(name);
-
+
r_tm(L("ab"));
exits(".ab");
}
addreq(L("pm"), r_pm, -1);
addreq(L("fl"), r_fl, 0);
}
-
blob - e54573c13b51b8ec618d580dc2f12b45623d458a
blob + 354ffc2a71357d78025c4bbd17365326298b6efe
--- src/cmd/htmlroff/t3.c
+++ src/cmd/htmlroff/t3.c
nr(L(".o"), eval(L("1i")));
nr(L(".o0"), eval(L("1i")));
nr(L(".p"), eval(L("11i")));
-
+
addreq(L("pl"), r_warn, -1);
addreq(L("bp"), r_nop, -1);
addreq(L("pn"), r_warn, -1);
addreq(L("mk"), r_nop, -1);
addreq(L("rt"), r_warn, -1);
}
-
blob - 157169de6a0b8eaf7bb651f33a168152b9aa7036
blob + 8a30132109110382c32a8021d34fa8d8e70eeb27
--- src/cmd/htmlroff/t4.c
+++ src/cmd/htmlroff/t4.c
#include "a.h"
/*
- * 4 - Text filling, centering, and adjusting.
+ * 4 - Text filling, centering, and adjusting.
* "\ " - unbreakable space
* .n register - length of last line
* nl register - text baseline position on this page
r_ad(int argc, Rune **argv)
{
int c, n;
-
+
nr(L(".j"), getnr(L(".j"))|1);
if(argc < 2)
return;
addreq(L("ad"), r_ad, -1);
addreq(L("na"), r_na, 0);
addreq(L("ce"), r_ce, -1);
-
+
addesc(' ', e_space, 0);
addesc('p', e_warn, 0);
addesc('&', e_amp, 0);
addesc('c', e_c, 0);
}
-
blob - cb9519514fb2449ec11a6e740cf088278ce6db36
blob + 226da09b35d8edfdfb79a62b002a45871218e083
--- src/cmd/htmlroff/t5.c
+++ src/cmd/htmlroff/t5.c
{
Rune buf[100];
double fv;
-
+
br();
fv = v * 1.0/UPI;
if(fv > 5)
void
t5init(void)
-{
+{
addreq(L("vs"), r_vs, -1);
addreq(L("ls"), r_ls, -1);
addreq(L("sp"), r_sp, -1);
nr(L(".ls"), 1);
nr(L(".ls0"), 1);
}
-
blob - 130f535feef3a2f61de218f2e90d04c304985631
blob + 3090cd262d3c60af6decb4e83f8bc9fc3d289926
--- src/cmd/htmlroff/t6.c
+++ src/cmd/htmlroff/t6.c
addreq(L("ll"), r_ll, -1);
addreq(L("in"), r_in, -1);
addreq(L("ti"), r_ti, 1);
-
+
nr(L(".l"), eval(L("6.5i")));
}
-
blob - 9936a44c88f12bff85bf84ee65fa5985be3818ad
blob + cee439277bfacee34f9f3c64e699deecd4d1382c
--- src/cmd/htmlroff/t7.c
+++ src/cmd/htmlroff/t7.c
Rune *p;
int i;
Mac *m;
-
+
if(verbose && isupperrune(argv[0][0])) fprint(2, "run: %S\n", argv[0]);
p = getds(argv[0]);
if(p == nil){
{
int i;
Mac *m;
-
+
if(--nmstack < 0){
fprint(2, "%L: macro stack underflow\n");
return;
{
Rune *argv[2];
int obol;
-
+
if(verbose) fprint(2, "outcb %p\n", outcb);
obol = bol;
argv[0] = name;
/*
* diversions
*
- * processed output diverted
+ * processed output diverted
* dn dl registers vertical and horizontal size of last diversion
* .z - current diversion name
*/
r_ch(int argc, Rune **argv)
{
int i;
-
+
if(argc == 2){
if(trap0 && runestrcmp(argv[1], trap0) == 0){
free(trap0);
fmtrunestrcpy(&fmt, p);
len = runestrlen(end);
while((p = readline(CopyMode)) != nil){
- if(runestrncmp(p, end, len) == 0
+ if(runestrncmp(p, end, len) == 0
&& (p[len]==' ' || p[len]==0 || p[len]=='\t'
|| (p[len]=='\\' && p[len+1]=='}'))){
free(p);
r_ds(Rune *cmd)
{
Rune *name, *line, *p;
-
+
name = copyarg();
line = readline(CopyMode);
if(name == nil || line == nil){
{
int n;
Rune *p;
-
+
if(ndi == 0 || difmtinit == 0)
return;
fmtrune(&difmt, Uunformatted);
r_em(int argc, Rune **argv)
{
Rune buf[20];
-
+
USED(argc);
runesnprint(buf, nelem(buf), ".%S\n", argv[1]);
as(L("eof"), buf);
e_star(void)
{
Rune *p;
-
+
p = getds(getname());
if(p)
pushinputstring(p);
void
t7init(void)
-{
+{
addreq(L("de"), r_de, -1);
addreq(L("am"), r_de, -1);
addreq(L("ig"), r_de, -1);
addreq(L("wh"), r_wh, -1);
addreq(L("ch"), r_ch, -1);
addreq(L("dt"), r_dt, -1);
-
+
addesc('$', e_dollar, CopyMode|ArgMode|HtmlMode);
addesc('*', e_star, CopyMode|ArgMode|HtmlMode);
addesc('t', e_t, CopyMode|ArgMode);
addesc('a', e_a, CopyMode|ArgMode);
addesc('\\', e_backslash, ArgMode|CopyMode);
addesc('.', e_dot, CopyMode|ArgMode);
-
+
ds(L("eof"), L(".sp 0.5i\n"));
ds(L(".."), L(""));
}
-
blob - ead5a020085382490c43bd76912c418fb7e25cc9
blob + 511737ced29c8a135e285f7d8fea849190b6dc25
--- src/cmd/htmlroff/t8.c
+++ src/cmd/htmlroff/t8.c
getdsnr(Rune *name, Reg *list)
{
Reg *s;
-
+
for(s=list; s; s=s->next)
if(runestrcmp(name, s->name) == 0)
return s->val;
as(Rune *name, Rune *val)
{
Rune *p, *q;
-
+
p = getds(name);
if(p == nil)
p = L("");
{
int n, total;
Reg *s;
-
+
total = 0;
for(s=dslist; s; s=s->next){
if(s->val)
nr(Rune *name, int val)
{
Rune buf[20];
-
+
runesnprint(buf, nelem(buf), "%d", val);
_nr(name, buf);
}
getaf(Rune *name)
{
Reg *s;
-
+
for(s=nrlist; s; s=s->next)
if(runestrcmp(s->name, name) == 0)
return s->fmt;
printnr(void)
{
Reg *r;
-
+
for(r=nrlist; r; r=r->next)
fprint(2, "%S %S %d\n", r->name, r->val, r->inc);
}
r_af(int argc, Rune **argv)
{
USED(argc);
-
+
af(argv[1], argv[2]);
}
r_rr(int argc, Rune **argv)
{
int i;
-
+
for(i=1; i<argc; i++)
_nr(argv[i], nil);
}
alpha(Rune *buf, int n, int a)
{
int i, v;
-
+
i = 1;
for(v=n; v>0; v/=26)
i++;
Rune *p;
char *q;
struct romanv *r;
-
+
if(upper)
upper = 'A' - 'a';
if(n >= 5000 || n <= 0){
{
int i, c, cc;
static Rune buf[100];
-
+
/* XXX add [name] syntax as in groff */
c = getnext();
if(c < 0)
int inc, v, l;
Rune *name, *fmt, buf[100];
Reg *s;
-
+
inc = getnext();
if(inc < 0)
return -1;
addreq(L("af"), r_af, 2);
addreq(L("rr"), r_rr, -1);
addreq(L("pnr"), r_pnr, 0);
-
+
addesc('n', e_n, CopyMode|ArgMode|HtmlMode);
addesc('g', e_g, 0);
}
-
blob - c9e045642501c87185bd0340dd1c7c9f803428aa
blob + 6f4c4d6c5d7fa49c470b4086cab4b3c947cf040b
--- src/cmd/htmlroff/t9.c
+++ src/cmd/htmlroff/t9.c
*/
XXX
-
blob - 99e99543f16d229d322dfe99f2f7d194769ec68a
blob + 15dd4c74dfbea7aaa8b2ccdab70fd929ac091056
--- src/cmd/htmlroff/util.c
+++ src/cmd/htmlroff/util.c
emalloc(uint n)
{
void *v;
-
+
v = mallocz(n, 1);
if(v == nil)
sysfatal("out of memory");
estrdup(char *s)
{
char *t;
-
+
t = strdup(s);
if(t == nil)
sysfatal("out of memory");
erealloc(void *ov, uint n)
{
void *v;
-
+
v = realloc(ov, n);
if(v == nil)
sysfatal("out of memory");
{
Rune *s;
va_list arg;
-
+
va_start(arg, fmt);
s = runevsmprint(fmt, arg);
va_end(arg);
{
char *s;
va_list arg;
-
+
va_start(arg, fmt);
s = vsmprint(fmt, arg);
va_end(arg);
warn(char *fmt, ...)
{
va_list arg;
-
+
fprint(2, "htmlroff: %L: ");
va_start(arg, fmt);
vfprint(2, fmt, arg);
hash[h] = l;
return l->r;
}
-
blob - 6b7152bab60d1d95c4c12b559f6dd4facc70d051
blob + 0be2f5b6f9e28a3fd7e662fa56cd260b0e9ac28c
--- src/cmd/import.c
+++ src/cmd/import.c
fmtinstall('F', fcallfmt);
}
-
+
if(rem){
netfd[0] = 0;
- netfd[1] = 1;
+ netfd[1] = 1;
write(1, "OK", 2);
}else{
if(argc != 1)
fn = localside;
if(rem+export == 1)
fn = remoteside;
-
+
if(rem || !dofork)
fn(nil);
else
blob - 0ca5084fecf65f2aded876fa94f6e20779f31dd7 (mode 755)
blob + d07a2e8ac8655209190a90ff55b12c5bf09e3631 (mode 644)
--- src/cmd/ip/dhcp.h
+++ src/cmd/ip/dhcp.h
OBtcpka= 38,
OBtcpkag= 39,
OBnisdomain= 40,
- OBniserver= 41,
+ OBniserver= 41,
OBntpserver= 42,
OBvendorinfo= 43, /* 0x2b */
OBnetbiosns= 44,
Sbound,
Srenewing,
Srebinding
-};
+};
typedef struct Bootp Bootp;
struct Bootp
blob - aa64deebd6a1cfd1748e5a4c4666e331686e6670 (mode 755)
blob + c69f9f383dd4b88728c8f521a8d5eb9706255493 (mode 644)
--- src/cmd/ip/dhcpd/dat.h
+++ src/cmd/ip/dhcpd/dat.h
extern Ipifc *ipifcs;
extern long now;
extern char *ndbfile;
-
blob - f4b48552e3b14f4fe0dcf3f73092b52c1651a8a6 (mode 755)
blob + cf245efedd5c6eddba50b36592679cef02c5574c (mode 644)
--- src/cmd/ip/dhcpd/db.c
+++ src/cmd/ip/dhcpd/db.c
}
setbinding(b, b->offeredto, now + b->offer);
b->lasttouched = now;
-
+
if(writebinding(fd, b) < 0){
close(fd);
return -1;
}
b->lease = 0;
b->expoffer = 0;
-
+
if(writebinding(fd, b) < 0){
close(fd);
return -1;
blob - e28bf3cb6ea283382ab5f2c10d2a516d4aa8eb21 (mode 755)
blob + c5fb06bf185f2afdc72153b92375bab689aa28b3 (mode 644)
--- src/cmd/ip/dhcpd/dhcpd.c
+++ src/cmd/ip/dhcpd/dhcpd.c
int mute;
int minlease = MinLease;
-ulong start;
+ulong start;
/* option magic */
char plan9opt[4] = { 'p', '9', ' ', ' ' };
sendnak(rp, "no offer for you");
return;
}
-
+
/* if not for me, retract offer */
if(!forme(rp->server)){
b->expoffer = 0;
p += n;
if(p > rp->e)
return;
-
+
switch(code){
case ODipaddr: /* requested ip address */
if(n == IPv4addrlen)
{
int pid;
char xip[100], xether[100];
-
+
switch(pid=fork()){
case -1:
break;
blob - 71719649f1aa66cdeb173db4a5e22ff9d2bad0cb (mode 755)
blob + a99b92182c5afff3a1560d3b40b15061cbd5c46b (mode 644)
--- src/cmd/ip/dhcpd/dhcpleases.c
+++ src/cmd/ip/dhcpd/dhcpleases.c
continue;
if(b.lease > now)
print("%I leased by %s until %s", b.ip, b.boundto, ctime(b.lease));
- }
+ }
}
blob - 53ffb58fb287e62ef490349736cf09976425e951 (mode 755)
blob + 97b2284f3d0d9cbdb6ffe4eb79ec3526d1285916 (mode 644)
--- src/cmd/ip/dhcpd/ndb.c
+++ src/cmd/ip/dhcpd/ndb.c
t = ndbipinfo(db, "ip", ip, attrs, p - attrs);
if(t == nil)
return -1;
-
+
for(nt = t; nt != nil; nt = nt->entry){
if(strcmp(nt->attr, "ip") == 0)
setipaddr(iip->ipaddr, nt->val);
blob - 666bcc410b56dc41418d9e55f0aeb445d1c2d5ad (mode 755)
blob + 666bcc410b56dc41418d9e55f0aeb445d1c2d5ad (mode 644)
blob - 4937e55b6471be280d33dbac2e8765108ff78601 (mode 755)
blob + ac3f44f8b08d0254d424655a0a03aa083e01d206 (mode 644)
--- src/cmd/ip/dhcpd/testlook.c
+++ src/cmd/ip/dhcpd/testlook.c
recursesubnet(db, classmask[CLASS(iip->ipaddr)], iip, fsname, gwname, auname);
/* lookup fs's and gw's ip addresses */
-
+
if(fsname[0])
lookupip(db, fsname, iip->fsip, iip);
if(gwname[0])
blob - c69624c5759a8b13da9e65a1835d21637f18aafa (mode 755)
blob + c69624c5759a8b13da9e65a1835d21637f18aafa (mode 644)
blob - b5ca90c5e9ba9ea9f2e37e337b0e04ee94a52c00 (mode 755)
blob + b5ca90c5e9ba9ea9f2e37e337b0e04ee94a52c00 (mode 644)
blob - d317c1bbbd2358ba6ee8b8b6df4a808e58403320 (mode 755)
blob + 7b7fa3181e717ed7630ec4445f1cc4fb854eab19 (mode 644)
--- src/cmd/ip/snoopy/arp.c
+++ src/cmd/ip/snoopy/arp.c
Opa
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"spa", Fv4ip, Ospa, "protocol source", } ,
{"tpa", Fv4ip, Otpa, "protocol target", } ,
blob - e7ead8637e99bbc2389eda7c3a115e7c39f001b9 (mode 755)
blob + 18350081bb1987d8c8916422dc6895ee127cf849 (mode 644)
--- src/cmd/ip/snoopy/bootp.c
+++ src/cmd/ip/snoopy/bootp.c
Ot
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"ca", Fv4ip, Oca, "client IP addr", } ,
{"sa", Fv4ip, Osa, "server IP addr", } ,
blob - ba3e446da5a9fdec1d0336f64256d50a9df8b022 (mode 755)
blob + 0ac054c7b2c8e631e23f0a747a7474157316554c (mode 644)
--- src/cmd/ip/snoopy/dat.h
+++ src/cmd/ip/snoopy/dat.h
char *e; /* buffer end */
int needroot; /* pr is root, need to see in expression */
- Proto *pr; /* current/next protocol */
+ Proto *pr; /* current/next protocol */
};
enum
blob - cd976ec0b899f6a113f722ab59e33442b609d5ee (mode 755)
blob + bab0cf8275e8d182935953b39c9ba6e98ec55424 (mode 644)
--- src/cmd/ip/snoopy/dhcp.c
+++ src/cmd/ip/snoopy/dhcp.c
OBtcpka= 38,
OBtcpkag= 39,
OBnisdomain= 40,
- OBniserver= 41,
+ OBniserver= 41,
OBntpserver= 42,
OBvendorinfo= 43, /* 0x2b */
OBnetbiosns= 44,
ps += n;
if(ps > m->pe)
break;
-
+
switch(code){
case ODipaddr: /* requested ip address */
p = pserver(p, e, "ipaddr", o, n);
nil,
defaultframer
};
-
blob - 144a494972b10c4261c3979ea040fce4120a5493
blob + c115df17b9e70559f98341b0372f429af71b686f
--- src/cmd/ip/snoopy/dns.c
+++ src/cmd/ip/snoopy/dns.c
/* query types (all RR types are also queries) */
Tixfr= 251, /* incremental zone transfer */
Taxfr= 252, /* zone transfer */
- Tmailb= 253, /* { Tmb, Tmg, Tmr } */
+ Tmailb= 253, /* { Tmb, Tmg, Tmr } */
Tall= 255, /* all records */
/* classes */
{
uchar *p;
int n;
-
+
p = *pp;
n = *p++;
if(p+n > ep)
if(class == Cin)
return "";
-
+
snprint(buf, sizeof buf, "class=%d", class);
return buf;
}
char *sym1, *sym2, *sep;
int type;
static int first = 1;
-
+
if(first){
first = 0;
quotefmtinstall();
NetS(p), p[3], p[4], rlen-4, p+4);
p += rlen;
break;
-
+
case Tsig:
if(rlen < 18)
goto error;
}
if(p != ep)
goto error;
- }
+ }
return 0;
error:
blob - ec2a3ce7cab4fdb33d0fd7ea299306e3c5db4673 (mode 755)
blob + 3d9451dacd857dc2bee55ff676a216f98da5e31a (mode 644)
--- src/cmd/ip/snoopy/dump.c
+++ src/cmd/ip/snoopy/dump.c
for(i = 0; i < n && p+1<e; i++){
c = ps[i];
*p++ = tohex[c>>4];
- *p++ = tohex[c&0xf];
+ *p++ = tohex[c&0xf];
}
}
blob - 9e16579ad7cccb341427b978b858bf581f8a8ae6 (mode 755)
blob + 2b33106e4cecf70c2c64cf71b73df2b8112901d6 (mode 644)
--- src/cmd/ip/snoopy/ether.c
+++ src/cmd/ip/snoopy/ether.c
Ot, /* type */
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fether, Os, "source address", } ,
{"d", Fether, Od, "destination address", } ,
blob - 6808293b74919434a787c15c651b52010a42c430 (mode 755)
blob + 2e744940815722b0f5149ae995d848063ea7eb98 (mode 644)
--- src/cmd/ip/snoopy/gre.c
+++ src/cmd/ip/snoopy/gre.c
uchar *p = a;
chksum = offset = key = seq = ack = 0;
-
+
flag = NetS(p);
prot = NetS(p+2);
p += 4; len -= 4;
n += sprintppp(p, buf+n, len);
else
n += sprintx(p, buf+n, len);
-
+
return n;
}
blob - e7bf37390c62f0e4f83fb75baed197a0640ecf79 (mode 755)
blob + e7bf37390c62f0e4f83fb75baed197a0640ecf79 (mode 644)
blob - 8e528dc96bcc0e793ba5a4b6e79f5f42f64d1e0a (mode 755)
blob + f798e42a32c35848962d5f518e284b5ca510a502 (mode 644)
--- src/cmd/ip/snoopy/icmp.c
+++ src/cmd/ip/snoopy/icmp.c
Op, /* next protocol */
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"t", Fnum, Ot, "type", } ,
{0}
blob - 9ba74939807545cb77da053aa035791692a2091c (mode 755)
blob + 9ede92a57f3f4a8cef4a7cc90e964c2a3fc47c87 (mode 644)
--- src/cmd/ip/snoopy/icmp6.c
+++ src/cmd/ip/snoopy/icmp6.c
Ot, /* type */
Op, /* next protocol */};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"t", Fnum, Ot, "type", } ,
{0}
};
enum
-{
+{
/* ICMPv6 types */
EchoReply = 0,
UnreachableV6 = 1,
[2] "unrecognized IPv6 option encountered",
[3] "icmp par prob: unknown code"
};
-enum
+enum
{
sll = 1,
tll = 2,
mtu = 5
};
-static char *icmp6opts[256] =
+static char *icmp6opts[256] =
{
[0] "unknown opt",
[1] "sll_addr",
case sll:
case tll:
- if ((pktsz < osz) || (osz != 8)) {
+ if ((pktsz < osz) || (osz != 8)) {
p = seprint(p, e, "\n option=%s bad size=%d", opt, osz);
m->pr = &dump;
return p;
break;
case pref:
- if ((pktsz < osz) || (osz != 32)) {
+ if ((pktsz < osz) || (osz != 32)) {
p = seprint(p, e, "\n option=%s: bad size=%d", opt, osz);
m->pr = &dump;
return p;
NetL(a+12)!=0);
pktsz -= osz;
- a += osz;
+ a += osz;
break;
case redir:
- if (pktsz < osz) {
+ if (pktsz < osz) {
p = seprint(p, e, "\n option=%s: bad size=%d", opt, osz);
m->pr = &dump;
return p;
p = seprint(p, e, "\n option=%s len %d", opt, osz);
a += osz;
m->ps = a;
- return p;
+ return p;
break;
case mtu:
- if ((pktsz < osz) || (osz != 8)) {
+ if ((pktsz < osz) || (osz != 8)) {
p = seprint(p, e, "\n option=%s: bad size=%d", opt, osz);
m->pr = &dump;
return p;
blob - a4ff60eb79d46f4de173884df5ed36c3c21b9251 (mode 755)
blob + 35c43a2419cbe814a2ac1b4f6abc6ecff5d8b62a (mode 644)
--- src/cmd/ip/snoopy/il.c
+++ src/cmd/ip/snoopy/il.c
Osd
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fnum, Os, "source port", } ,
{"d", Fnum, Od, "dest port", } ,
return 0;
}
-char *pktnames[] =
+char *pktnames[] =
{
- "Sync",
+ "Sync",
"Data",
"Dataquery",
"Ack",
pkttype(int t)
{
static char b[10];
-
+
if(t > 6){
sprint(b, "%d", t);
return b;
blob - 234ca85ff6cc83406378de8049e328f457fedfcd (mode 755)
blob + 045897781e49bb717ae6cb14851afd0d860ab6e1 (mode 644)
--- src/cmd/ip/snoopy/ip.c
+++ src/cmd/ip/snoopy/ip.c
Ot, /* type */
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fv4ip, Os, "source address", } ,
{"d", Fv4ip, Od, "destination address", } ,
blob - 7187cda771661ed9f9f34e4787ea4e12c9bdf441 (mode 755)
blob + ba9be993cd24ccd3904913d322c008f05227c602 (mode 644)
--- src/cmd/ip/snoopy/ip6.c
+++ src/cmd/ip/snoopy/ip6.c
Ot, /* type */
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fv6ip, Os, "source address", } ,
{"d", Fv6ip, Od, "destination address", } ,
int pktlen = IP6HDR + NetS(h->length);
uchar nexthdr = h->proto;
uchar *pkt = (uchar*) h;
-
+
pkt += len;
plen = len;
if (nexthdr == FRAG_HDR)
len = FRAG_HSZ;
- else
+ else
len = ( ((int) *(pkt+1)) + 1) * 8;
if (plen + len > pktlen)
int pktlen = IP6HDR + NetS(h->length);
uchar nexthdr = h->proto;
int plen;
-
+
pkt += len;
plen = len;
blob - bbc21986ff98e74cfc5ff55a813d5ea53199b9cb
blob + 09cf022dc677aee6637d1768b456d0ea3c40d951
--- src/cmd/ip/snoopy/llc.c
+++ src/cmd/ip/snoopy/llc.c
-/*
+/*
* LLC. Only enough to dispatch to SNAP and IP.
*/
UPoll = 0x10,
IsPoll = 0x100,
XidFi = 0x81,
-
+
SapNull = 0,
SapGlobal = 0xff,
Sap8021BI = 0x02,
// Linux gives llc -> snap not llc -> ip.
// If we don't tell snoopy about llc -> ip, then the default patterns
// like snoopy -h radiotap -f dns work better.
-// { "ip", SapIP },
+// { "ip", SapIP },
{ "snap", SapSnap },
{ 0 }
};
p_seprint(Msg *m)
{
Hdr h;
-
+
memset(&h, 0, sizeof h);
if(unpackhdr(m->ps, m->pe, &h) < 0)
return -1;
m->pr = &snap;
break;
}
- }
+ }
return 0;
}
blob - 9c2dad2e8ac9bb237d9bd0e786b82229e89eb371 (mode 755)
blob + 6902797e82706f543e2fea43276b7226bd48413c (mode 644)
--- src/cmd/ip/snoopy/main.c
+++ src/cmd/ip/snoopy/main.c
};
/*
- * pcap trace header
+ * pcap trace header
*/
void
pcaphdr(int fd)
{
if(tiflag){
struct pcap_file_header hdr;
-
+
if(readn(fd, &hdr, sizeof hdr) != sizeof hdr)
sysfatal("short header");
if(hdr.magic != TCPDUMP_MAGIC)
}
if(toflag){
struct pcap_file_header hdr;
-
+
hdr.magic = TCPDUMP_MAGIC;
hdr.version_major = PCAP_VERSION_MAJOR;
hdr.version_minor = PCAP_VERSION_MINOR;
-
+
hdr.thiszone = 0;
hdr.snaplen = 1500;
hdr.sigfigs = 0;
hdr.linktype = 1;
-
+
write(1, &hdr, sizeof(hdr));
}
}
case '=':
if(last == nil)
sysfatal("internal error: compilewalk: badly formed tree");
-
+
if(last->compile == nil)
sysfatal("unknown %s field: %s", f->pr->name, f->s);
(*last->compile)(f);
{
char buf[1024];
int n;
-
+
while((n = read(0, buf, sizeof buf)) > 0)
write(1, buf, n);
}
startmc(void)
{
int p[2];
-
+
if(fd1 == -1)
fd1 = dup(1, -1);
-
+
if(pipe(p) < 0)
return;
switch(fork()){
Mux *m;
Field *f;
char fmt[40];
-
+
if(name == nil){
print("protocols:\n");
startmc();
stopmc();
return;
}
-
+
pr = findproto(name);
if(pr == nil){
print("unknown protocol %s\n", name);
return;
}
-
+
if(pr->field){
print("%s's filter attributes:\n", pr->name);
len = 0;
blob - eb3eab3906e5ed3f335084167abefdc483ce486c (mode 755)
blob + eb3eab3906e5ed3f335084167abefdc483ce486c (mode 644)
blob - bb4cd893b4dde6b07be03ff7db1bae0ee080c58e (mode 755)
blob + d5871dd9b0ab0ac96f2fe245314a0664ffcdf2a3 (mode 644)
--- src/cmd/ip/snoopy/ospf.c
+++ src/cmd/ip/snoopy/ospf.c
uchar auth[8];
uchar data[1];
};
-#define OSPF_HDRSIZE 24
+#define OSPF_HDRSIZE 24
enum
{
case 0:
return "no authentication";
case 1:
- sprint(auth, "password(%8.8ux %8.8ux)", NetL(ospf->auth),
+ sprint(auth, "password(%8.8ux %8.8ux)", NetL(ospf->auth),
NetL(ospf->auth+4));
break;
case 2:
- sprint(auth, "crypto(plen %d id %d dlen %d)", NetS(ospf->auth),
+ sprint(auth, "crypto(plen %d id %d dlen %d)", NetS(ospf->auth),
ospf->auth[2], ospf->auth[3]);
break;
default:
- sprint(auth, "auth%d(%8.8ux %8.8ux)", NetS(ospf->autype), NetL(ospf->auth),
+ sprint(auth, "auth%d(%8.8ux %8.8ux)", NetS(ospf->autype), NetL(ospf->auth),
NetL(ospf->auth+4));
}
return auth;
uchar typ;
uchar numtos;
uchar metric[2];
-
+
};
struct OspfrtLSA {
x -= OSPF_HDRSIZE;
p = seprint(p, e, "ver=%d type=%d len=%d r=%V a=%V c=%4.4ux %s ",
- ospf->version, ospf->type, x,
+ ospf->version, ospf->type, x,
ospf->router, ospf->area, NetS(ospf->sum),
ospfauth(ospf));
blob - 92ed8aba2fdcabeaa201d0505ae78c7887e312f6
blob + 49fe0245ca0e9b308e2907539513b49b81729fdf
--- src/cmd/ip/snoopy/p80211.c
+++ src/cmd/ip/snoopy/p80211.c
-/*
+/*
* IEEE 802.11.
*/
NodataCfAck,
NodataCfPoll,
NodataCfAckPoll,
-
+
FlagTods = 0x1,
FlagFromds = 0x2,
FlagMoreflag = 0x4,
FlagMoreData = 0x20,
FlagWep = 0x40,
FlagOrder = 0x80,
-
+
ProtoNone = 0,
ProtoLlc,
};
if(h->vers != 0)
return 0;
-
+
switch(h->type){
case Tmgmt:
// fc dur da sa bssid seq
memmove(h->bssid, p+16, 6);
h->seq = LittleS(p+22);
break;
-
+
case Tctl:
switch(h->subtype){
case CtlPoll:
memmove(h->bssid, p+4, 6);
memmove(h->ta, p+10, 6);
break;
-
+
case CtlRts:
// fc dur ra ta
if(p+2+2+6+6 > ep)
memmove(h->ra, p+4, 6);
memmove(h->ta, p+10, 6);
break;
-
+
case CtlCts:
case CtlAck:
// fc dur ra
h->dur = LittleS(p+2);
memmove(h->ra, p+4, 6);
break;
-
+
case CtlCfEnd:
case CtlCfEndAck:
// fc dur ra bssid
break;
}
break;
-
+
case Tdata:
if(p+24 > ep)
return -1;
h->proto = ProtoLlc;
break;
}
- return 0;
+ return 0;
}
enum
p_seprint(Msg *m)
{
Hdr h;
-
+
memset(&h, 0, sizeof h);
if(unpackhdr(m->ps, m->pe, &h) < 0)
return -1;
blob - 9319cdaec7a5ab795a386dcb08c18fc287cafe00 (mode 755)
blob + 453f711d7b01849a7a57ec285b220961f77e3a0d (mode 644)
--- src/cmd/ip/snoopy/ppp.c
+++ src/cmd/ip/snoopy/ppp.c
proto = *m->ps++;
if((proto&1) == 0)
proto = (proto<<8) | *m->ps++;
-
+
m->p = seprint(m->p, m->e, "pr=%ud len=%d", proto, len);
demux(p_mux, proto, proto, m, &dump);
default:
p = seprint(p, e, " (type=%d len=%d)", o->type, o->len);
break;
- case Oipaddrs:
+ case Oipaddrs:
p = seprint(p, e, " ipaddrs(deprecated)");
break;
case Oipcompress:
p = seprint(p, e, " ipcompress");
break;
- case Oipaddr:
+ case Oipaddr:
p = seprint(p, e, " ipaddr=%V", o->data);
break;
- case Oipdns:
+ case Oipdns:
p = seprint(p, e, " dnsaddr=%V", o->data);
break;
- case Oipwins:
+ case Oipwins:
p = seprint(p, e, " winsaddr=%V", o->data);
break;
- case Oipdns2:
+ case Oipdns2:
p = seprint(p, e, " dns2addr=%V", o->data);
break;
- case Oipwins2:
+ case Oipwins2:
p = seprint(p, e, " wins2addr=%V", o->data);
break;
}
m->pe = m->ps+len;
else if(m->ps+len > m->pe)
return -1;
-
+
p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
switch(lcp->code) {
default:
p = seprint(p, e, " bad opt len %ux", o->type);
return p;
}
-
+
switch(o->type){
default:
p = seprint(p, e, " type=%d ", o->type);
break;
case 0:
- p = seprint(p, e, " OUI=(%d %.2ux%.2ux%.2ux) ", o->type,
+ p = seprint(p, e, " OUI=(%d %.2ux%.2ux%.2ux) ", o->type,
o->data[0], o->data[1], o->data[2]);
break;
case 17:
m->pe = m->ps+len;
else if(m->ps+len > m->pe)
return -1;
-
+
p = seprint(p, e, "id=%d code=%d", lcp->id, lcp->code);
switch(lcp->code) {
default:
break;
}
m->p = seprint(p, e, " len=%d", len);
-
+
return 0;
}
blob - dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 755)
blob + dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 644)
blob - dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 755)
blob + dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 644)
blob - dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 755)
blob + dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 644)
blob - dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 755)
blob + dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 644)
blob - dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 755)
blob + dab65f8f822fad6c6404b6a6ae7d66dfa79603ff (mode 644)
blob - 058f059df039a023c0caa25c34bd6ca640a6f2d9 (mode 755)
blob + ceb84d57e9330e252b60e5157541df8960027470 (mode 644)
--- src/cmd/ip/snoopy/pppoe_disc.c
+++ src/cmd/ip/snoopy/pppoe_disc.c
Osess
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"v", Fnum, Overs, "version", } ,
{"t", Fnum, Otype, "type", } ,
p_fields,
defaultframer
};
-
blob - 0472a907e0f7c2c3609023734a4bec8faf6a0d94 (mode 755)
blob + 0472a907e0f7c2c3609023734a4bec8faf6a0d94 (mode 644)
blob - 889dc8ab49f89b31ae15777df7196424a9b02b08
blob + 7fa7cc414e27510495edb3d512479398bfda5329
--- src/cmd/ip/snoopy/radiotap.c
+++ src/cmd/ip/snoopy/radiotap.c
p_seprint(Msg *m)
{
Hdr h;
-
+
memset(&h, 0, sizeof h);
if(unpackhdr(m->ps, m->pe, &h) < 0)
return -1;
blob - 149c8207d5bcea2302240931ffaaadf279e0001e (mode 755)
blob + 149c8207d5bcea2302240931ffaaadf279e0001e (mode 644)
blob - 29745d658bdf44f7756b8b99a1626b3e8778cb33 (mode 755)
blob + e764063dae194549fe79b05353c7f676695c3ec6 (mode 644)
--- src/cmd/ip/snoopy/rtcp.c
+++ src/cmd/ip/snoopy/rtcp.c
(NetS(h->len) + 1) * 4);
for(i = 0; i < rc; i++){
- r = (Report*)m->ps;
+ r = (Report*)m->ps;
m->ps += REPORTLEN;
frac = (int)(((float)r->lost[0] * 100.) / 256.);
m->p = seprint(m->p, m->e, "\n\trr(csrc=%8ux frac=%3d%% cumu=%10d seqhi=%10ud jitter=%10d lsr=%8ux dlsr=%f)",
NetL(r->ssrc), frac, NetL(r->lost), NetL(r->seqhi),
- NetL(r->jitter), NetL(r->lsr),
+ NetL(r->jitter), NetL(r->lsr),
dlsr);
}
m->pr = nil;
blob - 1aef15fa50b0b2ba00632bf94e588de64d6cf365 (mode 755)
blob + 1aef15fa50b0b2ba00632bf94e588de64d6cf365 (mode 644)
blob - 1854d1d64df90115f79690fa96f99de205658b59
blob + 78a3be09c07db28d1707bedac1aea34303fbc0e4
--- src/cmd/ip/snoopy/snap.c
+++ src/cmd/ip/snoopy/snap.c
-/*
+/*
* SNAP.
*/
{
Oorg,
Oet,
-
+
OuiEther = 0,
OuiCisco = 0xc,
OuiCisco90 = 0xf8,
blob - b8ea7e40ed6cc3488e461d2299317099debf5a64 (mode 755)
blob + 0afbd5450f27cdd4eab2433b1c237a8c308a17b1 (mode 644)
--- src/cmd/ip/snoopy/tcp.c
+++ src/cmd/ip/snoopy/tcp.c
Osd
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fnum, Os, "source port", } ,
{"d", Fnum, Od, "dest port", } ,
blob - 3d81f33d3ff2dc551e77a753ee4314707a5b6615 (mode 755)
blob + da9510f6002939d5266cdf084ca7cf6ac4629e63 (mode 644)
--- src/cmd/ip/snoopy/udp.c
+++ src/cmd/ip/snoopy/udp.c
Osetport
};
-static Field p_fields[] =
+static Field p_fields[] =
{
{"s", Fnum, Os, "source port", } ,
{"d", Fnum, Od, "dest port", } ,
blob - 6a0a7a00746760d7c79851ede59de066d82675d2
blob + 5ecfc20ad17da1f66c0ef65e34ee654f2d981bb6
--- src/cmd/jpg/jpegdump.c
+++ src/cmd/jpg/jpegdump.c
tab = get1();
printf ("\tcomponent %d: %d hsample, %d vsample, quantization table %d\n",
id, sf >> 4, sf & 0xf, tab);
- }
+ }
}
void get_com (int kind) {
case 0xd8:
printf ("SOI\n");
break;
- case 0xe0: case 0xe1: case 0xe2: case 0xe3:
- case 0xe4: case 0xe5: case 0xe6: case 0xe7:
- case 0xe8: case 0xe9: case 0xea: case 0xeb:
- case 0xec: case 0xed: case 0xee: case 0xef:
+ case 0xe0: case 0xe1: case 0xe2: case 0xe3:
+ case 0xe4: case 0xe5: case 0xe6: case 0xe7:
+ case 0xe8: case 0xe9: case 0xea: case 0xeb:
+ case 0xec: case 0xed: case 0xee: case 0xef:
get_app(c);
break;
case 0xda:
blob - f74da4c54b71ff985761e6a02e15a553b10b2e16
blob + 7618c6055801cb4e25756411d150b397903c3bf9
--- src/cmd/jpg/jpg.c
+++ src/cmd/jpg/jpg.c
free(a2->cmap);
free(a1);
free(a2);
- }
+ }
if (aa2[i] != nil)
fprint(2, "jpg: vidmerge: unequal lengths\n");
free(aa1);
blob - ea1c489bec696fabcf1c1b03393488953743a7fb
blob + 9baf366c9cd3533216a65614b3644e30815e76be
--- src/cmd/jpg/onechan.c
+++ src/cmd/jpg/onechan.c
dx = Dx(r);
dy = Dy(r);
- /*
+ /*
* Read image data into memory
* potentially one extra byte on each end of each scan line.
*/
blob - 154cb48d0531d4a846bcef722be0c69c817be102
blob + 586f63cdac94755eb23191651fb7d41cac1c9e41
--- src/cmd/jpg/readbmp.c
+++ src/cmd/jpg/readbmp.c
p = &buf[ix + iy * width];
if((1 == (val & 3)) || (2 == (val & 3)))
skip = 1;
- else
+ else
skip = 0;
while(val--) {
p = &buf[ix + iy * width];
if(val & 1)
skip = 1;
- else
+ else
skip = 0;
while(val--) {
num_coltab = 3;
if(num_coltab) {
- int i;
+ int i;
Bseek(b, bmih.size + sizeof(Infohdr), 0);
for(i = 0; i < num_coltab; i++) {
Bterm(&b);
return a;
}
-
-
blob - 22365669ad0adb7ec2453a4f548a52f07db4c1fb
blob + 092faf0715f1729cf26041783f61705d78db4a14
--- src/cmd/jpg/readgif.c
+++ src/cmd/jpg/readgif.c
nimages = 0;
array[0] = nil;
h->array = array;
-
+
for(;;){
switch(c = Bgetc(h->fd)){
case Beof:
blob - f3ad802e61c6dd7c99f3dfcbf01c79e7742ed31e
blob + c69d043850544ad22baa1e8ec2281d338b24fad9
--- src/cmd/jpg/readjpg.c
+++ src/cmd/jpg/readjpg.c
Huffman acht[4];
int **data[3];
int ndata[3];
-
+
uchar *sf; /* start of frame; do better later */
uchar *ss; /* start of scan; do better later */
int ri; /* restart interval */
return v;
}
-/*
+/*
* return next bit of input
*/
static
blob - 5fdbc1dbb5600cde822d19c587753cb6dd5b2e16
blob + e327a5729def1f063c62a13778067fc04079ef05
--- src/cmd/jpg/readpng.c
+++ src/cmd/jpg/readpng.c
enum{ IDATSIZE=1000000,
/* filtering algorithms, supposedly increase compression */
FilterNone = 0, /* new[x][y] = buf[x][y] */
- FilterSub = 1, /* new[x][y] = buf[x][y] + new[x-1][y] */
- FilterUp = 2, /* new[x][y] = buf[x][y] + new[x][y-1] */
- FilterAvg = 3, /* new[x][y] = buf[x][y] + (new[x-1][y]+new[x][y-1])/2 */
+ FilterSub = 1, /* new[x][y] = buf[x][y] + new[x-1][y] */
+ FilterUp = 2, /* new[x][y] = buf[x][y] + new[x][y-1] */
+ FilterAvg = 3, /* new[x][y] = buf[x][y] + (new[x-1][y]+new[x][y-1])/2 */
FilterPaeth= 4, /* new[x][y] = buf[x][y] + paeth(new[x-1][y],new[x][y-1],new[x-1][y-1]) */
FilterLast = 5,
PropertyBit = 1<<5
return *z->b++;
}
-static uchar
+static uchar
paeth(uchar a, uchar b, uchar c)
{
int p, pa, pb, pc;
-
+
p = (int)a + (int)b - (int)c;
pa = abs(p - (int)a);
pb = abs(p - (int)b);
break;
default:
sysfatal("bad number of channels: %d", z->nchan);
- }
+ }
}
static void
unfilter(p[0], p+1, z->pscan+1, z->scanl-1, (nch*z->bpp+7)/8);
/*
- * Adam7 interlace order.
+ * Adam7 interlace order.
* 1 6 4 6 2 6 4 6
* 7 7 7 7 7 7 7 7
* 5 6 5 6 5 6 5 6
blob - 073f4436b0640308154a1a964846bf7284cf4ec2
blob + 7067fc15f8de0637340dca8ba4b90ce70649fb59
--- src/cmd/jpg/readppm.c
+++ src/cmd/jpg/readppm.c
while((c = Bgetc(b)) != Beof && c != '\n')
;
}
- return c;
+ return c;
}
/*
return -1;
i = 0;
- do {
+ do {
i = i*10 + (c-'0');
} while((c = Bgetch(b)) != Beof && isdigit(c));
blob - f90bc2373d04293382342b6bccdeb0054afef59f
blob + 5194d544834c1e0c7b00ec0c8011e8e111c60f83
--- src/cmd/jpg/readyuv.c
+++ src/cmd/jpg/readyuv.c
static int lsbtab[] = { 6, 4, 2, 0};
-static int
+static int
clip(int x)
{
x >>= 18;
Bterm(&b);
return a;
}
-
-
blob - 08fc4801e040ed5c5a1d07218e0df99919c088a8
blob + 780bf7a503e60270b0dbff6003319a65d30c1fa1
--- src/cmd/jpg/writegif.c
+++ src/cmd/jpg/writegif.c
Bputc(fd, 0x01);
else
Bputc(fd, 0x00);
-
+
/* Delay time, in centisec (argument is millisec for sanity) */
if(dt < 0)
dt = 0;
else
Bputc(fd, depth);
- /*
+ /*
* Read image data into memory
* potentially one extra byte on each end of each scan line
*/
blob - 24a61a3661314cc2b551e34b1adf07a4a77bb586
blob + d0baf1223a482f350bf90ae9dd96d55010bebcf8
--- src/cmd/jpg/writepng.c
+++ src/cmd/jpg/writepng.c
uchar *b = buf, *e = b+n, *img;
int pixels; /* number of pixels in row that can be sent now */
int i, a, pixwid;
-
+
pixwid = z->pixwid;
while(b+pixwid <= e){ /* loop over image rows */
if(z->row >= nrow)
b[2] = (b[2]*255)/a;
}
}
- }else
+ }else
b += pixwid*pixels;
z->col += pixels;
Memimage *ni;
char buf[32];
ulong dst;
-
+
/*
* [A]BGR because we want R,G,B,[A] in big-endian order. Sigh.
*/
dst = ABGR32;
else
dst = BGR24;
-
+
if(i->chan == dst)
return i;
*h++ = tm->min;
*h++ = tm->sec;
chunk(bo, "tIME", buf, h-buf);
-
+
if(II->fields_set & II_GAMMA){
vgamma = II->gamma*100000;
put4(buf, vgamma);
blob - c837865242810f8d735070990ccb2a3b605c1e08
blob + da528a448a34eac6a2fa2f9716bf4ed766450ef8
--- src/cmd/jpg/writeppm.c
+++ src/cmd/jpg/writeppm.c
chan = image->chan;
}
- /*
+ /*
* Read image data into memory
* potentially one extra byte on each end of each scan line
*/
blob - dcbbb581aa50c5d81d4bcb03bd1a252374171d7e
blob + b2e6d359c21f5e7c7ed6a606348ee276f304c080
--- src/cmd/lex/sub1.c
+++ src/cmd/lex/sub1.c
if(!isprint(c)){
print("\\%-3o",c);
charc += 3;
- } else
+ } else
print("%c", c);
break;
}
print("final %d",left[t]);
break;
case S1FINAL:
- print("s1final %d",left[t]);
+ print("s1final %d",left[t]);
break;
case S2FINAL:
print("s2final %d",left[t]);
blob - 9221aea7130b04c2d53cc4f20e7cbedb0929edf4
blob + d619abad7a7ff08225f0ae9df0187482892b9d56
--- src/cmd/lex/sub2.c
+++ src/cmd/lex/sub2.c
case CARAT:
cfoll(left[v]);
break;
- case STAR: case PLUS: case QUEST: case RSCON:
+ case STAR: case PLUS: case QUEST: case RSCON:
cfoll(left[v]);
break;
case BAR: case RCAT: case DIV: case RNEWE:
case BAR: case QUEST: case RNEWE:
follow(p);
break;
- case RCAT: case DIV:
+ case RCAT: case DIV:
if(v == left[p]){
if(nullstr[right[p]])
follow(p);
}
else follow(p);
break;
- case RSCON: case CARAT:
+ case RSCON: case CARAT:
follow(p);
break;
# ifdef DEBUG
Bprint(&fout,"0,\t0,\t0};\n");
/* put out yymatch */
-
+
Bprint(&fout,"struct yywork *yytop = yycrank+%d;\n",yytop);
Bprint(&fout,"struct yysvf *yybgin = yysvec+1;\n");
Bprint(&fout,"Uchar yymatch[] = {\n");
blob - 369afe1b32dab5fcea328a47d554a02714ed0488
blob + af40cfcc61016a07814d65da2ae71108d9f20fff
--- src/cmd/look.c
+++ src/cmd/look.c
case 'f':
fold++;
break;
- case 'i':
+ case 'i':
iflag++;
break;
case 'n':
if(argc < 1) {
direc++;
fold++;
- } else
+ } else
filename = argv[0];
if (!iflag)
rcanon(orig, key);
blob - 666f64c4f2744f10c82523774fbdce4a47df2538
blob + a07858a8d8d6daefe0519fc0c997be6699a65fdc
--- src/cmd/lp/ipcopen.c
+++ src/cmd/lp/ipcopen.c
{
char buf[1024];
int ppid, cpid;
- int n, tot = 0;
+ int n, tot = 0;
while ((n=read(from, buf, sizeof(buf))) > 0) {
if (n==1 && tot==0 && *buf=='\0')
blob - 0dc70259063357f21a7abf0203e2f60301bc1f21
blob + 363d9501e53c210bed0b7d49c0f55df7545c9dc3
--- src/cmd/lp/lpdsend.c
+++ src/cmd/lp/lpdsend.c
if (statflag) {
fprintf(stderr, "cannot have both -k and -q flags\n");
exit(1);
- }
+ }
killflag = 1;
killarg = optarg;
break;
if (killflag) {
fprintf(stderr, "cannot have both -q and -k flags\n");
exit(1);
- }
+ }
statflag = 1;
break;
case 's':
blob - 4893f4521b85c90567345faa1a92c696c63a0fc8
blob + bcdcfdbb5607ffa71bbf3f63a4615f481601a823
--- src/cmd/lp/lpsend.c
+++ src/cmd/lp/lpsend.c
alarm(0);
return(bcnt);
}
-
+
/* get whatever stdin has and put it into the temporary file.
* return the file size.
*/
blob - fca3ee9589ea1c52375386b5176916cdbe932de6
blob + 845532be643aeaf9c9c6f391e01f7eb04c84750a
--- src/cmd/ls.c
+++ src/cmd/ls.c
if(dirbuf == 0){
fprint(2, "ls: malloc fail\n");
exits("malloc fail");
- }
+ }
}
int
buf[12] = 0;
return buf;
}
-
blob - 858f0d69c7dcb7e6a28bcdabda61115fea429326
blob + 1c9db868872eaf11801a68aaf61d30d582833340
--- src/cmd/map/libmap/bonne.c
+++ src/cmd/map/libmap/bonne.c
alpha = place->wlon.l;
else if(fabs(place->nlat.c)==0)
alpha = 0;
- else
+ else
alpha = place->wlon.l/(1+
stdpar.c*stdpar.c*stdpar.c/place->nlat.c/3);
else
blob - fd508d2baae56d34302020f5099bc4901aee0a64
blob + abfd6ea093c619c07b2eca1e6505790b28dfb5d9
--- src/cmd/map/libmap/cubrt.c
+++ src/cmd/map/libmap/cubrt.c
cubrt(double a)
{
double x,y,x1;
- if(a==0)
+ if(a==0)
return(0.);
y = 1;
if(a<0) {
blob - b4c9bbf695dbddec867071bc33680cb7c02e7f4b
blob + 6f7d560445f25a2fd2a3f458a3a987f4c580bf0e
--- src/cmd/map/libmap/elco2.c
+++ src/cmd/map/libmap/elco2.c
cmul(c,dn2,1+e1*m2,e2*m2,&f1,&f2);
cdiv(d*x,d*y,f1,f2,&d1[i],&d2[i]);
- if(k<=CC)
+ if(k<=CC)
break;
kc = sqrt(m*kc);
f = m2;
blob - 173ffcd34a7ccbb670a27c05f552efa3abcf44e1
blob + f7ee7b6f8497b04db92db4b15d6812c43d451b29
--- src/cmd/map/libmap/gilbert.c
+++ src/cmd/map/libmap/gilbert.c
use standard formula: tan x/2 = (1-cos x)/sin x = sin x/(1+cos x)
to show that the right side of the last equation is tan(n/2)
*/
-
-
blob - 366f69fe440bbf95918ce28734151675c986599b
blob + 9678c6810ddc7855c212008dffff24a16a07197e
--- src/cmd/map/libmap/homing.c
+++ src/cmd/map/libmap/homing.c
return 0;
}
*lat += res;
- if(*lat <= 90)
+ if(*lat <= 90)
return 1;
if(*lon == 90)
return -1;
blob - 6b688aa3d0309b98464f2d5c1afaa97a766037c8
blob + e8037a6c4df473f1659a64ab03607a8c8635307e
--- src/cmd/map/libmap/lambert.c
+++ src/cmd/map/libmap/lambert.c
}
deg2rad(par0, &stdp0);
deg2rad(par1, &stdp1);
- if(fabs(par1+par0)<.1)
+ if(fabs(par1+par0)<.1)
return(mercator());
if(fabs(par1-par0)<.1)
return(perspective(-1.));
blob - dc58c6f05045d1db2ce452f5fcee4f66fe979240
blob + a3d06d8176eb737c9b873274b324fc370d2e5231
--- src/cmd/map/libmap/lune.c
+++ src/cmd/map/libmap/lune.c
deny = w1y + w2y;
cdiv(numx, numy, denx, deny, x, y);
return 1;
-}
+}
proj
lune(double lat, double theta)
blob - 6bdef49b9e6299c9a3e2388fed0f006cf9d714ba
blob + 31837de287a61e4496354f498703243a037d7f61
--- src/cmd/map/libmap/tetra.c
+++ src/cmd/map/libmap/tetra.c
{/*30*/ {0., -45., 45., -150.},
/*31*/ {0., -135., 135., -30.},
/*32*/ {-90., 0., 0., 90.},
- /*33*/ {0.}
+ /*33*/ {0.}
}};
static double tx[4] = { /*where to move facet after final rotation*/
0., 0., -1., 1. /*-1,1 to be sqrt(3)*/
return 0;
vr = fpir - vr;
vi = fpii - vi;
- } else
+ } else
if(!elco2(br,bi,tk,1.,1.,&vr,&vi))
return 0;
if(si>=0) {
tetracut(struct place *g, struct place *og, double *cutlon)
{
int i,j,k;
- if((g->nlat.s<=-rt3inv&&og->nlat.s<=-rt3inv) &&
+ if((g->nlat.s<=-rt3inv&&og->nlat.s<=-rt3inv) &&
(ckcut(g,og,*cutlon=0.)==2||ckcut(g,og,*cutlon=PI)==2))
return(2);
twhichp(g,&i,&k);
}
return(Xtetra);
}
-
blob - 0d0e48a4e30419581a27f1e6238053335b9ad648
blob + 9c7b7ec4fd1c15d7a0642414e3036195a62dd1aa
--- src/cmd/map/libmap/twocirc.c
+++ src/cmd/map/libmap/twocirc.c
*y = (*x*a+t/2)/b;
}
return 1;
-}
+}
static int
Xglobular(struct place *place, double *x, double *y)
twocircles(-2*place->wlon.l/PI,
2*place->nlat.l/PI, place->nlat.c, place->nlat.s, x, y);
return 1;
-}
+}
proj
globular(void)
double pval = abst>=1? 1: abst/(1+sqrt(1-t*t));
double p2 = 2*pval/(1+pval);
twocircles(-place->wlon.l/PI, pval, sqrt(1-p2*p2), p2, x, y);
- if(t < 0)
+ if(t < 0)
*y = -*y;
return 1;
}
blob - 74ae79ac314dc9f7bcc9bedbe11760d6ce1b6aab
blob + 5ca1a65c0f5414714408c93b12c8c2464751f473
--- src/cmd/map/map.c
+++ src/cmd/map/map.c
void realcut(void);
int
-option(char *s)
+option(char *s)
{
if(s[0]=='-' && (s[1]<'0'||s[1]>'9'))
s = getenv("MAPDIR");
if(s)
mapdir = s;
- if(argc<=1)
+ if(argc<=1)
error("usage: map projection params options");
for(k=0;index[k].name;k++) {
s = index[k].name;
argc -= i;
break;
case 'c':
- for(i=0;i<3&&argc>i&&!option(argv[i]);i++)
+ for(i=0;i<3&&argc>i&&!option(argv[i]);i++)
center[i] = atof(argv[i]);
argc -= i;
argv += i;
position[i] = atof(argv[i]);
argc -= i;
argv += i;
- if(i!=3||position[2]<=0)
+ if(i!=3||position[2]<=0)
error("incomplete positioning");
break;
case 'y':
crot.l = center[2]*RAD;
sincos(&crot);
scaling *= HALFWIDTH*0.9;
- if(symbolfile)
+ if(symbolfile)
getsyms(symbolfile);
if(!s2flag) {
openpl();
pen(DOTTED);
if(grid[0]>0.)
for(lat=ceil(lolat/grid[0])*grid[0];
- lat<=hilat;lat+=grid[0])
+ lat<=hilat;lat+=grid[0])
dogrid(lat,lat,lolon,hilon);
if(grid[1]>0.)
for(lon=ceil(lolon/grid[1])*grid[1];
- lon<=hilon;lon+=grid[1])
+ lon<=hilon;lon+=grid[1])
dogrid(lolat,hilat,lon,lon);
comment("border","");
colorx(bordcolor);
if(!inwindow(&geog))
return(-1);
i = fixproj(&geog,x,y);
- if(rflag)
+ if(rflag)
*x = -*x;
/*
printp(&geog);
latlon(lat,lon,&geog);
normalize(&geog);
i = fixproj(&geog,x,y);
- if(rflag)
+ if(rflag)
*x = -*x;
return(i);
}
nvert = 4;
v[2] = v[1];
v[1].x=v[0].x, v[1].y=v[2].y, v[3].x=v[2].x, v[3].y=v[0].y;
- }
+ }
v[nvert] = v[0];
v[nvert+1] = v[1];
s = 0;
{
struct place g;
double lat;
-
+
if(cut != picut) /* punt on unusual cuts */
return;
for(lat=window[0]; lat<=window[1]; lat+=grid[2]) {
blob - c4c67134de7528f8ccc9e00a1bab45787da1c244
blob + 8a6cfccc33385a96de266089e3bbfafb5e021d43
--- src/cmd/map/route.c
+++ src/cmd/map/route.c
dlat = fabs(an-bn);
printf("-o %.4f %.4f %.4f -w %.2f %.2f %.2f %.2f \n",
pn,pw,theta, -0.3*cw1, .3*cw1, -.6*cw1, .6*cw1);
-
+
} else {
cn1 = 0;
n = 1 + fabs(bw1-aw1)/.2;
blob - 11df34e31051127ecc860caeeeb079dce3e24498
blob + d7c6481d7bb4b7a817e17c5255af89e3f1530d1b
--- src/cmd/mk/env.c
+++ src/cmd/mk/env.c
for(i = 0; *p; i++, p++){
if((j->r->attr®EXP) && j->match[i])
envupd(*p, newword(j->match[i]));
- else
+ else
envupd(*p, newword(""));
}
return envy;
blob - 30728197e7eea5b6506cf32a1441399f5d261588
blob + 537d2d75a5c2a73e072f2a0afdc07e5ef219e552
--- src/cmd/mk/rule.c
+++ src/cmd/mk/rule.c
{
if(r == nil)
return;
- Bprint(&bout, "%s: start=%ld shelltype=%s shellcmd=%s\n",
+ Bprint(&bout, "%s: start=%ld shelltype=%s shellcmd=%s\n",
s, r, r->shellt->name, wtos(r->shellcmd, ' '));
for(; r; r = r->next){
Bprint(&bout, "\tRule %ld: %s[%d] attr=%x next=%ld chain=%ld alltarget='%s'",
blob - dd225c0d0be0936b6ded1823e79481ebe867d7e8
blob + 6f60cede03081982585aa5924cff978b73a37c0c
--- src/cmd/mk/run.c
+++ src/cmd/mk/run.c
for(jj = jobs; jj->next; jj = jj->next)
;
jj->next = j;
- } else
+ } else
jobs = j;
j->next = 0;
/* this code also in waitup after parse redirect */
blob - e25665141637d5fb2df92c167200f7946edb927c
blob + d8f205c8cee84c91a9e6a031cea000dfe12563f9
--- src/cmd/mk/sh.c
+++ src/cmd/mk/sh.c
shcopyq,
shmatchname
};
-
blob - 03a9d058d3eaa9f2055a10476521a55137916d8b
blob + f520b066c2e9c2be32ca0ac0f7f0fe44c44e5642
--- src/cmd/mk/sys.h
+++ src/cmd/mk/sys.h
#include <libc.h>
#include <bio.h>
#include <regexp.h>
-
blob - c63d3cefd0246d4644ba8a9e2758eb349beea255
blob + 37f05b717f5f54e3cfbc4d5e9fe750352f0b2531
--- src/cmd/mk/unix.c
+++ src/cmd/mk/unix.c
Word *w;
for(p = environ; *p; p++){
-/* rsc 5/5/2004 -- This misparses fn#cd={whatever}
+/* rsc 5/5/2004 -- This misparses fn#cd={whatever}
s = shname(*p);
if(*s == '=') {
*s = 0;
n = 0;
for(w=cmd; w; w=w->next)
n++;
-
+
argv = Malloc((n+extra+1)*sizeof(argv[0]));
i = 0;
for(w=cmd; w; w=w->next)
argv[n] = 0;
*pargv = argv;
return n;
-}
+}
int
execsh(char *args, char *cmd, Bufblock *buf, Envy *e, Shell *sh, Word *shellcmd)
blob - f858a92afe8ef57202d4ae5bc9e04aee62d87623
blob + b6c0ab0f7702cf2bc44fc447b705f87724a1473d
--- src/cmd/mk/varsub.c
+++ src/cmd/mk/varsub.c
{
Word *w;
Symtab *sym;
-
+
sym = symlook(name, S_VAR, 0);
if(sym){
/* check for at least one non-NULL value */
}
*end = 0;
*s = end+1;
-
+
sym = symlook(buf->start, S_VAR, 0);
if(sym == 0 || sym->u.ptr == 0)
w = newword(buf->start);
while(w->next)
w = w->next;
}
- if(PERCENT(*cp) && nmid > 0){
+ if(PERCENT(*cp) && nmid > 0){
if(w){
bufcpy(buf, w->s, strlen(w->s));
bufcpy(buf, enda, nmid);
}
if(w == 0)
h = w = newword(v->s);
-
+
if(head == 0)
head = h;
else
blob - f94c4fd7960931595d31bbc412354485bf88f4ce
blob + e1e52a1c37c352b3e219549f20f6e727e7ee8ce6
--- src/cmd/mk/word.c
+++ src/cmd/mk/word.c
head = w = new;
while(w->next)
w = w->next;
-
+
}
if (!head)
head = newword("");
blob - 54994cdd19bcfd600ffb8ae4c622ceb5b9149576
blob + a1d00dfba42899133626ce58b2ab21acb31507a7
--- src/cmd/mpm/range.h
+++ src/cmd/mpm/range.h
class vboxrange : public range {
int dv; // inherited from slug
int base; // inherited from slug
- int brk; // 0 => ok to break after, 1 => no break
+ int brk; // 0 => ok to break after, 1 => no break
public:
vboxrange(slug *p) : range(p) { dv = p->dv; base = p->base; brk = p->parm; }
void dump() {
blob - 9dfd3b2a1b4f1cd07277ca9934312f01e54f2b3e
blob + 0f72b931dcd117a513b097e7c015bd55a87ecdc2
--- src/cmd/mpm/slug.h
+++ src/cmd/mpm/slug.h
PL, // distance of physical page bottom from page top (Page Length)
MF, // minimum fullness required for padding
CT, // tolerance for division into two columns
- WARN, // warnings to stderr?
+ WARN, // warnings to stderr?
DBG // debugging flag
};
blob - 823e204a640bbb716d3d5696450bcd11ed31b960
blob + ff01450ceca36fa465a0437199241e457be0b299
--- src/cmd/namespace.c
+++ src/cmd/namespace.c
print("%s\n", ns);
exits(0);
}
-
blob - 60fd9402ff488b50bbc2a660a96eb7a66b7db3e8 (mode 755)
blob + 60fd9402ff488b50bbc2a660a96eb7a66b7db3e8 (mode 644)
blob - 8e1fd0ce9464896e62db2a0ad7d62e03bf3b32f1 (mode 755)
blob + 8e1fd0ce9464896e62db2a0ad7d62e03bf3b32f1 (mode 644)
blob - ca73184aab9594550df8ee8499bf3b8af4d6a211 (mode 755)
blob + 067ba4447c2662acad6f07478522af7d1ae63d7b (mode 644)
--- src/cmd/ndb/dblookup.c
+++ src/cmd/ndb/dblookup.c
rp->rmb = dnlookup(mailbox, Cin, 1);
}
- /* hang dns slaves off of the soa. this is
+ /* hang dns slaves off of the soa. this is
* for managing the area.
*/
for(t = entry; t != nil; t = t->entry)
if(strcmp(t->attr, "dnsslave") == 0)
addserver(&rp->soa->slaves, t->val);
-
+
return rp;
}
unlock(&dblock);
return;
}
-
+
/* forget our area definition */
freearea(&owned);
freearea(&delegated);
-
+
/* reopen all the files (to get oldest for time stamp) */
for(ndb = db; ndb; ndb = ndb->next)
ndbreopen(ndb);
if(cachedb){
/* mark all db records as timed out */
dnagedb();
-
+
/* read in new entries */
for(ndb = db; ndb; ndb = ndb->next)
dbfile2cache(ndb);
-
+
/* mark as authentic anything in our domain */
dnauthdb();
-
+
/* remove old entries */
dnageall(1);
} else {
snprint(buf, sizeof buf, "%I", ipaddr);
a[0] = attr;
-
+
lock(&dblock);
if(opendatabase() < 0){
unlock(&dblock);
blob - 8b874030d9b35daae17ca13237851a920ba37742 (mode 755)
blob + 5a37eefa951668bd59f0b3b1da27615405f8f123 (mode 644)
--- src/cmd/ndb/dn.c
+++ src/cmd/ndb/dn.c
"cert",
nil,
nil,
-
+
/* 40 */ nil, nil, nil, nil, nil, nil, nil, nil,
/* 48 */ nil, nil, nil, nil, nil, nil, nil, nil,
/* 56 */ nil, nil, nil, nil, nil, nil, nil, nil,
/* 224 */ nil, nil, nil, nil, nil, nil, nil, nil,
/* 232 */ nil, nil, nil, nil, nil, nil, nil, nil,
/* 240 */ nil, nil, nil, nil, nil, nil, nil, nil,
-/* 248 */ nil, nil, nil,
+/* 248 */ nil, nil, nil,
"ixfr",
"axfr",
if(x->type != Ta && x->type != Tmx && x->type != Tns)
return rp;
- base = rp;
+ base = rp;
n = rand();
last = first = nil;
{
Server *ns;
-
+
for(ns = nil; s != nil; s = s->next)
addserver(&ns, s->name);
return ns;
blob - 05c9d0043ccac7da209714661f23d5cf2446e805 (mode 755)
blob + bb4d050cb8c13bfc8850f77043b0592ec7c1cf11 (mode 644)
--- src/cmd/ndb/dnarea.c
+++ src/cmd/ndb/dnarea.c
{
Waitmsg *w;
char *argv[3];
-
+
argv[0] = zonerefreshprogram;
argv[1] = "XXX";
argv[2] = nil;
free(w);
}
}
-
blob - 8e4b307565bcce7432fd1490439e54173ac9051b (mode 755)
blob + 8e4b307565bcce7432fd1490439e54173ac9051b (mode 644)
blob - 979abe4ebda01f13a56daabbfde8dcdbdb56cccc (mode 755)
blob + 366521b686443fcbd979031c1ae051de0a08a346 (mode 644)
--- src/cmd/ndb/dnresolve.c
+++ src/cmd/ndb/dnresolve.c
rp = nil;
break;
}
-
+
name = rp->host->name;
if(cn)
rrcat(cn, rp);
else
rrfreelist(rp);
-
+
rp = dnresolve1(name, class, type, req, depth, recurse);
}
}
rrfreelist(rp);
/*
- * try the cache for a canonical name. if found punt
+ * try the cache for a canonical name. if found punt
* since we'll find it during the canonical name search
* in dnresolve().
*/
}
/*
- * Get a udpport for requests and replies.
+ * Get a udpport for requests and replies.
*/
int
udpport(void)
len = udpreadtimeout(fd, (Udphdr*)ibuf, ibuf+Udphdrsize, Maxudpin, (endtime-now)*1000);
if(len < 0)
return -1; /* timed out */
-
+
/* convert into internal format */
memset(mp, 0, sizeof(*mp));
err = convM2DNS(&ibuf[Udphdrsize], len, mp);
{
fd_set rd;
struct timeval tv;
-
+
FD_ZERO(&rd);
FD_SET(fd, &rd);
-
+
tv.tv_sec = ms/1000;
tv.tv_usec = (ms%1000)*1000;
-
+
if(select(fd+1, &rd, 0, 0, &tv) != 1)
return -1;
return udpread(fd, h, data, n);
soarr->next = nil;
}
soaowner = soarr->owner;
- } else
+ } else
soaowner = nil;
/* the attach can cause soarr to be freed so mine it now */
blob - 05a5dd45604f09101b241051aa6e045fc413291c (mode 755)
blob + cb3170529338cc65d956250ab577d4966e223ed7 (mode 644)
--- src/cmd/ndb/dns.c
+++ src/cmd/ndb/dns.c
default:
usage();
}ARGEND
-
+
if(argc)
usage();
if(serveudp && servetcp)
blob - 9825f0bd1734856c449a61f4244714228649f1d1 (mode 755)
blob + fbd114f3aaaa22734a37f5a0f6c61c41700ec5f8 (mode 644)
--- src/cmd/ndb/dns.h
+++ src/cmd/ndb/dns.h
/* query types (all RR types are also queries) */
Tixfr= 251, /* incremental zone transfer */
Taxfr= 252, /* zone transfer */
- Tmailb= 253, /* { Tmb, Tmg, Tmr } */
+ Tmailb= 253, /* { Tmb, Tmg, Tmr } */
Tall= 255, /* all records */
/* classes */
blob - 0818b85ff0d20ba48ee5628e7c6732d3f9620eb4 (mode 755)
blob + c3ad3e13ca3733f326c7f747d712198ea6a1e536 (mode 644)
--- src/cmd/ndb/dnsdebug.c
+++ src/cmd/ndb/dnsdebug.c
preloadserveraddrs(void)
{
RR *rp, **l, *first;
-
+
l = &first;
for(rp = serveraddrs; rp != nil; rp = rp->next){
rrcopy(rp, l);
blob - 509734b033ce39c3cfd35da475d1ae237cd6a746 (mode 755)
blob + 660006bd79b3c8cd1b740fdf5540cc74c66ba147 (mode 644)
--- src/cmd/ndb/dnserver.c
+++ src/cmd/ndb/dnserver.c
nsdp = dnlookup(cp, repp->qd->owner->class, 0);
if(nsdp == 0)
continue;
-
+
repp->ns = rrlookup(nsdp, Tns, OKneg);
if(repp->ns){
/* don't pass on anything we know is wrong */
}
break;
}
-
+
repp->ns = dblookup(cp, repp->qd->owner->class, Tns, 0, 0);
if(repp->ns)
break;
blob - dc7ae06b4c64f0d988f162a1d90317f7ce3ec1f8 (mode 755)
blob + dc7ae06b4c64f0d988f162a1d90317f7ce3ec1f8 (mode 644)
blob - 3d4d1e901c596d8e8894c3274bc93af73642e557 (mode 755)
blob + 3d4d1e901c596d8e8894c3274bc93af73642e557 (mode 644)
blob - 13161548142617471439724ff69d5ba3cc4c9521
blob + 713331f463d4da45a8765dfbeabc6772d891ef6c
--- src/cmd/ndb/dntcpserver.c
+++ src/cmd/ndb/dntcpserver.c
tcpannounce(char *mntpt)
{
int fd;
-
+
USED(mntpt);
if((fd=announce(tcpaddr, adir)) < 0)
warning("announce %s: %r", tcpaddr);
blob - 9f84125cdde6d37e492f6c9df1637390b9e74e35 (mode 755)
blob + a84cd0505ecc426da803660516ebb769701588e6 (mode 644)
--- src/cmd/ndb/dnudpserver.c
+++ src/cmd/ndb/dnudpserver.c
for(i=0; i<Maxactive; i++)
proccreate(udpproc, (void*)(uintptr)fd, STACK);
}
-
blob - 507bd7c7809b9dae8f87b92697855ff84637dd07
blob + ea334bf771b084dcba9367b10c81feda1a95e2b2
--- src/cmd/ndb/ndbmkhash.c
+++ src/cmd/ndb/ndbmkhash.c
{
Ndbtuple *t, *nt;
int n;
- Dir *d;
+ Dir *d;
uchar buf[8];
char file[128];
int fd;
blob - 65bc04720bd103d653764dfa648aff0e1808d0b3
blob + 85b72b1ea02ab0be473616151f42d0cf14c9efd2
--- src/cmd/ndb/ndbquery.c
+++ src/cmd/ndb/ndbquery.c
default:
usage();
}
-
+
db = ndbopen(dbfile);
if(db == 0){
fprint(2, "no db files\n");
blob - db344f975e5b8cee147fe46066816256cabeffaa
blob + 5d1274af547b38bcf9ef4aae06f6e9cfdd3f78d7
--- src/cmd/ndb/runproc.c
+++ src/cmd/ndb/runproc.c
}
return runprocfd(file, v, fd);
}
-
blob - ddd39284c5d5293800df1d773b2b2133388d0a7f
blob + 0a6b2da891109d9ed9fc630245ddd5cf21f64e27
--- src/cmd/netfiles/acme.c
+++ src/cmd/netfiles/acme.c
winopenfd(Win *w, char *name, int mode)
{
char buf[100];
-
+
snprint(buf, sizeof buf, "%d/%s", w->id, name);
return fsopenfd(acmefs, buf, mode);
}
char buf[40], *p;
uint q0;
int n;
-
+
n = fspread(wfid(w, "addr"), buf, sizeof buf-1, 0);
if(n <= 0)
return -1;
{
char *buf;
int n, tot, m;
-
+
m = 128;
buf = emalloc(m+1);
tot = 0;
{
CFid *fid;
char *s;
-
+
mountacme();
if((fid = fsopen(acmefs, "index", OREAD)) == nil)
return nil;
Event e[2];
Win *w;
int i;
-
+
w = v;
i = 0;
for(;;){
{
int n;
char *p;
-
+
n = winread(w, "tag", w->name, sizeof w->name-1);
if(n <= 0)
return nil;
*p = 0;
return w->name;
}
-
blob - 50997e97a728135b44bee4666742ccf1cf1eefc7
blob + c792a9c1e49b9d64007c948cb9915e177bc2e813
--- src/cmd/netfiles/acme.h
+++ src/cmd/netfiles/acme.h
Channel *c; /* chan(Event) */
Win *next;
Win *prev;
-
+
/* events */
int nbuf;
char name[1024];
blob - 45e19416316cf9b6bf770002fc8af6b85de5a278
blob + baacb984f5d98e448f08e22aec8454bd9c23f6ff
--- src/cmd/netfiles/main.c
+++ src/cmd/netfiles/main.c
/*
* Remote file system editing client.
* Only talks to acme - external programs do all the hard work.
- *
+ *
* If you add a plumbing rule:
# /n/ paths go to simulator in acme
arg(char *file, char *addr, Channel *c)
{
Arg *a;
-
+
a = emalloc(sizeof *a);
a->file = estrdup(file);
a->addr = estrdup(addr);
winbyid(int id)
{
Win *w;
-
+
for(w=windows; w; w=w->next)
if(w->id == id)
return w;
lookup(char *s, char **list)
{
int i;
-
+
for(i=0; list[i]; i++)
if(strcmp(list[i], s) == 0)
return i;
expandarg(Win *w, Event *e)
{
uint q0, q1;
-
+
if(e->c2 == 'l') /* in tag - no choice but to accept acme's expansion */
return estrdup(e->text);
winaddr(w, ",");
if(e->oq0 == e->oq1 && e->q0 != e->q1 && !isdot(w, e->q0, e->q1)){
winaddr(w, "#%ud+#1-/[^ \t\\n]*/,#%ud-#1+/[^ \t\\n]*/", e->q0, e->q1);
q0 = winreadaddr(w, &q1);
- cprint("\tre-expand to %d-%d\n", q0, q1);
+ cprint("\tre-expand to %d-%d\n", q0, q1);
}else
winaddr(w, "#%ud,#%ud", e->q0, e->q1);
return winmread(w, "xdata");
char *addr;
Plumbmsg *m;
Win *w;
-
+
m = vm;
if(m->ndata >= 1024){
fprint(2, "insanely long file name (%d bytes) in plumb message (%.32s...)\n",
plumbfree(m);
return;
}
-
+
addr = plumblookup(m->attr, "addr");
w = nametowin(m->data);
if(w == nil)
{
CFid *fid;
Plumbmsg *m;
-
+
threadsetname("plumbthread");
fid = plumbopenfid("netfileedit", OREAD);
if(fid == nil){
parsename(char *name, char **server, char **path)
{
char *p, *nul;
-
+
cleanname(name);
if(strncmp(name, "/n/", 3) != 0 && name[3] == 0)
return -1;
winname(w, a->file);
winprint(w, "tag", "Get Put Look ");
c = wineventchan(w);
-
+
goto caseGet;
-
+
while((e=recvp(c)) != nil){
if(e->c1!='K')
dprint("acme %E\n", e);
winaddr(w, ",");
winprint(w, "data", "[reading...]");
winaddr(w, ",");
- cprint("9 netfileget %s%q %q\n",
+ cprint("9 netfileget %s%q %q\n",
strcmp(type, "file") == 0 ? "" : "-d", server, path);
if(strcmp(type, "file")==0)
twait(pipetowin(w, "data", 2, "9 netfileget %q %q", server, path));
Arg *a;
Channel *c;
Win *w;
-
+
c = chancreate(sizeof(void*), 0);
a = arg(name, nil, c);
threadcreate(filethread, a, STACK);
loopthread(void *v)
{
QLock lk;
-
+
threadsetname("loopthread");
qlock(&lk);
qlock(&lk);
}
-
+
void
threadmain(int argc, char **argv)
{
default:
usage();
}ARGEND
-
+
if(argc)
usage();
fmtinstall('E', eventfmt);
doquote = needsrcquote;
quotefmtinstall();
-
+
twaitinit();
threadcreate(plumbthread, nil, STACK);
threadcreate(loopthread, nil, STACK);
threadexits(nil);
}
-
blob - 3434ebc844d9a890fe7c282bd5d3630eb2f44777
blob + 0d6032978204af401a1f270ed433e29c9acc1df5
--- src/cmd/netfiles/wait.c
+++ src/cmd/netfiles/wait.c
wq[nwq++] = w;
}
break;
-
+
case 1:
dprint("wait: req for pid %d chan %p\n", r.pid, r.c);
for(i=0; i<nwq; i++){
{
Waitreq r;
Waitmsg *w;
-
+
r.pid = pid;
r.c = chancreate(sizeof(Waitmsg*), 1);
send(twaitchan, &r);
{
int x;
Waitmsg *w;
-
+
w = twaitfor(pid);
x = w->msg[0] != 0 ? -1 : 0;
free(w);
twaitchan = chancreate(sizeof(Waitreq), 10);
threadcreate(waitthread, nil, 128*1024);
}
-
blob - 5110840f7e52e3395b5db5170b71510f80e05499
blob + a1083fc77eb4c4c9292c94e6dcf99032329a4bf8
--- src/cmd/page/cache.c
+++ src/cmd/page/cache.c
static Image *im;
if(im)
- return im;
+ return im;
im = xallocimage(display, Rect(0,0,50,50), GREY1, 1, DBlack);
if(im == nil)
return nil;
raproc(void *a)
{
Cached *c;
-
+
c = a;
lockdisplay(display);
/*
Cached *c;
Image *im;
int ra;
-
+
if(doc->npage < 1)
return display->white;
blob - 22e08665fc1a4fa3b77ea20b7d02783fb859aab5
blob + 793d75a41b8ca65b9d139fde2c0a9f2117d98828
--- src/cmd/page/gfx.c
+++ src/cmd/page/gfx.c
doc = emalloc(sizeof(*doc));
gfx = emalloc(sizeof(*gfx));
gfx->g = nil;
-
+
doc->npage = 0;
doc->drawpage = gfxdrawpage;
doc->pagename = gfxpagename;
memset(g, 0, sizeof *g);
if(memcmp(buf, "GIF", 3) == 0)
g->type = Igif;
- else if(memcmp(buf, "\111\111\052\000", 4) == 0)
+ else if(memcmp(buf, "\111\111\052\000", 4) == 0)
g->type = Itiff;
else if(memcmp(buf, "\115\115\000\052", 4) == 0)
g->type = Itiff;
return doc->npage++;
}
-static int
+static int
addpage(Document *doc, char *name)
{
return genaddpage(doc, name, nil, 0);
if(fd < 0) {
fprint(2, "cannot spawn converter: %r\n");
wexits("convert");
- }
+ }
}
im = readimage(display, fd, 0);
blob - 5c493b35583d44c8301a1aa3c3b848c6aef2857e
blob + 1d60212a2370e740b669006eaed6d942e372fad2
--- src/cmd/page/gs.c
+++ src/cmd/page/gs.c
/*
* gs interface for page.
* ps.c and pdf.c both use these routines.
- * a caveat: if you run more than one gs, only the last
- * one gets killed by killgs
+ * a caveat: if you run more than one gs, only the last
+ * one gets killed by killgs
*/
#include <u.h>
#include <libc.h>
threadexits(0);
}
-int
+int
spawngs(GSInfo *g, char *safer)
{
Channel *cp;
blob - 96563c3d1663fb7ff179681f39344fa4df6c8533
blob + 00d065ad8d6dda3d45c3a4131d9dc68805e60c49
--- src/cmd/page/nrotate.c
+++ src/cmd/page/nrotate.c
* The basic concept is that you can invert an array by
* inverting the top half, inverting the bottom half, and
* then swapping them.
- *
+ *
* This is usually overkill, but it speeds up slow remote
* connections quite a bit.
*/
/*
* Halve the grating period in the mask.
- * The grating currently looks like
+ * The grating currently looks like
* ####____####____####____####____
* where #### is opacity.
*
* ##__##__##__##__##__##__##__##__
* which is achieved by shifting the mask
* and drawing on itself through itself.
- * Draw doesn't actually allow this, so
+ * Draw doesn't actually allow this, so
* we have to copy it first.
*
* ####____####____####____####____ (dst)
/*
* r0 is the lower rectangle, while r1 is the upper one.
*/
- draw(tmp, tmp->r, img, nil,
+ draw(tmp, tmp->r, img, nil,
}
void
snprint(buf, sizeof buf, "%d%s%d", c++, name, gran);
fd = create(buf, OWRITE, 0666);
if(fd < 0)
- return;
+ return;
writeimage(fd, im, 0);
close(fd);
}
-
blob - 041df26bb97440cf74502518d206b91ebdc78a7f
blob + 01ad17ff946e7b36da18598cfb24cd3e682490ce
--- src/cmd/page/page.c
+++ src/cmd/page/page.c
for(;;)
sleep(1000);
}
-
+
int
bell(void *u, char *x)
{
void
usage(void)
{
- fprint(2, "usage: page [-biRrwf] [-p ppi] file...\n");
+ fprint(2, "usage: page [-biRrwf] [-p ppi] file...\n");
wexits("usage");
}
break;
case 'f':
fitwin = 1;
- break;
+ break;
default:
usage();
}ARGEND;
fprint(2, "page: short read reading %s\n", argv[0]);
wexits("read");
}
-
+
atexit(cleanup);
}else if(argc != 0){
if(!(b = Bopen(argv[0], OREAD))) {
fprint(2, "page: cannot open \"%s\"\n", argv[0]);
wexits("open");
- }
+ }
if(Bread(b, buf, Ninput) != Ninput) {
fprint(2, "page: short read reading %s\n", argv[0]);
wexits("initdraw");
}
display->locking = 1;
-
+
truecolor = screen->depth > 8;
viewer(doc);
wexits(0);
blob - 2de67bc7a1a14767b48d97dd02172df6e38bac04
blob + 89df6c5ef67dfb9e70897c07a75f42ce52f4518b
--- src/cmd/page/pdf.c
+++ src/cmd/page/pdf.c
/*
* pdf.c
- *
+ *
* pdf file support for page
*/
static Image* pdfdrawpage(Document *d, int page);
static char* pdfpagename(Document*, int);
-char *pdfprolog =
+char *pdfprolog =
#include "pdfprolog.c"
;
char *p;
char *f[4];
Rectangle r;
-
+
r = Rect(0,0,0,0);
waitgs(gs);
gscmd(gs, "/CropBox knownoget {} {[0 0 0 0]} ifelse PAGE==\n");
pdfpagename(Document *d, int page)
{
static char str[15];
-
+
USED(d);
sprint(str, "p %d", page+1);
return str;
blob - 846895718caafaa40d16309961cc1b0884793743
blob + eb09cc8f89b45a5bab0ee62425d8a40ce303770a
--- src/cmd/page/ps.c
+++ src/cmd/page/ps.c
/*
* ps.c
- *
+ *
* provide postscript file reading support for page
*/
if(!prefix(p, "%%Page:"))
continue;
- /*
+ /*
* figure out of the %%Page: line contains a page number
* or some other page description to use in the menu bar.
- *
+ *
* lines look like %%Page: x y or %%Page: x
* we prefer just x, and will generate our
* own if necessary.
blob - 3ac83a1fbb8c976c508c38b665e224f4bd32871a
blob + 2c6ea520fcbcb58f74b7dc3ab8c5d0f8e505e445
--- src/cmd/page/rotate.c
+++ src/cmd/page/rotate.c
/*
* rotate an image 180° in O(log Dx + log Dy) /dev/draw writes,
* using an extra buffer same size as the image.
- *
+ *
* the basic concept is that you can invert an array by inverting
* the top half, inverting the bottom half, and then swapping them.
* the code does this slightly backwards to ensure O(log n) runtime.
* (If you do it wrong, you can get O(log² n) runtime.)
- *
+ *
* This is usually overkill, but it speeds up slow remote
* connections quite a bit.
*/
snprint(buf, sizeof buf, "%d%s%d", c++, name, gran);
fd = create(buf, OWRITE, 0666);
if(fd < 0)
- return;
+ return;
writeimage(fd, im, 0);
close(fd);
}
/*
* Halve the grating period in the mask.
- * The grating currently looks like
+ * The grating currently looks like
* ####____####____####____####____
* where #### is opacity.
*
* ##__##__##__##__##__##__##__##__
* which is achieved by shifting the mask
* and drawing on itself through itself.
- * Draw doesn't actually allow this, so
+ * Draw doesn't actually allow this, so
* we have to copy it first.
*
* ####____####____####____####____ (dst)
interlace(im, tmp, axis, nn, mask, gran);
// writefile("interlace", im, gran);
-
+
gran = nextmask(mask, axis, gran);
shuffle(im, tmp, axis, n, mask, gran, nn);
// writefile("shuffle", im, gran);
return f;
}
-/*
+/*
* i0(x) is the modified Bessel function, Σ (x/2)^2L / (L!)²
* There are faster ways to calculate this, but we precompute
* into a table so let's keep it simple.
blob - f10ef6db3a681a0a9048b1931c4496d7cb650777
blob + 3b4655d1fc3b8bb48222bcde6d59bf4f9e10c701
--- src/cmd/page/util.c
+++ src/cmd/page/util.c
{
uchar buf[8192];
int fd, n;
-
+
strcpy(tempfile, "/tmp/pagespoolXXXXXXXXX");
fd = opentemp(tempfile, ORDWR);
if(name)
arg = a;
if(pipe(p) < 0){
- fprint(2, "pipe fails: %r\n");
+ fprint(2, "pipe fails: %r\n");
wexits("pipe");
}
write(p[1], arg->ibuf, arg->in);
while((n = read(stdinfd, buf, sizeof buf)) > 0)
write(p[1], buf, n);
-
+
close(p[1]);
threadexits(0);
}
blob - 315a22a80c4196cd826f453643f9259db2556a63
blob + 2696f01fb8f81adb56ea3d2195f2b4ab0ad6fec4
--- src/cmd/page/view.c
+++ src/cmd/page/view.c
Cursor reading={
{-1, -1},
- {0xff, 0x80, 0xff, 0x80, 0xff, 0x00, 0xfe, 0x00,
- 0xff, 0x00, 0xff, 0x80, 0xff, 0xc0, 0xef, 0xe0,
- 0xc7, 0xf0, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xc0,
+ {0xff, 0x80, 0xff, 0x80, 0xff, 0x00, 0xfe, 0x00,
+ 0xff, 0x00, 0xff, 0x80, 0xff, 0xc0, 0xef, 0xe0,
+ 0xc7, 0xf0, 0x03, 0xf0, 0x01, 0xe0, 0x00, 0xc0,
0x03, 0xff, 0x03, 0xff, 0x03, 0xff, 0x03, 0xff, },
- {0x00, 0x00, 0x7f, 0x00, 0x7e, 0x00, 0x7c, 0x00,
- 0x7e, 0x00, 0x7f, 0x00, 0x6f, 0x80, 0x47, 0xc0,
- 0x03, 0xe0, 0x01, 0xf0, 0x00, 0xe0, 0x00, 0x40,
+ {0x00, 0x00, 0x7f, 0x00, 0x7e, 0x00, 0x7c, 0x00,
+ 0x7e, 0x00, 0x7f, 0x00, 0x6f, 0x80, 0x47, 0xc0,
+ 0x03, 0xe0, 0x01, 0xf0, 0x00, 0xe0, 0x00, 0x40,
0x00, 0x00, 0x01, 0xb6, 0x01, 0xb6, 0x00, 0x00, }
};
Cursor query = {
{-7,-7},
- {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
- 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
- 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
+ {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
+ 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
+ 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
- {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
- 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
- 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
+ {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
+ 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
+ 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
};
USED(nil);
}
-int
+int
max(int a, int b)
{
return a > b ? a : b;
}
-int
+int
min(int a, int b)
{
return a < b ? a : b;
m->lasthit = 0; /* this page */
else
m->lasthit = reverse ? doc->npage-1-page : page;
-
+
setcursor(mc, &reading);
delayfreeimage(nil);
im = cachedpage(doc, angle, page);
q = basename;
if(p = strchr(q, '.'))
*p = 0;
-
+
memset(name, 0, sizeof name);
snprint(name, sizeof(name)-1, "%s.%d.bit", q, page+1);
if(access(name, 0) >= 0) {
Empty3,
Exit,
};
-
+
void
viewer(Document *dd)
{
"next",
"prev",
"zerox",
- "",
+ "",
"reverse",
"discard",
"write",
- "",
- "quit",
- 0
+ "",
+ "quit",
+ 0
};
char *s;
enum {
};
Alt alts[CN+1];
Plumbmsg *pm;
-
+
cp = chancreate(sizeof pm, 0);
assert(cp);
setcursor(mc, &query);
sleep(1000);
setcursor(mc, nil);
- break;
+ break;
}
break;
xy0 = oxy;
do {
dxy = subpt(m.xy, oxy);
- oxy = m.xy;
+ oxy = m.xy;
translate(dxy);
recv(mc->c, &m);
} while(m.buttons == Left);
translate(dxy);
}
break;
-
+
case Middle:
if(doc->npage == 0)
break;
if((page >= doc->npage) && !doc->fwdonly)
return;
-
+
showpage(page, &menu);
nxt = 0;
break;
if((page >= doc->npage) && !doc->fwdonly && !reverse)
return;
-
+
showpage(page, &menu);
nxt = 0;
break;
showpage(page, &menu);
}
break;
- }
+ }
else{ /* image */
double delta;
Rectangle r;
delta = (double)Dy(im->r)/(double)Dy(r);
setcursor(mc, &reading);
- tmp = xallocimage(display,
- Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta)),
+ tmp = xallocimage(display,
+ Rect(0, 0, (int)((double)Dx(im->r)*delta), (int)((double)Dy(im->r)*delta)),
im->chan, 0, DBlack);
if(tmp == nil) {
fprint(2, "out of memory during zoom: %r\n");
break;
reverse = !reverse;
menu.lasthit = doc->npage-1-menu.lasthit;
-
+
if(page == 0 || page == doc->npage-1) {
page = doc->npage-1-page;
showpage(page, &menu);
case Empty3:
break;
- };
+ };
-
-
+
+
case Right:
if(doc->npage == 0)
break;
n = menuhit(RMenu, mc, &menu, nil);
if(n == -1)
break;
-
+
if(doc->fwdonly) {
switch(n){
case 0: /* this page */
}
break;
}
-
+
if(n == doc->npage)
return;
else
page = reverse ? doc->npage-1-n : n;
-
+
if(oldpage != page)
showpage(page, &menu);
nxt = 0;
* mp and sp get aligned with bot.min.
*/
static void
-gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
+gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
Image *src, Point sp, Image *mask, Point mp, int op)
{
Rectangle r;
}
}
border(screen, r, -4000, gray, ZP);
-// flushimage(display, 0);
+// flushimage(display, 0);
}
/* clip p to be in r */
}
/*
- * resize is perhaps a misnomer.
+ * resize is perhaps a misnomer.
* this really just grows the window to be at least dx across
* and dy high. if the window hits the bottom or right edge,
* it is backed up until it hits the top or left edge.
blob - 6645820c6bc5d57e0e27f27c31b47615804d0b21
blob + 6c84f2fb82806eee1af8a396667a8cd26ba9fa3d
--- src/cmd/paint/eenter.c
+++ src/cmd/paint/eenter.c
return n;
}
-
blob - 7dce3710cad3c4d09d6d4df54e43ac752542abff
blob + e7f502cf7b81ab1c6045d6e674bf64072fcdec9d
--- src/cmd/paint/paint.c
+++ src/cmd/paint/paint.c
* mp and sp get aligned with bot.min.
*/
static void
-gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
+gendrawdiff(Image *dst, Rectangle bot, Rectangle top,
Image *src, Point sp, Image *mask, Point mp, int op)
{
Rectangle r;
{
cpos = ZP;
if(canvas)
- cpos = addpt(canvas->r.min,
+ cpos = addpt(canvas->r.min,
divpt(subpt(canvas->r.max, canvas->r.min), 2));
spos = addpt(screen->r.min,
divpt(subpt(screen->r.max, screen->r.min), 2));
if(argc == 1)
filename = strdup(argv[0]);
else if(argc != 0)
- usage();
+ usage();
if(initdraw(0, 0, "paint") < 0)
sysfatal("initdraw: %r");
blob - 2e859f84874ca7ed564474e690df7a9734ecabba
blob + f4105bf3401a0688f086488b7ea3ab8b11730680
--- src/cmd/pbd.c
+++ src/cmd/pbd.c
}
write(1, p, strlen(p));
exits(0);
-}
+}
blob - bec41e47a7d930ec79bd12cdedfc421b2e876bd4
blob + 4cb16957be7b3e0785ebfd741fc366f7b0058aaf
--- src/cmd/pic/arcgen.c
+++ src/cmd/pic/arcgen.c
else if( x> 0.0 && y<=0.0) return(4);
else return 0; /* shut up lint */
}
-
blob - e0db5fc6c5502b902f5c259e9aafdbadcaa19a1f
blob + bc7e933515ecee88984552ec7b149b24c3f2025d
--- src/cmd/pic/linegen.c
+++ src/cmd/pic/linegen.c
extreme(ex, ey);
nx = xi; ny = yi;
}
-
+
}
p->o_ddval = ddval;
if (dbg) {
blob - e888fafc827612055d05f390f5eb05f21508489e
blob + 1e2db1b5218c4bf2d0dab056e2cd012c1833f4c2
--- src/cmd/pic/misc.c
+++ src/cmd/pic/misc.c
return 0;
}
-double
+double
getcomp(obj *p, int t) /* return component of a position */
{
switch (t) {
blob - 53337117c8f2d28deb1d827ed967ffe35a10c23a
blob + d4b6699fe1e6619b5c39792d1ad6d9673b534b93
--- src/cmd/plot/libplot/circ.c
+++ src/cmd/plot/libplot/circ.c
int rad;
p.x=SCX(xc);
p.y=SCY(yc);
- if (r < 0)
+ if (r < 0)
rad=SCR(-r);
else
rad=SCR(r);
blob - 47b39012b60ac3c51dd4a663cf63207e9239cab8
blob + 6255efa5ff254debe6756317d804623800ee1cc4
--- src/cmd/plot/libplot/disk.c
+++ src/cmd/plot/libplot/disk.c
int rad;
p.x=SCX(xc);
p.y=SCY(yc);
- if (r < 0)
+ if (r < 0)
rad=SCR(-r);
else
rad=SCR(r);
blob - 4e60260b6e76a8a8697d0d9371eb17644a66e278
blob + 11cdcfcb68c3944f578563e6a85e6f41e34d579e
--- src/cmd/plot/libplot/move.c
+++ src/cmd/plot/libplot/move.c
#include "mplot.h"
void move(double xx, double yy){
- e1->copyx = xx;
+ e1->copyx = xx;
e1->copyy = yy;
}
blob - 212b9c973beb37a1b07f37ee2fb9852b2dc570ef
blob + d8b5ffb20a4ac7fa57ec848636546ab70e0d5349
--- src/cmd/plot/libplot/parabola.c
+++ src/cmd/plot/libplot/parabola.c
double dt, d2, d1;
d1 = sqrt((xb - x0) * (xb - x0) + (yb - y0) * (yb - y0));
d2 = sqrt((xb - x1) * (xb - x1) + (yb - y1) * (yb - y1));
- if (d1 <= e1->quantum || d2 <= e1->quantum) {
- plotline(x0, y0, x1, y1);
- return;
+ if (d1 <= e1->quantum || d2 <= e1->quantum) {
+ plotline(x0, y0, x1, y1);
+ return;
}
- c0x = x0 + x1 - 2. * xb;
+ c0x = x0 + x1 - 2. * xb;
c1x = 2. * (xb - x0);
- c0y = y0 + y1 - 2. * yb;
+ c0y = y0 + y1 - 2. * yb;
c1y = 2. * (yb - y0);
move(x0, y0);
dt = e1->quantum / d1;
blob - 9fb8863d28ca60f812462d1a08182a19f59f2910
blob + 993a7b204d5cac469ed1d1fc1c24d43c2c5d30fa
--- src/cmd/plot/libplot/ppause.c
+++ src/cmd/plot/libplot/ppause.c
#include "mplot.h"
-void ppause(void){
- char aa[4];
- fflush(stdout);
- read(0, aa, 4);
- erase();
+void ppause(void){
+ char aa[4];
+ fflush(stdout);
+ read(0, aa, 4);
+ erase();
}
blob - 9c8ccf158dcde9e08e1bc4c4034a0b8b47b791ce
blob + c0c8c6b3a12096e4491b51411bf4967a368c0902
--- src/cmd/plot/libplot/rarc.c
+++ src/cmd/plot/libplot/rarc.c
dx = x1 - xc;
dy = y1 - yc;
rd = sqrt(dx * dx + dy * dy);
- if (rd / e1->quantum < 1.0) {
- move(xc, yc);
- vec(xc, yc);
+ if (rd / e1->quantum < 1.0) {
+ move(xc, yc);
+ vec(xc, yc);
return;
}
dph = acos(1.0 - (e1->quantum / rd));
- if (dph > PI4)
+ if (dph > PI4)
dph = PI4;
ph=atan2((y2-yc),(x2 - xc)) - atan2(dy, dx);
- if (ph < 0)
- ph += 6.2832;
- if (rr < 0)
+ if (ph < 0)
+ ph += 6.2832;
+ if (rr < 0)
ph = 6.2832 - ph;
- if (ph < dph)
+ if (ph < dph)
plotline(x1, y1, x2, y2);
else {
- n = ph / dph;
- a = cos(dph);
- b = sin(dph);
- if (rr < 0)
+ n = ph / dph;
+ a = cos(dph);
+ b = sin(dph);
+ if (rr < 0)
b = -b;
move(x1, y1);
while ((n--) >= 0) {
- xnext = dx * a - dy * b;
- dy = dx * b + dy * a;
+ xnext = dx * a - dy * b;
+ dy = dx * b + dy * a;
dx = xnext;
vec(dx + xc, dy + yc);
}
blob - e3dc4058f2b4e2a84cda8bfa7a35d4ba2def2c0f
blob + 0f12b63617e0561d9586afcc73e772f8802e0fda
--- src/cmd/plot/libplot/save.c
+++ src/cmd/plot/libplot/save.c
#include "mplot.h"
-void save(void){
- sscpy(e1, e1 + 1);
- e1++;
+void save(void){
+ sscpy(e1, e1 + 1);
+ e1++;
}
blob - 8cfa83d7a0c93a5be543aee2815fdf2868995c47
blob + 6001bd726f4f785f363c4cb5f12c1e3f42a1ecfa
--- src/cmd/plot/libplot/spline.c
+++ src/cmd/plot/libplot/spline.c
np = num;
fp = ff;
while((n = *np++)){
- xp = *fp++;
- yp = xp + 1;
- xp0 = xp;
+ xp = *fp++;
+ yp = xp + 1;
+ xp0 = xp;
yp0 = yp;
- xpe = xp0 + 2 * (n - 1);
+ xpe = xp0 + 2 * (n - 1);
ype = yp0 + 2 * (n - 1);
- if (n < 3) {
- plotline(*xp, *yp, *(xp + 2), *(yp + 2));
+ if (n < 3) {
+ plotline(*xp, *yp, *(xp + 2), *(yp + 2));
continue;
}
if (mode == 4) { /*closed curve*/
- xa = 0.5 * (*xpe + *(xpe - 2));
+ xa = 0.5 * (*xpe + *(xpe - 2));
xc = 0.5 * (*xpe + *xp0);
- ya = 0.5 * (*ype + *(ype - 2));
+ ya = 0.5 * (*ype + *(ype - 2));
yc = 0.5 * (*ype + *yp0);
parabola(xa, ya, xc, yc, *xpe, *ype);
- xa = 0.5 * (*xpe + *xp0);
+ xa = 0.5 * (*xpe + *xp0);
xc = 0.5 * (*(xp0 + 2) + *xp0);
- ya = 0.5 * (*ype + *yp0);
+ ya = 0.5 * (*ype + *yp0);
yc = 0.5 * (*(yp0 + 2) + *yp0);
parabola(xa, ya, xc, yc, *xp0, *yp0);
}
if (mode % 2) /*odd mode makes first point double*/
plotline(*xp0,*yp0,0.5*(*xp0+*(xp0+2)),0.5*(*yp0+*(yp0+2)));
}
- xp += 2;
+ xp += 2;
yp += 2;
for (i = 1; i < (n - 1); i++, xp += 2, yp += 2) {
- xa = 0.5 * (*(xp - 2) + *xp);
+ xa = 0.5 * (*(xp - 2) + *xp);
xc = 0.5 * ( *xp + *(xp + 2));
- ya = 0.5 * (*(yp - 2) + *yp);
+ ya = 0.5 * (*(yp - 2) + *yp);
yc = 0.5 * ( *yp + *(yp + 2));
parabola(xa, ya, xc, yc, *xp, *yp);
}
blob - 2b41990d4a807869e93f612b0b77412b477826c6
blob + 62333edfd885da297752a01b250654939bdd5c66
--- src/cmd/plot/libplot/subr.c
+++ src/cmd/plot/libplot/subr.c
return(DBlack);
case 'r':
return(DRed);
- case 'g':
+ case 'g':
return(DGreen);
- case 'b':
+ case 'b':
return(DBlue);
- case 'm':
+ case 'm':
return(DMagenta);
- case 'y':
+ case 'y':
return(DYellow);
- case 'c':
+ case 'c':
return(DCyan);
- case 'w':
+ case 'w':
return(DWhite);
- case 'R':
+ case 'R':
return(atoi(s + 1));
- case 'G':
- e1->pgap = atof(s + 1);
+ case 'G':
+ e1->pgap = atof(s + 1);
return(-1);
- case 'A':
- e1->pslant = (180. - atof(s + 1)) / RADIAN;
+ case 'A':
+ e1->pslant = (180. - atof(s + 1)) / RADIAN;
return(-1);
}
- while (*++s != 0)
+ while (*++s != 0)
if (*s == '/') {
s++;
break;
return DBlack;
}
void sscpy(struct penvir *a, struct penvir *b){ /* copy 'a' onto 'b' */
- b->left = a->left;
- b->bottom = a->bottom;
- b->xmin = a->xmin;
+ b->left = a->left;
+ b->bottom = a->bottom;
+ b->xmin = a->xmin;
b->ymin = a->ymin;
- b->scalex = a->scalex;
+ b->scalex = a->scalex;
b->scaley = a->scaley;
- b->sidex = a->sidex;
+ b->sidex = a->sidex;
b->sidey = a->sidey;
- b->copyx = a->copyx;
+ b->copyx = a->copyx;
b->copyy = a->copyy;
b->quantum = a->quantum;
b->grade = a->grade;
- b->pmode = a->pmode;
- b->foregr = a->foregr;
+ b->pmode = a->pmode;
+ b->foregr = a->foregr;
b->backgr = a->backgr;
}
void idle(void){}
blob - 8b62387bb5ccbcc3c25d785eb9e856e62c87f186
blob + f87e228bd13fc6a26deb06b23cb9dd5439c49c05
--- src/cmd/plot/plot.c
+++ src/cmd/plot/plot.c
exits("undefined");
}
*ap = sav;
- while (isspace((uchar)*ap) || *ap == ',')
+ while (isspace((uchar)*ap) || *ap == ',')
ap++;
if (*ap != '\0')
SC = atof(ap);
blob - 5a4cd88cef1ec5a8b2d458e933f427ae0df8fbce
blob + 13ebe768f7d1b89469e1be562fd1cc9d0428aeed
--- src/cmd/plumb/match.c
+++ src/cmd/plumb/match.c
newexec(Plumbmsg *m)
{
Exec *exec;
-
+
exec = emalloc(sizeof(Exec));
exec->msg = m;
exec->p0 = -1;
else
prev->next = a->next;
free(a->name);
- free(a->value);
+ free(a->value);
free(a);
break;
}
blob - b6807a4d102cd78628bf2fa62aa0faa4c0abd121
blob + 2dc55cbb46be2c04b6b38c4d638190214af41e17
--- src/cmd/postscript/common/bbox.c
+++ src/cmd/postscript/common/bbox.c
} /* End of concat */
/*****************************************************************************/
-
blob - 6b409cad163e520b4c607d971b45aa2d7cbc10ee
blob + 0bbf5902070e8661093a1011df83749d4e76b574
--- src/cmd/postscript/common/comments.h
+++ src/cmd/postscript/common/comments.h
#define ENDPAGE "%%EndPage:"
#define FORMSPERPAGE "%%FormsPerPage:"
#define VERSION "%%Version:"
-
blob - f49f6f1fda8dab462211b09ee244f914687e1c9b
blob + 7b26766885a6e992d471074af0f8075a267369ac
--- src/cmd/postscript/common/common.h
+++ src/cmd/postscript/common/common.h
void pagelist(char *);
int safe_tmpnam(char*);
-
blob - 77635b6b5fc471685c4e2e336e8181b8cf65a97b
blob + 75bea5b5517b440a7b613753ce2057a6c8bd983d
--- src/cmd/postscript/common/ext.h
+++ src/cmd/postscript/common/ext.h
extern int cat(char*);
extern void concat(double*);
-/*
+/*
* extern char *tempnam(char*,char*);
* extern char *malloc();
* extern char *calloc();
blob - dffeb957861c0424a0191bb69a3a00c35bac1bc3
blob + 1553c2c46d2fc8b093dbad339f9c96d7f6725e65
--- src/cmd/postscript/common/gen.h
+++ src/cmd/postscript/common/gen.h
#define ABS(A) ((A) >= 0 ? (A) : -(A))
#define MIN(A, B) ((A) < (B) ? (A) : (B))
#define MAX(A, B) ((A) > (B) ? (A) : (B))
-
blob - 2826f4e5fe9f21d7e5e545c93d7c0b20892bdf64
blob + 31de6b4d4808add02af524278873410bf3de56b7
--- src/cmd/postscript/common/glob.c
+++ src/cmd/postscript/common/glob.c
int reading = UTFENCODING; /* input */
int writing = WRITING; /* and output encoding */
-
blob - 28120ea5d8fa9ed24ae39a68ad67258680067c52
blob + 81444465a7c5f2930d885c9cee802b3578ff8480
--- src/cmd/postscript/common/misc.c
+++ src/cmd/postscript/common/misc.c
} /* End of interrupt */
/*****************************************************************************/
-
blob - f2019c1e4908b0db47c33c9591a5b9c42798949d
blob + 6e456bb26d1c26ccefa8bb6e52d1738fec15d582
--- src/cmd/postscript/common/path.h
+++ src/cmd/postscript/common/path.h
#define FONTDIR "#9/troff/font"
#define POSTLIBDIR "#9/postscript/prologues"
#define TEMPDIR "/var/tmp"
-
blob - ba956d574f02f33512244a1b54ced6433fc9b182
blob + 2e96093ba65cc70ea9d0b585e5649b38a7b6319f
--- src/cmd/postscript/common/request.c
+++ src/cmd/postscript/common/request.c
} /* End of dumprequest */
/*****************************************************************************/
-
blob - 25d94d01a1a26c8acab131e700a41ee6c79b5c08
blob + 6898ffd0433d7ec4c3bcb9f3b6e9dc666508159e
--- src/cmd/postscript/common/request.h
+++ src/cmd/postscript/common/request.h
int page;
char *file;
} Request;
-
blob - 31aa1b3bfb46a8bcc23c269ab121850bafd48571
blob + 4c8f6ffb799f52f41514a52a719bef67fdf9a721
--- src/cmd/postscript/download/download.c
+++ src/cmd/postscript/download/download.c
} /* End of allocate */
/*****************************************************************************/
-
blob - f88cc57ad9be1cbeb5a5e49e9149625c05765934
blob + 3e8ac6ff0bbb319c774f5e607643676bdf49dba1
--- src/cmd/postscript/download/download.h
+++ src/cmd/postscript/download/download.h
} Map;
Map *allocate();
-
blob - 49736d6f0eaea8c0c1148852039096ac2904a705
blob + 99d2f64c14e5a55b60b6c8a1bdbd0f38644d3263
--- src/cmd/postscript/misc/ibmfont.c
+++ src/cmd/postscript/misc/ibmfont.c
*
* where font.ibm is the font file, exactly as it came over from an IBM PC,
* and font.unix is equivalent host resident font file usable on Unix systems.
- *
+ *
*/
#include <stdio.h>
ch = '\n';
putc(ch, fp_out);
} /* End for */
-
+
} /* End of asciitext */
/*****************************************************************************/
if ( (++n % 40) == 0 )
putc('\n', fp_out);
} /* End for */
-
+
} /* End of hexdata */
/*****************************************************************************/
return(val);
-} /* End of getint */
+} /* End of getint */
/*****************************************************************************/
} /* End of error */
/*****************************************************************************/
-
blob - 7b45e667a16740d81d23717d063cfb59122ed26b
blob + 7818fc1d445934c0b888579e4dca1eb3e12e644d
--- src/cmd/postscript/misc/laserbar.c
+++ src/cmd/postscript/misc/laserbar.c
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
/* sp ! " # $ % & ' */
- 0304, 0, 0, 0, 0250, 0052, 0, 0,
+ 0304, 0, 0, 0, 0250, 0052, 0, 0,
/* ( ) * + , - - / */
0, 0, 0224, 0212, 0, 0205, 0604, 0242,
/* 0 1 2 3 4 5 6 7 */
0064, 0441, 0141, 0540, 0061, 0460, 0160, 0045,
/* 8 9 : ; < = > ? */
- 0444, 0144, 0, 0, 0, 0, 0, 0,
+ 0444, 0144, 0, 0, 0, 0, 0, 0,
/* @ A B C D E F G */
0, 0411, 0111, 0510, 0031, 0430, 0130, 0015,
/* H I J K L M N O */
blob - 59244a1922d6039c81596b6e8f8cc00a4e3ffe56
blob + d0c9cb78103985d5c0a9412a74f0917b01cb577f
--- src/cmd/postscript/misc/macfont.c
+++ src/cmd/postscript/misc/macfont.c
*
* where font.mac is the font file, exactly as it came over from a Macintosh,
* and font.unix is equivalent host resident font file usable on Unix systems.
- *
+ *
*/
#include <stdio.h>
ch = '\n';
putc(ch, fp_out);
} /* End for */
-
+
} /* End of asciitext */
/*****************************************************************************/
if ( (++n % 40) == 0 )
putc('\n', fp_out);
} /* End for */
-
+
} /* End of hexdata */
/*****************************************************************************/
return(val);
-} /* End of getint */
+} /* End of getint */
/*****************************************************************************/
} /* End of error */
/*****************************************************************************/
-
blob - 1715288ba6559453416f39f6bf47af3bac700c35
blob + 520daf331d3692724f0c9911fe2a0f90601213b3
--- src/cmd/postscript/misc/pscrypt.c
+++ src/cmd/postscript/misc/pscrypt.c
} /* End of Getc */
/*****************************************************************************/
-
blob - d99124d58c76072bc62397f2718fe030a0a4d242
blob + 5631052095fbd4c9b6203c447686c4aea79caa37
--- src/cmd/postscript/postreverse/postreverse.c
+++ src/cmd/postscript/postreverse/postreverse.c
* up being copied to the output file and FALSE will be returned to the caller.
* The first call (made from reverse()) looks for ENDPROLOG. Any other call comes
* from readpages() and will be looking for the ENDSETUP comment.
- *
+ *
*/
len = strlen(FORMSPERPAGE);
} /* End of trailer */
/*****************************************************************************/
-
blob - edae7a277d3a5f883f6a9f1648e2369746d6503f
blob + a78ff4e8bdf7fbd96005dadcb6008b6281aa8226
--- src/cmd/postscript/postreverse/postreverse.h
+++ src/cmd/postscript/postreverse/postreverse.h
*/
char *copystdin();
-
blob - 5e49e55efadd6c0fef35ace3442e9535de0e059d
blob + f9fbfd7696a4e38edf0e5a19b8a844c44b51afcb
--- src/cmd/postscript/tr2post/Bgetfield.c
+++ src/cmd/postscript/tr2post/Bgetfield.c
do {
r = Bgetrune(bp);
if (r == '\n') inputlineno++;
- sindex++;
+ sindex++;
} while (r>=0 && isspace(r));
if (r<0) {
return(-1);
}
/* get a string of type: "d" for decimal integer, "u" for unsigned,
- * "s" for string", "c" for char,
+ * "s" for string", "c" for char,
* return the number of characters gotten for the field. If nothing
* was gotten and the end of file was reached, a negative value
* from the Bgetrune is returned.
case '0':
base = 8;
continue;
- default:
+ default:
break;
}
break;
continue;
}
}
- if ((dig = asc2dig(r, base)) == -1) bailout = TRUE;
+ if ((dig = asc2dig(r, base)) == -1) bailout = TRUE;
else n = dig + (n * base);
}
if (r < 0) return(-1);
continue;
}
}
- if ((dig = asc2dig(r, base)) == -1) bailout = TRUE;
+ if ((dig = asc2dig(r, base)) == -1) bailout = TRUE;
else u = dig + (n * base);
}
*(int *)thing = u;
blob - 11d1ae85b179e852f4d3f3992942c49fbd327431
blob + 4b4f4ef003d267860359bed864bd247dda3aff35
--- src/cmd/postscript/tr2post/chartab.c
+++ src/cmd/postscript/tr2post/chartab.c
if (*cp == 0) *cp = galloc(0, sizeof(struct charent), "readtroffmetric:charent");
(*cp)->postfontid = thisfont;
- (*cp)->postcharid = thischar;
+ (*cp)->postcharid = thischar;
(*cp)->troffcharwidth = ntoken;
(*cp)->name = galloc(0, 2, "readtroffmetric: char name");
(*cp)->next = 0;
line++;
break;
}
- if (!errorflg) {
+ if (!errorflg) {
line++;
}
} while(!errorflg && rv>=0);
}
if (*cp == 0) *cp = galloc(0, sizeof(struct charent), "readtroffmetric:charent");
(*cp)->postfontid = RUNEGETGROUP(charnum);
- (*cp)->postcharid = RUNEGETCHAR(charnum);
+ (*cp)->postcharid = RUNEGETCHAR(charnum);
(*cp)->troffcharwidth = width;
(*cp)->name = galloc(0, strlen(stoken)+1, "readtroffmetric: char name");
(*cp)->next = 0;
blob - f0a9800a027314835aa4868111bf8bc919d642f9
blob + ad3abbaf9f1af1932004bf5b7d8a7b63ecdb9b50
--- src/cmd/postscript/tr2post/devcntl.c
+++ src/cmd/postscript/tr2post/devcntl.c
while ((c = Bgetc(inp)) != '\n' && c != Beof);
inputlineno++;
}
-
blob - a7f6b2236b62d73193d717dcd4feef07d867098c
blob + b8bda78d389c664c8dd067a1dabeaf754ec5ef1b
--- src/cmd/postscript/tr2post/draw.c
+++ src/cmd/postscript/tr2post/draw.c
* was expected to be legitimate PostScript that manipulated the current path.
* The old escape sequence will be supported for a while (for Ravi), and always
* call this routine with copy set to TRUE.
- *
+ *
*
*/
blob - 366bae70a56b3768b04ca2e70ea9688dd2af1303
blob + 90b7b88255679ccc32e43699cb89c4df6399fddb
--- src/cmd/postscript/tr2post/readDESC.c
+++ src/cmd/postscript/tr2post/readDESC.c
printdesclang=galloc(printdesclang, strlen(token)+1, "readdesc:");
strcpy(printdesclang, token);
if (debug) Bprint(Bstderr, "PDL %s\n", token);
- break;
+ break;
case 1:
encoding=galloc(encoding, strlen(token)+1, "readdesc:");
strcpy(encoding, token);
}
fontmnt = atoi(token) + 1;
fontmtab = galloc(fontmtab, fontmnt*sizeof(char *), "readdesc:");
-
+
for (i=0; i<fontmnt; i++)
fontmtab[i] = 0;
fontindex = 0;
blob - 5ca1b3286a85414858ecbcadcaf32d9a39343689
blob + 3f28e8d56f30135736719520ad2ce33302cccade
--- src/cmd/postscript/tr2post/tr2post.c
+++ src/cmd/postscript/tr2post/tr2post.c
}
atexit(cleanup);
Bstdout = bstdout; /* &bstdout->Biobufhdr; */
-
+
ARGBEGIN{
case 'a': /* aspect ratio */
aspectratio = atof(ARGF());
exits("read");
}
finish();
-
+
exits("");
return 0;
}
blob - f914a1c87209b1be3835b5fd7f2a57ff6866d37c
blob + 7f00dbd4d2966de5afba307a09591306a4287584
--- src/cmd/postscript/tr2post/utils.c
+++ src/cmd/postscript/tr2post/utils.c
if (delta == troffontab[curtrofffontid].spacewidth*fontsize/10 && isinstring()) {
if (pageon()) runeout(' ');
} else {
- if (pageon()) {
+ if (pageon()) {
endstring();
/* Bprint(Bstdout, " %d 0 rmoveto ", delta); */
/* Bprint(Bstdout, " %d %d m ", hpos+x, vpos); */
if (*cp != 0) goto foundit;
}
}
-
+
if (*cp == 0) {
error(WARNING, "cannot find glyph, rune=0x%x stoken=<%s> troff font %s\n", rune, stoken,
troffontab[curtrofffontid].trfontid);
Bprint(Bstderr, "runeout(0x%x)<%C> postfontid=0x%x postcharid=0x%x troffcharwidth=%d\n",
rune, rune, (*cp)->postfontid, (*cp)->postcharid, (*cp)->troffcharwidth);
}
-
+
tfp = &(troffontab[fontid]);
for (i=0; i<tfp->psfmapsize; i++) {
psfp = &(tfp->psfmap[i]);
blob - d930f34c5f5a5eb867b67386f831fa15b4930628
blob + 5cd686237aac4ef01d1537da956f87651bdab0fb
--- src/cmd/proof/font.c
+++ src/cmd/proof/font.c
string(screen, p, display->black, ZP, f, s);
}
-static int drawlog2[] = {
- 0, 0,
- 1, 1,
- 2, 2, 2, 2,
- 3, 3, 3, 3, 3, 3, 3, 3,
- 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
+static int drawlog2[] = {
+ 0, 0,
+ 1, 1,
+ 2, 2, 2, 2,
+ 3, 3, 3, 3, 3, 3, 3, 3,
+ 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,
5
};
blob - d591d38467e5219a08d66e03bd34ac07cd33f718
blob + c12fe91eda6708c5639afa3314d5216c71c4a0a0
--- src/cmd/proof/htroff.c
+++ src/cmd/proof/htroff.c
static void
spline(Image *b, int n, Point *pp)
{
- long w, t1, t2, t3, fac=1000;
- int i, j, steps=10;
+ long w, t1, t2, t3, fac=1000;
+ int i, j, steps=10;
Point p, q;
for (i = n; i > 0; i--)
t2 = 3*fac/4 - w * w / fac;
w = w - fac/2;
t3 = w * w / (2*fac);
- q.x = (t1*pp[i+2].x + t2*pp[i+1].x +
+ q.x = (t1*pp[i+2].x + t2*pp[i+1].x +
t3*pp[i].x + fac/2) / fac;
- q.y = (t1*pp[i+2].y + t2*pp[i+1].y +
+ q.y = (t1*pp[i+2].y + t2*pp[i+1].y +
t3*pp[i].y + fac/2) / fac;
line(b, p, q, 0, 0, 0, display->black, ZP);
p = q;
blob - 5e0c804c20edb0700cce981e2fbca0e7b56dee1c
blob + e8c18f873754ea109080d21dad68f8a906991aa5
--- src/cmd/proof/main.c
+++ src/cmd/proof/main.c
{
char c;
int dotrack = 0;
-
+
libfont = unsharp(libfont);
ARGBEGIN{
case 'm': /* magnification */
loadfontname(c, "??");
mapscreen();
clearscreen();
- readpage();
+ readpage();
}
/*
blob - 6e00c894b9d001cce3e1c7572d3c8b0e5f8a286e
blob + 42a38e81108293cad8876eb475d7f2deeba95ca6
--- src/cmd/ramfs.c
+++ src/cmd/ramfs.c
fprint(2, "usage: %s [-is] [-m mountpoint]\n", argv0);
exits("usage");
}
-
blob - 03c96d4901e4fbce44d44f51eeaf7d1bc3a25f1b
blob + 172acfa3e008063edfbfa1a72ea424cdf0e07ae1
--- src/cmd/rc/exec.c
+++ src/cmd/rc/exec.c
code bootstrap[32];
char num[12], *rcmain;
int i;
-
+
/* needed for rcmain later */
putenv("PLAN9", unsharp("#9"));
copynwords(word *a, word *tail, int n)
{
word *v, **end;
-
+
v = 0;
end = &v;
while(n-- > 0){
blob - dc0ca2e88c7f1cec38f58894298652481307a682
blob + 63f83354d3509a3e541cff3708c13e747c141b20
--- src/cmd/rc/havefork.c
+++ src/cmd/rc/havefork.c
* ssh foo & will reopen /dev/tty, try to read a password,
* get a signal, and repeat, in a tight loop, forever.
* Arguably this is a bug in ssh (it behaves the same
- * way under bash as under rc) but I'm fixing it here
+ * way under bash as under rc) but I'm fixing it here
* anyway. If we dissociate the process from the tty,
* then it won't be able to open /dev/tty ever again.
* The SIG_IGN on SIGTTOU makes writing the tty
- * (via fd 1 or 2, for example) succeed even though
+ * (via fd 1 or 2, for example) succeed even though
* our pgrp is not the terminal's controlling pgrp.
*/
if((tty = open("/dev/tty", OREAD)) >= 0){
blob - d9369e5c493048cce062f50e2df1f7b2a6002af6
blob + 973ddee8d97485511025a8935009508f695dbf20
--- src/cmd/rc/lex.c
+++ src/cmd/rc/lex.c
}
/*
* read a character from the input stream
- */
+ */
int
getnext(void)
blob - da9d8679e6794bb6c9040291681aa800139090ac
blob + d52def7d0fa51d73111d732db413766656170bec
--- src/cmd/rc/plan9ish.c
+++ src/cmd/rc/plan9ish.c
}
*ep=0;
qsort((char *)env, nvar, sizeof ep[0], cmpenv);
- return env;
+ return env;
}
void Updenv(void){}
void Execute(word *args, word *path)
exitcode(char *msg)
{
int n;
-
+
n = atoi(msg);
if(n == 0)
n = 1;
delwaitpid(int pid)
{
int r, w;
-
+
for(r=w=0; r<nwaitpids; r++)
if(waitpids[r] != pid)
waitpids[w++] = waitpids[r];
havewaitpid(int pid)
{
int i;
-
+
for(i=0; i<nwaitpids; i++)
if(waitpids[i] == pid)
return 1;
blob - 897597e286bfb90b6c03c128e14d044cb5732d63
blob + 2c3ff6bc715d44bcd3b22452ae1cdde7e956d1d9
--- src/cmd/rc/tree.c
+++ src/cmd/rc/tree.c
freetree(tree *p)
{
if(p==0)
- return;
+ return;
freetree(p->child[0]);
freetree(p->child[1]);
freetree(p->child[2]);
blob - f0f8397f084e0941d0e8c38501717796080a75f9
blob + d9c4a182d15a13abb52ad6293e7616ef48fdd6de
--- src/cmd/readcons.c
+++ src/cmd/readcons.c
{
char *def, *p;
int secret;
-
+
def = nil;
secret = 0;
ARGBEGIN{
default:
usage();
}ARGEND
-
+
if(argc != 1)
usage();
print("%s\n", p);
exits(0);
}
-
blob - d3208419572986e0139cdb1b07d84ea78f010453 (mode 755)
blob + b882b826ad661bb434bcac481619b0d3960c3367 (mode 644)
--- src/cmd/resample.c
+++ src/cmd/resample.c
return f;
}
-/*
+/*
* i0(x) is the modified Bessel function, Σ (x/2)^2L / (L!)²
* There are faster ways to calculate this, but we precompute
* into a table so let's keep it simple.
blob - c3b36df1a2c1180ba174c58d5ad2b55025678f24
blob + 256261cad639ee78aaac4348c2ca83c80a8232ae
--- src/cmd/rio/client.c
+++ src/cmd/rio/client.c
if(c->parent == c->screen->root)
return;
-
+
if(on){
XUngrabButton(dpy, AnyButton, AnyModifier, c->parent);
XSetInputFocus(dpy, c->window, RevertToPointerRoot, timestamp());
shuffle(int up)
{
Client **l, *c;
-
+
if(clients == 0 || clients->next == 0)
return;
if(!up){
/* top(clients); */
/* active(clients); */
}
-
blob - f1fff54c10ed124563b46d21258dc496547ff786
blob + 489c68e8504fc4ae121e06ba7792c4e4a1efce16
--- src/cmd/rio/color.c
+++ src/cmd/rio/color.c
return rgb;
}
}
-
blob - 33f635224435331e1b3f669aa33cb738df6ba9dd
blob + 3aff91bbc1a9dd21a253ffc27bcb5e1bde1fa270
--- src/cmd/rio/cursor.c
+++ src/cmd/rio/cursor.c
Cursordata bigarrow = {
16,
{0, 0},
- { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F,
- 0xFF, 0x0F, 0xFF, 0x0F, 0xFF, 0x1F, 0xFF, 0x3F,
- 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F,
- 0xCF, 0x1F, 0x8F, 0x0F, 0x07, 0x07, 0x03, 0x02,
+ { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F,
+ 0xFF, 0x0F, 0xFF, 0x0F, 0xFF, 0x1F, 0xFF, 0x3F,
+ 0xFF, 0x7F, 0xFF, 0xFF, 0xFF, 0x7F, 0xFF, 0x3F,
+ 0xCF, 0x1F, 0x8F, 0x0F, 0x07, 0x07, 0x03, 0x02,
},
- { 0x00, 0x00, 0xFE, 0x7F, 0xFE, 0x3F, 0xFE, 0x0F,
- 0xFE, 0x07, 0xFE, 0x07, 0xFE, 0x0F, 0xFE, 0x1F,
- 0xFE, 0x3F, 0xFE, 0x7F, 0xFE, 0x3F, 0xCE, 0x1F,
- 0x86, 0x0F, 0x06, 0x07, 0x02, 0x02, 0x00, 0x00,
+ { 0x00, 0x00, 0xFE, 0x7F, 0xFE, 0x3F, 0xFE, 0x0F,
+ 0xFE, 0x07, 0xFE, 0x07, 0xFE, 0x0F, 0xFE, 0x1F,
+ 0xFE, 0x3F, 0xFE, 0x7F, 0xFE, 0x3F, 0xCE, 0x1F,
+ 0x86, 0x0F, 0x06, 0x07, 0x02, 0x02, 0x00, 0x00,
}
};
s->root_pixmap = XCreatePixmapFromBitmapData(dpy,
s->root, grey_bits, grey_width, grey_height,
s->black, s->white, s->depth);
-
+
s->bordcurs[BorderN] = XCreateFontCursor(dpy, 138);
s->bordcurs[BorderNNE] = XCreateFontCursor(dpy, 136);
s->bordcurs[BorderENE] = s->bordcurs[BorderNNE] ;
Cursor whitearrow = {
{0, 0},
- {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
- 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,
- 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
+ {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
+ 0xFF, 0xF0, 0xFF, 0xF0, 0xFF, 0xF8, 0xFF, 0xFC,
+ 0xFF, 0xFE, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0xFC,
0xF3, 0xF8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, },
- {0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,
- 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,
- 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,
+ {0xFF, 0xFF, 0xFF, 0xFF, 0xC0, 0x06, 0xC0, 0x1C,
+ 0xC0, 0x30, 0xC0, 0x30, 0xC0, 0x38, 0xC0, 0x1C,
+ 0xC0, 0x0E, 0xC0, 0x07, 0xCE, 0x0E, 0xDF, 0x1C,
0xD3, 0xB8, 0xF1, 0xF0, 0xE0, 0xE0, 0xC0, 0x40, }
};
Cursor query = {
{-7,-7},
- {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
- 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
- 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
+ {0x0f, 0xf0, 0x1f, 0xf8, 0x3f, 0xfc, 0x7f, 0xfe,
+ 0x7c, 0x7e, 0x78, 0x7e, 0x00, 0xfc, 0x01, 0xf8,
+ 0x03, 0xf0, 0x07, 0xe0, 0x07, 0xc0, 0x07, 0xc0,
0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, 0x07, 0xc0, },
- {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
- 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
- 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
+ {0x00, 0x00, 0x0f, 0xf0, 0x1f, 0xf8, 0x3c, 0x3c,
+ 0x38, 0x1c, 0x00, 0x3c, 0x00, 0x78, 0x00, 0xf0,
+ 0x01, 0xe0, 0x03, 0xc0, 0x03, 0x80, 0x03, 0x80,
0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
};
Cursor tl = {
{-4, -4},
- {0xfe, 0x00, 0x82, 0x00, 0x8c, 0x00, 0x87, 0xff,
- 0xa0, 0x01, 0xb0, 0x01, 0xd0, 0x01, 0x11, 0xff,
- 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ {0xfe, 0x00, 0x82, 0x00, 0x8c, 0x00, 0x87, 0xff,
+ 0xa0, 0x01, 0xb0, 0x01, 0xd0, 0x01, 0x11, 0xff,
+ 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x1f, 0x00, },
- {0x00, 0x00, 0x7c, 0x00, 0x70, 0x00, 0x78, 0x00,
- 0x5f, 0xfe, 0x4f, 0xfe, 0x0f, 0xfe, 0x0e, 0x00,
- 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ {0x00, 0x00, 0x7c, 0x00, 0x70, 0x00, 0x78, 0x00,
+ 0x5f, 0xfe, 0x4f, 0xfe, 0x0f, 0xfe, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x00, 0x00, }
};
Cursor t = {
{-7, -8},
- {0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x06, 0xc0,
- 0x1c, 0x70, 0x10, 0x10, 0x0c, 0x60, 0xfc, 0x7f,
- 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xff, 0xff,
+ {0x00, 0x00, 0x00, 0x00, 0x03, 0x80, 0x06, 0xc0,
+ 0x1c, 0x70, 0x10, 0x10, 0x0c, 0x60, 0xfc, 0x7f,
+ 0x80, 0x01, 0x80, 0x01, 0x80, 0x01, 0xff, 0xff,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, },
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
- 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80,
- 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+ 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80, 0x03, 0x80,
+ 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};
Cursor tr = {
{-11, -4},
- {0x00, 0x7f, 0x00, 0x41, 0x00, 0x31, 0xff, 0xe1,
- 0x80, 0x05, 0x80, 0x0d, 0x80, 0x0b, 0xff, 0x88,
- 0x00, 0x88, 0x0, 0x88, 0x00, 0x88, 0x00, 0x88,
+ {0x00, 0x7f, 0x00, 0x41, 0x00, 0x31, 0xff, 0xe1,
+ 0x80, 0x05, 0x80, 0x0d, 0x80, 0x0b, 0xff, 0x88,
+ 0x00, 0x88, 0x0, 0x88, 0x00, 0x88, 0x00, 0x88,
0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0xf8, },
- {0x00, 0x00, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x1e,
- 0x7f, 0xfa, 0x7f, 0xf2, 0x7f, 0xf0, 0x00, 0x70,
- 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ {0x00, 0x00, 0x00, 0x3e, 0x00, 0x0e, 0x00, 0x1e,
+ 0x7f, 0xfa, 0x7f, 0xf2, 0x7f, 0xf0, 0x00, 0x70,
+ 0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
0x00, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x00, }
};
Cursor r = {
{-8, -7},
- {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58,
- 0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02,
- 0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58,
+ {0x07, 0xc0, 0x04, 0x40, 0x04, 0x40, 0x04, 0x58,
+ 0x04, 0x68, 0x04, 0x6c, 0x04, 0x06, 0x04, 0x02,
+ 0x04, 0x06, 0x04, 0x6c, 0x04, 0x68, 0x04, 0x58,
0x04, 0x40, 0x04, 0x40, 0x04, 0x40, 0x07, 0xc0, },
- {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
- 0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc,
- 0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80,
+ {0x00, 0x00, 0x03, 0x80, 0x03, 0x80, 0x03, 0x80,
+ 0x03, 0x90, 0x03, 0x90, 0x03, 0xf8, 0x03, 0xfc,
+ 0x03, 0xf8, 0x03, 0x90, 0x03, 0x90, 0x03, 0x80,
0x03, 0x80, 0x03, 0x80, 0x03, 0x80, 0x00, 0x00, }
};
Cursor br = {
{-11, -11},
- {0x00, 0xf8, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
- 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
- 0xff, 0x88, 0x80, 0x0b, 0x80, 0x0d, 0x80, 0x05,
+ {0x00, 0xf8, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
+ 0x00, 0x88, 0x00, 0x88, 0x00, 0x88, 0x00, 0x88,
+ 0xff, 0x88, 0x80, 0x0b, 0x80, 0x0d, 0x80, 0x05,
0xff, 0xe1, 0x00, 0x31, 0x00, 0x41, 0x00, 0x7f, },
- {0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
- 0x0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
- 0x00, 0x70, 0x7f, 0xf0, 0x7f, 0xf2, 0x7f, 0xfa,
+ {0x00, 0x00, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ 0x0, 0x70, 0x00, 0x70, 0x00, 0x70, 0x00, 0x70,
+ 0x00, 0x70, 0x7f, 0xf0, 0x7f, 0xf2, 0x7f, 0xfa,
0x00, 0x1e, 0x00, 0x0e, 0x00, 0x3e, 0x00, 0x00, }
};
Cursor b = {
{-7, -7},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0xff, 0xff, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
- 0xfc, 0x7f, 0x0c, 0x60, 0x10, 0x10, 0x1c, 0x70,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0xff, 0xff, 0x80, 0x01, 0x80, 0x01, 0x80, 0x01,
+ 0xfc, 0x7f, 0x0c, 0x60, 0x10, 0x10, 0x1c, 0x70,
0x06, 0xc0, 0x03, 0x80, 0x00, 0x00, 0x00, 0x00, },
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
- 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe,
- 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x7f, 0xfe, 0x7f, 0xfe, 0x7f, 0xfe,
+ 0x03, 0x80, 0x03, 0x80, 0x0f, 0xe0, 0x03, 0x80,
0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, }
};
Cursor bl = {
{-4, -11},
- {0x1f, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
- 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
- 0x11, 0xff, 0xd0, 0x01, 0xb0, 0x01, 0xa0, 0x01,
+ {0x1f, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ 0x11, 0x00, 0x11, 0x00, 0x11, 0x00, 0x11, 0x00,
+ 0x11, 0xff, 0xd0, 0x01, 0xb0, 0x01, 0xa0, 0x01,
0x87, 0xff, 0x8c, 0x00, 0x82, 0x00, 0xfe, 0x00, },
- {0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
- 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
- 0x0e, 0x00, 0x0f, 0xfe, 0x4f, 0xfe, 0x5f, 0xfe,
+ {0x00, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00, 0x0e, 0x00,
+ 0x0e, 0x00, 0x0f, 0xfe, 0x4f, 0xfe, 0x5f, 0xfe,
0x78, 0x00, 0x70, 0x00, 0x7c, 0x00, 0x00, 0x0, }
};
Cursor l = {
{-7, -7},
- {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20,
- 0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20,
- 0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20,
+ {0x03, 0xe0, 0x02, 0x20, 0x02, 0x20, 0x1a, 0x20,
+ 0x16, 0x20, 0x36, 0x20, 0x60, 0x20, 0x40, 0x20,
+ 0x60, 0x20, 0x36, 0x20, 0x16, 0x20, 0x1a, 0x20,
0x02, 0x20, 0x02, 0x20, 0x02, 0x20, 0x03, 0xe0, },
- {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
- 0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0,
- 0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0,
+ {0x00, 0x00, 0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0,
+ 0x09, 0xc0, 0x09, 0xc0, 0x1f, 0xc0, 0x3f, 0xc0,
+ 0x1f, 0xc0, 0x09, 0xc0, 0x09, 0xc0, 0x01, 0xc0,
0x01, 0xc0, 0x01, 0xc0, 0x01, 0xc0, 0x00, 0x00, }
};
blob - 0420c2bdc8025703384b574a60dcb68126521d9f
blob + 0035cf34dbf7df0200b11f37fe4f082c04ce5d12
--- src/cmd/rio/event.c
+++ src/cmd/rio/event.c
mainloop(int shape_event)
{
XEvent ev;
-
+
for(;;){
getevent(&ev);
c->dy = e->height;
if(e->value_mask & CWBorderWidth)
c->border = e->border_width;
-
+
if(c->dx >= c->screen->width && c->dy >= c->screen->height)
c->border = 0;
else
blob - 5aff69c8134c2897e5d1ebaeb42c8532eabab311
blob + 85aa570c8ab64d741e432655c89e3c5833cc59c3
--- src/cmd/rio/grab.c
+++ src/cmd/rio/grab.c
c->dy = sy*(dy + 2*BORDER );
c->x = px;
c->y = py;
-
+
/* compensate position for size changed due to size hints */
if(spx)
c->x -= c->dx - rdx;
ScreenInfo *s;
if(debug) fprintf(stderr, "drawbound %d %dx%d+%d+%d\n", drawing, c->dx, c->dy, c->x, c->y);
-
+
s = c->screen;
x = c->x;
y = c->y;
XUnmapWindow(dpy, s->sweepwin);
return;
}
-
+
x += BORDER;
y += BORDER;
dx -= 2*BORDER;
blob - 5bac1735756dc4f40920786d44be5bf83c7364fc
blob + 40740b05456edcb6c95f637c68fc7354a45d478b
--- src/cmd/rio/key.c
+++ src/cmd/rio/key.c
shuffle(shift);
/* fprintf(stderr, "%sTab\n", shift ? "Back" : ""); */
}
-
blob - 4bf87852e79573958839127241cec5ed9a6a764c
blob + 1e0b3797152589c1e5198d766e93688a224de58f
--- src/cmd/rio/main.c
+++ src/cmd/rio/main.c
s->min_cmaps = MinCmapsOfScreen(ScreenOfDisplay(dpy, i));
s->depth = DefaultDepth(dpy, i);
- /*
+ /*
* Figure out underlying screen format.
*/
if(XMatchVisualInfo(dpy, i, 16, TrueColor, &xvi)
s->vis = DefaultVisual(dpy, i);
}
if(DefaultDepth(dpy, i) != s->depth){
- s->def_cmap = XCreateColormap(dpy, s->root, s->vis, AllocNone);
+ s->def_cmap = XCreateColormap(dpy, s->root, s->vis, AllocNone);
}
ds = DisplayString(dpy);
attr.cursor = s->arrow;
attr.event_mask = SubstructureRedirectMask
| SubstructureNotifyMask | ColormapChangeMask
- | ButtonPressMask | ButtonReleaseMask | PropertyChangeMask
+ | ButtonPressMask | ButtonReleaseMask | PropertyChangeMask
| KeyPressMask | EnterWindowMask;
mask = CWCursor|CWEventMask;
XChangeWindowAttributes(dpy, s->root, mask, &attr);
blob - dc23f1c3b046bc8f010229ed73c39eafed86a732
blob + e7a37c68681a530e115dec52c2b69a9db42c43f7
--- src/cmd/rio/menu.c
+++ src/cmd/rio/menu.c
0
};
-Menu b2menu =
+Menu b2menu =
{
b2items
};
e->x, e->y);
XTranslateCoordinates(dpy, e->window, s->root, e->x, e->y,
&e->x, &e->y, &dw);
- }
+ }
switch (e->button){
case Button1:
if(c){
XAllowEvents (dpy, ReplayPointer, curtime);
} else if((e->state&(ShiftMask|ControlMask))==(ShiftMask|ControlMask)){
menuhit(e, &egg);
- } else if(numvirtuals > 1 && (n = menuhit(e, &b2menu)) > -1)
+ } else if(numvirtuals > 1 && (n = menuhit(e, &b2menu)) > -1)
button2(n);
return;
case Button3:
int i;
for(i = 0; i < numhidden; i++)
- if(c == hiddenc[i])
+ if(c == hiddenc[i])
break;
if(i == numhidden){
XMapWindow(dpy, c->parent);
setstate(c, NormalState);
if(currents[virt] == c)
- active(c);
+ active(c);
}
}
}
void
initb2menu(int n)
-{
+{
b2items[n] = 0;
}
blob - 05cc5ad7b55f7aaf1e04d9669e6aeeb0b64569df
blob + 927ea85f864af7446e9f2a5df07717de8979f04d
--- src/cmd/rio/printevent.c
+++ src/cmd/rio/printevent.c
There are times during debugging when it would be real useful to be able to
-print the fields of an event in a human readable form. Too many times I found
-myself scrounging around in section 8 of the Xlib manual looking for the valid
-fields for the events I wanted to see, then adding printf's to display the
+print the fields of an event in a human readable form. Too many times I found
+myself scrounging around in section 8 of the Xlib manual looking for the valid
+fields for the events I wanted to see, then adding printf's to display the
numeric values of the fields, and then scanning through X.h trying to decode
the cryptic detail and state fields. After playing with xev, I decided to
write a couple of standard functions that I could keep in a library and call
they need them.
A simple, sample program is included which does little else but to demonstrate
-the use of these two functions. These functions have saved me many an hour
+the use of these two functions. These functions have saved me many an hour
during debugging and I hope you find some benefit to these. If you have any
-comments, suggestions, improvements, or if you find any blithering errors you
+comments, suggestions, improvements, or if you find any blithering errors you
can get it touch with me at the following location:
ken@richsun.UUCP
if(0)
sprintf(buffer, "%lu day%s %02lu:%02lu:%02lu.%03lu",
day, day == 1 ? "" : "(s)", hr, min, sec, msec);
-
+
sprintf(buffer, "%lud%luh%lum%lu.%03lds", day, hr, min, sec, msec);
return (buffer);
}
char *eventtype(XEvent *ev)
{
static char buffer[20];
-
+
switch (ev->type) {
case KeyPress:
return ("KeyPress");
break;
}
}
-
blob - 7b22e970ef6e7a2c2473298cfcf3fe0d9dbef87c
blob + 9ad8c639068fc8479471bf758663681a9877d23c
--- src/cmd/rio/showevent/sample.c
+++ src/cmd/rio/showevent/sample.c
printf("\n\n");
}
}
-
blob - d42ddbabfe85a5d2c9c58dec3c424b4fedce0e59
blob + c4d368d8080fca28ba7cf6ea61c7fcadcdfc8407
--- src/cmd/rio/xevents.c
+++ src/cmd/rio/xevents.c
Display *dpy;
Window window;
XEvent event;
-
+
if (!(dpy = XOpenDisplay(""))) {
printf("Failed to open display...\n");
exit(1);
}
-
+
screen = DefaultScreen(dpy);
window = XCreateSimpleWindow(dpy, RootWindow(dpy, screen), 100, 100,
printevent(&event);
}
}
-
blob - 180eada41b49468bcc8407a6d09e97678fa07321
blob + e235874eb8b55bac8c89b32f984aeb972d38eabc
--- src/cmd/rio/xshove.c
+++ src/cmd/rio/xshove.c
main(int argc, char **argv)
{
int screen;
-
+
screen = 0;
ARGBEGIN{
case 's':
usage();
break;
}ARGEND
-
+
dpy = XOpenDisplay("");
if(dpy == nil)
sysfatal("open display: %r");
n = 100;
p = nil;
- XGetWindowProperty(dpy, w, a, 0, 100L, 0,
+ XGetWindowProperty(dpy, w, a, 0, 100L, 0,
AnyPropertyType, &type, &fmt,
&n, &dummy, &p);
if(p == nil || *p == 0)
w = mallocz(nxwin*sizeof w[0], 1);
if(w == 0)
sysfatal("malloc: %r");
-
+
Win *ww = w;
for(i=0; i<nxwin; i++){
memset(&attr, 0, sizeof attr);
ww++;
}
nw = ww - w;
-}
+}
void
listwindows(void)
char rect[50];
snprint(rect, sizeof rect, "%d,%d,%d,%d", ww->x, ww->y, ww->x+ww->dx, ww->y+ww->dy);
print("%08x %-20s %-10s %s\n",
- (uint)ww->xw,
+ (uint)ww->xw,
rect,
ww->instance,
ww->class);
blob - 12510689daf638433011cf7f481a585ad46f4024
blob + 386fe8d479dd70ecb8a50239407df79b99a31225
--- src/cmd/sam/cmd.c
+++ src/cmd/sam/cmd.c
if(nextc() == 'g')
cmd.flag = getch();
}
-
+
}
}
}
addr.num = getnum(1);
break;
case '0': case '1': case '2': case '3': case '4':
- case '5': case '6': case '7': case '8': case '9':
+ case '5': case '6': case '7': case '8': case '9':
addr.num = getnum(1);
addr.type='l';
break;
blob - d9dd42ac5b48de641499908eb8e73d9a4c43a9b0
blob + 2899f28ea7d853077171588110c7550b055e4d13
--- src/cmd/sam/mesg.c
+++ src/cmd/sam/mesg.c
invlong(void)
{
vlong v;
-
+
v = (inp[7]<<24) | (inp[6]<<16) | (inp[5]<<8) | inp[4];
v = (v<<16) | (inp[3]<<8) | inp[2];
v = (v<<16) | (inp[1]<<8) | inp[0];
outshort(int s)
{
*outp++ = s;
- *outp++ = s>>8;
+ *outp++ = s>>8;
}
void
blob - 234414998eaddd945b0a79a6cb5f198f7e121a4d
blob + 0acf861c818d4a1549a4847badcf75b2a142056e
--- src/cmd/sam/mesg.h
+++ src/cmd/sam/mesg.h
/*
* File transfer protocol schematic, a la Holzmann
* #define N 6
- *
+ *
* chan h = [4] of { mtype };
* chan t = [4] of { mtype };
- *
+ *
* mtype = { Hgrow, Hdata,
* Hcheck, Hcheck0,
* Trequest, Tcheck,
* };
- *
+ *
* active proctype host()
* { byte n;
- *
+ *
* do
* :: n < N -> n++; t!Hgrow
* :: n == N -> n++; t!Hcheck0
- *
+ *
* :: h?Trequest -> t!Hdata
* :: h?Tcheck -> t!Hcheck
* od
* }
- *
+ *
* active proctype term()
* {
* do
* From: gerard@research.bell-labs.com
* Date: Tue Jul 17 13:47:23 EDT 2001
* To: rob@research.bell-labs.com
- *
+ *
* spin -c (or -a) spec
* pcc -DNP -o pan pan.c
* pan -l
- *
+ *
* proves that there are no non-progress cycles
* (infinite executions *not* passing through
* the statement marked with a label starting
* with the prefix "progress")
- *
+ *
*/
blob - 94fad3e7e16fadb0360f9aef7479bf632b8f35f4
blob + 68207cd6fe647700c289aa118f4b4b492d1c0292
--- src/cmd/sam/moveto.c
+++ src/cmd/sam/moveto.c
while(--p >= 0 && alnum(filereadc(f, p)))
f->dot.r.p1--;
}
-
blob - d376acd0abc6ff518380fef76fe8d54eba199e9e
blob + f11586217489449d960d49fb84e5ded83836c574
--- src/cmd/sam/plumb.h
+++ src/cmd/sam/plumb.h
char *plumbpack(Plumbmsg *, int *);
int plumbfree(Plumbmsg *);
char *cleanname(char*);
-
blob - 0bce4141da124a761156c175593301ab0927d078
blob + c96101df6d44c301a4910815ed5a6dffe05cd0f1
--- src/cmd/sam/rasp.c
+++ src/cmd/sam/rasp.c
}
return rg;
}
-
blob - f180290bbe650cff628a8f8f4104d514e9568a87
blob + 84e015f51cc30ea3522feadfa1ebec866b7c0c05
--- src/cmd/sam/sam.c
+++ src/cmd/sam/sam.c
char **volatile argv;
String *t;
char *termargs[10], **ap;
-
+
argc = _argc;
argv = _argv;
ap = termargs;
blob - a745a5bc378990173de7cfc838cb1de06e82dd68
blob + 97f2fce81b1061e5b7dcafdc013d1b47414391d2
--- src/cmd/sam/unix.c
+++ src/cmd/sam/unix.c
#include "sam.h"
Rune samname[] = { '~', '~', 's', 'a', 'm', '~', '~', 0 };
-
+
static Rune l1[] = { '{', '[', '(', '<', 0253, 0};
static Rune l2[] = { '\n', 0};
static Rune l3[] = { '\'', '"', '`', 0};
return user;
}
-int
-statfile(char *name, ulong *dev, uvlong *id, long *time, long *length, long *appendonly)
+int
+statfile(char *name, ulong *dev, uvlong *id, long *time, long *length, long *appendonly)
{
struct stat dirb;
if (stat(name, &dirb) == -1)
return -1;
if (dev)
- *dev = dirb.st_dev;
+ *dev = dirb.st_dev;
if (id)
*id = dirb.st_ino;
if (time)
{
struct stat dirb;
- if (fstat(fd, &dirb) == -1)
+ if (fstat(fd, &dirb) == -1)
return -1;
if (dev)
*dev = dirb.st_dev;
- if (id)
+ if (id)
*id = dirb.st_ino;
if (time)
*time = dirb.st_mtime;
int fd = temp_file(buf, sizeof buf);
if (fd >= 0)
remove(buf);
- return fd;
+ return fd;
}
#undef waitfor
-int
+int
samwaitfor(int pid)
{
int r;
panic("realloc fails");
return p;
}
-
-
blob - 5ccd999ae3e68b23175c7f535d93d03842641239
blob + 0b04d0b066928a83604d794948ae333e98f4848e
--- src/cmd/samterm/icons.c
+++ src/cmd/samterm/icons.c
};
Cursor deadmouse={
{-7, -7},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x0C, 0x00, 0x8E, 0x1D, 0xC7,
- 0xFF, 0xE3, 0xFF, 0xF3, 0xFF, 0xFF, 0x7F, 0xFE,
+ 0xFF, 0xE3, 0xFF, 0xF3, 0xFF, 0xFF, 0x7F, 0xFE,
0x3F, 0xF8, 0x17, 0xF0, 0x03, 0xE0, 0x00, 0x00,},
- {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x08, 0x00, 0x04, 0x00, 0x82,
- 0x04, 0x41, 0xFF, 0xE1, 0x5F, 0xF1, 0x3F, 0xFE,
+ 0x04, 0x41, 0xFF, 0xE1, 0x5F, 0xF1, 0x3F, 0xFE,
0x17, 0xF0, 0x03, 0xE0, 0x00, 0x00, 0x00, 0x00,}
};
Cursor lockarrow={
blob - 7c653aa4837f8e23dcc766bdc767bb7239826c55
blob + e1dd148adb00fa99a3be28c9932b7d0b10954325
--- src/cmd/samterm/io.c
+++ src/cmd/samterm/io.c
goto again;
}
got |= 1<<type;
- return got;
+ return got;
}
int
blob - 5fc42908e1d380dd036c6f87888bbccfb4f2cff1
blob + de9518456f12ebb4652e68e800c09f313fcdca15
--- src/cmd/samterm/main.c
+++ src/cmd/samterm/main.c
ulong n;
if(clearesc)
- typeesc = -1;
+ typeesc = -1;
if(typestart == typeend) {
modified = 0;
return;
case SCROLLKEY:
case CUT:
case COPY:
- case PASTE:
+ case PASTE:
return 1;
}
return 0;
blob - 1e9cd5612be1aef9a0dbe13241cf6ddf9e6452b3
blob + 32478ea2870cb44dfcf7004424ed370c499aee39
--- src/cmd/samterm/mesg.c
+++ src/cmd/samterm/mesg.c
outcopy(int count, uchar *data)
{
while(count--)
- outdata[HSIZE+outcount++] = *data++;
+ outdata[HSIZE+outcount++] = *data++;
}
void
blob - ac564ecff9932b33cf7cb29ca27b3b25a17ebccf
blob + 2e1a645d64d5e96905b00dd08ae9fd4b523e82e9
--- src/cmd/samterm/samterm.h
+++ src/cmd/samterm/samterm.h
void outlong(long);
void outvlong(vlong);
void outsend(void);
-
blob - 9af012eaa56ab636c90685e1272977ca769c58f5
blob + 9219ee51bac07ce89e3e46105f8d1240267ec585
--- src/cmd/scat/display.c
+++ src/cmd/scat/display.c
int p[2];
int i, n;
uchar *a;
-
+
if(pipe(p) < 0){
fprint(2, "pipe failed: %r\n");
return;
void
displayimage(Image *im)
{
- int p[2];
+ int p[2];
if(pipe(p) < 0){
fprint(2, "pipe failed: %r\n");
blob - 519d98f9aa8fa081d4c40739bc2427ddea137f89
blob + 4cd03d02257ae6c4729933cc5cb77fab74096301
--- src/cmd/scat/header.c
+++ src/cmd/scat/header.c
Bprint(&bout, "not mounting dss\n");
return "/n/dss";
}
-
blob - ade4ac5b36b8d78792c304e8c833533fb10ddb6a
blob + c8c743a5d6594b7791e3464aab28ebb8c85fd008
--- src/cmd/scat/plot.c
+++ src/cmd/scat/plot.c
}
if(strcmp(p->name, "saturn") == 0){
drawdisc(scr, p->semidiam, 1, saturncolor, pt, "S");
-
+
return;
}
if(strcmp(p->name, "uranus") == 0){
drawdisc(scr, p->semidiam, 0, uranuscolor, pt, "U");
-
+
return;
}
if(strcmp(p->name, "neptune") == 0){
drawdisc(scr, p->semidiam, 0, neptunecolor, pt, "N");
-
+
return;
}
if(strcmp(p->name, "pluto") == 0){
drawdisc(scr, p->semidiam, 0, plutocolor, pt, "P");
-
+
return;
}
if(strcmp(p->name, "comet") == 0){
blob - 35b7e7aa0fa161044db83b750f8f80f68265addd
blob + dff596b17eecd9f7a86b9608b9fe00b4b8691f04
--- src/cmd/scat/scat.c
+++ src/cmd/scat/scat.c
if(strncmp(s, t, n)==0 && (s[n]<'a' || 'z'<s[n]))
return skipbl(s+n);
return 0;
-
+
}
char*
if(strncmp(s, t, n)==0 && (s[n]==0 || s[n]==' ' || s[n]=='\t'))
return skipbl(s+n);
return 0;
-
+
}
int
blob - 6be98145788e9c2baf81aea577ad7e6f3e28e4cb
blob + bc55fbfcb761258e76641af0bed92e052a870c8e
--- src/cmd/scat/sky.h
+++ src/cmd/scat/sky.h
* The BB field is a dreg, and correct only for SAO and NGC.
* IC(n) is just NGC(n+7840)
* Others should be self-explanatory.
- *
+ *
* Records:
*
* Star is an SAOrec
blob - a78c9c66496d54118c6f150daf516610e6982faf
blob + 23615cf22bf78a95b54d4a952fa6fd95c9d112b7
--- src/cmd/sed.c
+++ src/cmd/sed.c
#define YCOM 026
#define XCOM 033
-
+
typedef struct label { /* Label symbol table */
Rune asc[9]; /* Label name */
SedCom *chain;
}
if (rhs < end)
*rhs++ = r;
- else
+ else
return 0;
}
c = '\n'; /* fake an end-of-line */
prog.pctl.curr = 0;
}
- } else
+ } else
c = -1;
} else if ((c = Bgetrune(prog.pctl.bp)) < 0)
Bterm(prog.pctl.bp);
{
if (!pattern)
return 0;
- subexp[0].s.rsp = buf;
+ subexp[0].s.rsp = buf;
subexp[0].e.rep = 0;
if (rregexec(pattern, linebuf, subexp, MAXSUB) > 0) {
loc1 = subexp[0].s.rsp;
blob - 3f8ea16554beca72061f5fcd47003c65432db85e
blob + b21e8a7e594734a6c63d27450de63fae3444c140
--- src/cmd/sftpcache.c
+++ src/cmd/sftpcache.c
*
* Stupid sftp bug: sftp invokes ssh, which always set O_NONBLOCK
* on 0, 1, and 2. Ssh inherits sftp's 2, so we can't use the output pipe
- * on fd 2, since it will get set O_NONBLOCK, sftp won't notice, and
+ * on fd 2, since it will get set O_NONBLOCK, sftp won't notice, and
* writes will be lost. So instead we use a separate pipe for errors
- * and consult it after each command. Assume the pipe buffer is
+ * and consult it after each command. Assume the pipe buffer is
* big enough to hold the error output.
*/
#include <u.h>
{
static char buf[1000];
int c, tot;
-
+
tot = 0;
while((c = Bgetc(bin)) >= 0 && tot<sizeof buf){
buf[tot++] = c;
readstr(int fd, char *a, int n)
{
int i;
-
+
for(i=0; i<n; i++){
if(read(fd, a+i, 1) != 1)
return -1;
{
char buf[100];
int n, first;
-
+
first = 1;
while((n = read(sftperr, buf, sizeof buf)) > 0){
if(debug){
char buf[200], cmd[1000], *q, *s;
char dir[100], ndir[100];
int p[2], px[2], pe[2], pid, ctl, nctl, fd, n;
-
+
notify(bell);
fmtinstall('H', encodefmt);
default:
usage();
}ARGEND
-
+
if(argc != 1)
usage();
-
+
if(pipe(p) < 0 || pipe(px) < 0 || pipe(pe) < 0)
sysfatal("pipe: %r");
pid = fork();
sysfatal("fork");
if(pid != 0)
exits(nil);
-
+
for(;;){
nctl = listen(dir, ndir);
if(nctl < 0)
close(fd);
}
}
-
blob - fa65002d7867e67a0b664a08d7c1478a12196832
blob + 4b42f140ae1080655b75ad4c60f3a47e8c51f9fb
--- src/cmd/smugfs/a.h
+++ src/cmd/smugfs/a.h
};
extern int printerrors;
-
blob - 2adf8b9b62d6583f2ba7db8abfb509810740d01d
blob + afce6ba7179a7a5344098ab16a89d2ccdb468e23
--- src/cmd/smugfs/cache.c
+++ src/cmd/smugfs/cache.c
movetofront(Cache *c, CEntry *e)
{
popout(c, e);
- insertfront(c, e);
+ insertfront(c, e);
}
static CEntry*
evict(Cache *c)
{
CEntry *e;
-
+
e = c->tail;
popout(c, e);
c->cefree(e);
{
int h;
CEntry *e;
-
+
h = hash(name) % c->nhash;
for(e=c->hash[h]; e; e=e->hash.next){
if(strcmp(name, e->name) == 0){
return e;
}
}
-
+
if(!create)
return nil;
-
+
if(c->nentry >= c->maxentry)
e = evict(c);
else{
h = hash(name) % c->nhash;
e->hash.next = c->hash[h];
c->hash[h] = e;
- return e;
+ return e;
}
void
{
CEntry **l, *e;
int i;
-
+
for(i=0; i<c->nhash; i++){
for(l=&c->hash[i]; (e=*l); ){
if(substr == nil || strstr(e->name, substr)){
blob - e23d49e145a8cb77a08df7d0e9cf82370891149c
blob + 82a2c753b9707a2dcf24f3c22471196e2700c57a
--- src/cmd/smugfs/download.c
+++ src/cmd/smugfs/download.c
dfree(CEntry *ce)
{
DEntry *d;
-
+
d = (DEntry*)ce;
if(d->tmpfile){
remove(d->tmpfile);
host = parseurl(url, &path);
if(host == nil)
return -1;
-
+
d = (DEntry*)cachelookup(downloadcache, url, 1);
if(d->tmpfile){
free(host);
fmtprint(&fmt, "User-Agent: " USER_AGENT "\r\n");
fmtprint(&fmt, "\r\n");
req = fmtstrflush(&fmt);
-
+
fprint(2, "Get %s\n", url);
if(httptofile(&http, host, req, hdr, fd) < 0){
blob - a57b96d11d58938578d99dfa505394a27cc7ffa0
blob + 47e0a47b45c5f4c295ad400ede95891a973c2700
--- src/cmd/smugfs/fs.c
+++ src/cmd/smugfs/fs.c
Upload *u;
int fd, i;
char tmp[] = "/var/tmp/smugfs.XXXXXX";
-
+
if((fd = opentemp(tmp, ORDWR)) < 0)
return nil;
qlock(&uploadlock);
{
int i;
Upload *u;
-
+
qlock(&uploadlock);
for(i=0; i<nup; i++){
u = up[i];
}
datalen = d->length;
free(d);
-
+
memset(&ds, 0, sizeof ds);
seek(u->fd, 0, 0);
total = 0;
fmtprint(&fmt, "X-Smug-FileName: %s\r\n", u->name);
fmtprint(&fmt, "\r\n");
req = fmtstrflush(&fmt);
-
+
seek(u->fd, 0, 0);
jv = jsonupload(&http, UPLOAD_HOST, req, u->fd, datalen);
free(req);
{
int i;
Json *v;
-
+
for(i=0; i<nnick; i++)
if(strcmp(nick[i], name) == 0)
return i;
responderrstr(Req *r)
{
char err[ERRMAX];
-
+
rerrstr(err, sizeof err);
respond(r, err);
}
xclone(Fid *oldfid, Fid *newfid)
{
SmugFid *sf;
-
+
if(oldfid->aux == nil)
return nil;
getcategories(SmugFid *sf)
{
Json *v, *w;
-
+
v = smug("smugmug.categories.get", "NickName", nickname(sf->nickid), nil);
w = jincref(jwalk(v, "Categories"));
jclose(v);
getcategorytree(SmugFid *sf)
{
Json *v, *w;
-
+
v = smug("smugmug.users.getTree", "NickName", nickname(sf->nickid), nil);
w = jincref(jwalk(v, "Categories"));
jclose(v);
{
int i;
Json *v, *w;
-
+
v = getcategorytree(sf);
if(v == nil)
return nil;
int i;
vlong id;
Json *v;
-
+
v = getcategories(sf);
if(v == nil)
return -1;
{
Json *v;
vlong id;
-
+
v = getcategories(sf);
if(v == nil)
return -1;
"NickName", nickname(sf->nickid), nil);
w = jincref(jwalk(v, "Albums"));
jclose(v);
- return w;
+ return w;
}
static vlong
vlong id;
Json *v;
char *key;
-
+
v = getalbums(sf);
if(v == nil)
return -1;
vlong id;
Json *v;
char *key;
-
+
v = getalbums(sf);
if(v == nil)
return -1;
Json *v;
char *p;
char *key;
-
+
id = strtol(name, &p, 10);
if(*p != 0 || *name == 0)
return -1;
vlong id;
Json *v;
char *key;
-
+
v = getimages(sf, sf->album, sf->albumkey);
if(v == nil)
return -1;
{
Json *v;
char *s;
-
+
v = getcategory(sf, sf->category);
s = jstring(jwalk(v, "Name"));
if(s)
{
Json *v;
char *s;
-
+
v = getalbum(sf, sf->album, sf->albumkey);
s = jstring(jwalk(v, "Title"));
if(s)
{
char *s;
Json *v;
-
+
v = getimageinfo(sf, sf->image, sf->imagekey);
s = jstring(jwalk(v, "FileName"));
if(s && s[0])
{
vlong length;
Json *v;
-
+
v = getimageinfo(sf, sf->image, sf->imagekey);
length = jint(jwalk(v, "Size"));
jclose(v);
return nil;
}
-static char* imagestrings[] =
+static char* imagestrings[] =
{
"Caption",
"LastUpdated",
"Album",
};
-static char* albumbools[] =
+static char* albumbools[] =
{
"Public",
"Printable",
"X3Larges",
};
-static char* albumstrings[] =
+static char* albumstrings[] =
{
"Description"
"Keywords",
case Qimagectl:
v = getimageinfo(sf, sf->image, sf->imagekey);
break;
-
+
case Qimageurl:
v = getimageinfo(sf, sf->image, sf->imagekey);
fmtstrinit(&fmt);
fmtprint(&fmt, "%s %s\n", urls[i].name, s);
jclose(v);
return fmtstrflush(&fmt);
-
+
case Qimageexif:
v = getimageexif(sf, sf->image, sf->imagekey);
break;
-
+
case Qalbumsettings:
v = getalbum(sf, sf->album, sf->albumkey);
fmtstrinit(&fmt);
char *uid;
char *s;
vlong length;
-
+
memset(&q, 0, sizeof q);
name = nil;
freename = 0;
SmugFid *sf;
char *x;
Upload *u;
-
+
dotdot = strcmp(name, "..") == 0;
sf = fid->aux;
switch(sf->type){
break;
}
goto NotFound;
-
+
case Qalbums:
case Qcategory:
if(dotdot){
break;
}
goto NotFound;
-
+
case Qimage:
if(dotdot){
free(sf->imagekey);
xsf.nickid = i;
dostat(&xsf, nil, d);
return 0;
-
+
case Qnick:
if(i-- == 0){
xsf.type = Qalbums;
xsf.category = id;
dostat(&xsf, nil, d);
return 0;
-
+
case Qalbums:
case Qcategory:
if((id = getalbumindex(sf, i, &key)) < 0)
dostat(&xsf, nil, d);
free(key);
return 0;
-
+
case Qalbum:
if(i-- == 0){
xsf.type = Qalbumsettings;
dostat(&xsf, nil, d);
free(key);
return 0;
-
+
case Qimage:
if(i-- == 0){
xsf.type = Qimagefile;
}
}
respond(r, "invalid wstat");
-}
+}
static void
xattach(Req *r)
{
SmugFid *sf;
-
+
sf = emalloc(sizeof *sf);
r->fid->aux = sf;
sf->type = Qroot;
case Qalbumsettings:
case Qimagesettings:
break;
-
+
case Quploadfile:
if(r->ifcall.mode != OREAD){
lock(&sf->upload->lk);
unlock(&sf->upload->lk);
}
break;
-
+
default:
if(r->ifcall.mode != OREAD){
respond(r, "permission denied");
dostat(sf, &r->ofcall.qid, nil);
respond(r, nil);
return;
-
+
case Qcategory:
// Create new album.
if(!(r->ifcall.perm&DMDIR))
snprint(strid, sizeof strid, "%lld", sf->category);
// Start with most restrictive settings.
v = ncsmug("smugmug.albums.create",
- "Title", r->ifcall.name,
+ "Title", r->ifcall.name,
"CategoryID", strid,
"Public", "0",
"WorldSearchable", "0",
dostat(sf, &r->ofcall.qid, nil);
respond(r, nil);
return;
-
+
case Qalbum:
// Upload image to album.
if(r->ifcall.perm&DMDIR)
respond(r, nil);
return;
}
- respond(r, "permission denied");
+ respond(r, "permission denied");
}
static int
writetofd(Req *r, int fd)
{
int total, n;
-
+
total = 0;
while(total < r->ifcall.count){
n = pwrite(fd, (char*)r->ifcall.data+total, r->ifcall.count-total, r->ifcall.offset+total);
int fd;
HTTPHeader hdr;
char *url;
-
+
sf = r->fid->aux;
r->ofcall.count = 0;
switch(sf->type){
Json *v;
char strid[50];
SmugFid *sf;
-
+
sf = r->fid->aux;
r->ofcall.count = r->ifcall.count;
sync = (r->ifcall.count==4 && memcmp(r->ifcall.data, "sync", 4) == 0);
respond(r, nil);
return;
}
- break;
+ break;
case Qalbumsctl:
case Qcategoryctl:
jcacheflush("smugmug.categories.get");
}
respond(r, "invalid control message");
return;
-}
+}
void
xremove(Req *r)
respond(r, nil);
}
return;
-
+
case Qimage:
snprint(id, sizeof id, "%lld", sf->image);
v = ncsmug("smugmug.images.delete",
void
xinit(void)
-{
+{
xsrv.attach = xattach;
xsrv.open = xopen;
xsrv.create = xcreate;
blob - 9cf7f1d0729290ee40ac16f0d3e944dc165238a6
blob + c6c117fcab8b1e2d85b6179f5ae2cc683dd4deb8
--- src/cmd/smugfs/http.c
+++ src/cmd/smugfs/http.c
{
int nline;
char *data, *ebuf, *p, *q, *next;
-
+
memset(hdr, 0, sizeof *hdr);
ebuf = buf+n;
data = haveheader(buf, n);
q++;
strncpy(hdr->codedesc, q, sizeof hdr->codedesc);
hdr->codedesc[sizeof hdr->codedesc-1] = 0;
- continue;
+ continue;
}
q = strchr(p, ':');
if(q == nil)
memmove(buf, data, ebuf - data);
return ebuf - data;
-}
+}
static char*
genhttp(Protocol *proto, char *host, char *req, HTTPHeader *hdr, int wfd, int rfd, vlong rtotal)
proto->close(fd);
return nil;
}
-
+
if(rfd >= 0){
while(rtotal > 0){
m = sizeof buf;
blob - 750f232c069e7a7ff386a4da1a02fdc7fc7e799a
blob + 026aa59e86403530a2d2a46b3b3822caf5ca2317
--- src/cmd/smugfs/icache.c
+++ src/cmd/smugfs/icache.c
{
int h;
Icache *ic;
-
+
h = hash(url) % NHASH;
for(ic=icache.hash[h]; ic; ic=ic->hash){
if(strcmp(ic->url, url) == 0){
ic = emalloc(sizeof *ic);
icache.n++;
}
-
+
ic->url = estrdup(url);
ic->fd = dup(fd, -1);
ic->file = estrdup(file);
icacheflush(char *substr)
{
Icache **l, *ic;
-
+
for(l=&icache.head; (ic=*l); ) {
if(substr == nil || strstr(ic->url, substr)) {
icache.n--;
}else
l = &ic->next;
}
-
+
if(icache.head) {
icache.head->prev = nil;
for(ic=icache.head; ic; ic=ic->next){
icacheinsert(url, &hdr, buf, fd);
return fd;
}
-
blob - d6472b4db0a71cb7d11413ecea566cf11a82bc63
blob + c79c189c767c461874fb66ec026c0f706ec4682d
--- src/cmd/smugfs/json.c
+++ src/cmd/smugfs/json.c
newjval(int type)
{
Json *v;
-
+
v = emalloc(sizeof *v);
v->ref = 1;
v->type = type;
double d;
Json *v;
- /* -?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))?([Ee][-+]?[0-9]+) */
+ /* -?(0|[1-9][0-9]*)(\.(0|[1-9][0-9]*))?([Ee][-+]?[0-9]+) */
p = wskip(*pp);
q = p;
if(*q == '-')
while('0' <= *q && *q <= '9')
q++;
}
-
+
t = emalloc(q-p+1);
memmove(t, p, q-p);
t[q-p] = 0;
v = newjval(Jnumber);
v->number = d;
*pp = q;
- return v;
+ return v;
}
static Json*
parsejson(char *text)
{
Json *v;
-
+
v = parsevalue(&text);
if(v && text && *wskip(text) != 0){
jclose(v);
{
Fmt fmt;
char buf[256];
-
+
fmtfdinit(&fmt, 1, buf, sizeof buf);
_printjval(&fmt, v, 0);
fmtprint(&fmt, "\n");
jsonfmt(Fmt *fmt)
{
Json *v;
-
+
v = va_arg(fmt->args, Json*);
if(fmt->flags&FmtSharp)
_printjval(fmt, v, 0);
jlookup(Json *v, char *name)
{
int i;
-
+
if(v->type != Jobject)
return nil;
for(i=0; i<v->len; i++)
{
char elem[128], *p, *next;
int n;
-
+
for(p=path; *p && v; p=next){
next = strchr(p, '/');
if(next == nil)
jstrcmp(Json *jv, char *s)
{
char *t;
-
+
t = jstring(jv);
if(t == nil)
return -2;
blob - 92490e775a5e696bf24ceaa7969f76e603872ac0
blob + f0043bb392b686a424d6b3a536120f2142b70158
--- src/cmd/smugfs/jsonrpc.c
+++ src/cmd/smugfs/jsonrpc.c
jfree(CEntry *ce)
{
JEntry *j;
-
+
j = (JEntry*)ce;
jclose(j->reply);
}
makehttprequest(char *host, char *path, char *postdata)
{
Fmt fmt;
-
+
fmtstrinit(&fmt);
fmtprint(&fmt, "POST %s HTTP/1.0\r\n", path);
fmtprint(&fmt, "Host: %s\r\n", host);
{
char *data;
HTTPHeader hdr;
-
+
data = httpreq(proto, host, request, &hdr, rfd, rlength);
if(data == nil){
fprint(2, "httpreq: %r\n");
{
Json *jv;
va_list arg;
-
+
va_start(arg, name1);
// TODO: Could use https only for login.
jv = jsonrpc(&https, HOST, PATH, method, name1, arg, 0);
{
Json *jv;
va_list arg;
-
+
va_start(arg, name1);
jv = jsonrpc(&http, HOST, PATH, method, name1, arg, 1);
va_end(arg);
jclose(jv);
return nil;
}
-
blob - 5603211e317f4f3bbec3319233d6316b81a7d5a8
blob + 5e2f015a2909c9d599fce616801f21fec29c6c6d
--- src/cmd/smugfs/log.c
+++ src/cmd/smugfs/log.c
lbvappend(&rpclogbuf, fmt, arg);
va_end(arg);
}
-
blob - 6be0ca42d339a0377bdca16452a2eb5926f37542
blob + e1c2745f6549ad4038c27a13c3976f5689e1c12c
--- src/cmd/smugfs/main.c
+++ src/cmd/smugfs/main.c
nil);
if(v == nil)
sysfatal("login failed: %r");
-
+
memset(up->user, 'X', strlen(up->user));
memset(up->passwd, 'X', strlen(up->passwd));
free(up);
default:
usage();
}ARGEND
-
+
if(argc != 0)
usage();
if(name == nil && mtpt == nil)
mtpt = "/n/smug";
-
+
/*
* Check twice -- if there is an exited smugfs instance
* mounted there, the first access will fail but unmount it.
blob - baccd3acd7eb8db99a4b26aa5f624d0a24eb936c
blob + 01b169c8e92bab6d6f94a5a912913051acd46065
--- src/cmd/smugfs/openssl.c
+++ src/cmd/smugfs/openssl.c
sbio = BIO_new_ssl_connect(ctx);
BIO_get_ssl(sbio, &ssl);
SSL_set_mode(ssl, SSL_MODE_AUTO_RETRY);
-
+
snprint(buf, sizeof buf, "%s:https", host);
BIO_set_conn_hostname(sbio, buf);
-
+
if(BIO_do_connect(sbio) <= 0 || BIO_do_handshake(sbio) <= 0){
ERR_error_string_n(ERR_get_error(), buf, sizeof buf);
BIO_free_all(sbio);
{
int m, total;
char *p;
-
+
p = v;
total = 0;
while(total < n){
}
total += m;
}
- return total;
+ return total;
}
static int
blob - a203ece937e37e8a341a53b7997ed9cc5198fb51
blob + b8b9511277294ab5bba38e98ec230a7e4ed2e7bb
--- src/cmd/smugfs/tcp.c
+++ src/cmd/smugfs/tcp.c
httpwrite,
httpclose,
};
-
blob - b4a649d83180a51aa45940f38b1c658ce2d26f24
blob + 90a12cb9a31e0269001f3bb100b3ca5542696e37
--- src/cmd/smugfs/util.c
+++ src/cmd/smugfs/util.c
emalloc(int n)
{
void *v;
-
+
v = mallocz(n, 1);
if(v == nil)
sysfatal("out of memory");
{
Tm tm;
vlong ms;
-
+
ms = nsec()/1000000;
-
+
tm = *localtime(ms/1000);
fmtprint(f, "%02d:%02d:%02d.%03d",
tm.hour, tm.min, tm.sec,
{
int x;
char *s;
-
+
s = va_arg(fmt->args, char*);
for(; *s; s++){
x = (uchar)*s;
}
return 0;
}
-
blob - 20f5b6ad10491e02fcc5a17c2b630009a28b54d4
blob + 613a8cc519b4b465a863c277c0337e3c1f37132f
--- src/cmd/snarfer/osx-cocoa-snarfer.c
+++ src/cmd/snarfer/osx-cocoa-snarfer.c
#include "snarfer.c"
-
blob - 20f5b6ad10491e02fcc5a17c2b630009a28b54d4
blob + 613a8cc519b4b465a863c277c0337e3c1f37132f
--- src/cmd/snarfer/osx-snarfer.c
+++ src/cmd/snarfer/osx-snarfer.c
#include "snarfer.c"
-
blob - 9477f0420951bb79e220344c7b46c48f8074f0de
blob + d09b2f44b360dd8abe9f94c6a1b5949f18060485
--- src/cmd/snarfer/snarfer.c
+++ src/cmd/snarfer/snarfer.c
main(int argc, char **argv)
{
XEvent xevent;
-
+
ARGBEGIN{
default:
usage();
if((xdisplay = XOpenDisplay(nil)) == nil)
sysfatal("XOpenDisplay: %r");
- drawable = XCreateWindow(xdisplay, DefaultRootWindow(xdisplay),
- 0, 0, 1, 1, 0, 0,
- InputOutput, DefaultVisual(xdisplay, DefaultScreen(xdisplay)),
+ drawable = XCreateWindow(xdisplay, DefaultRootWindow(xdisplay),
+ 0, 0, 1, 1, 0, 0,
+ InputOutput, DefaultVisual(xdisplay, DefaultScreen(xdisplay)),
0, 0);
if(drawable == None)
sysfatal("XCreateWindow: %r");
XFlush(xdisplay);
-
+
xclipboard = XInternAtom(xdisplay, "CLIPBOARD", False);
xutf8string = XInternAtom(xdisplay, "UTF8_STRING", False);
xtargets = XInternAtom(xdisplay, "TARGETS", False);
xgetsnarf();
appleputsnarf();
xputsnarf();
-
+
for(;;){
XNextEvent(xdisplay, &xevent);
switch(xevent.type){
XEvent r;
XSelectionRequestEvent *xe;
XDisplay *xd;
-
+
xd = xdisplay;
-
+
memset(&r, 0, sizeof r);
xe = (XSelectionRequestEvent*)e;
if(0) fprint(2, "xselect target=%d requestor=%d property=%d selection=%d\n",
int fmt, i;
XWindow w;
XDisplay *xd;
-
+
xd = xdisplay;
w = None;
*/
if(w == None)
return nil;
-
+
/*
* We should be waiting for SelectionNotify here, but it might never
* come, and we have no way to time out. Instead, we will clear
return nil;
/* get the property */
data = nil;
- XGetWindowProperty(xd, drawable, prop, 0, SnarfSize/sizeof(ulong), 0,
+ XGetWindowProperty(xd, drawable, prop, 0, SnarfSize/sizeof(ulong), 0,
AnyPropertyType, &type, &fmt, &len, &dummy, &xdata);
if(xdata == nil || (type != XA_STRING && type != xutf8string) || len == 0){
if(xdata)
fprint(2, "apple pasteboard cannot assert ownership\n");
return;
}
- cfdata = CFDataCreate(kCFAllocatorDefault,
+ cfdata = CFDataCreate(kCFAllocatorDefault,
(uchar*)rsnarf, runestrlen(rsnarf)*2);
if(cfdata == nil){
fprint(2, "apple pasteboard cfdatacreate failed\n");
CFRelease(cfdata);
#endif
}
-
-
blob - 73fff2e2bea52e71b48b2a54311e8cb56be38f9f
blob + 35b59804e0ebe95c87fa6bdb5275f66cb0be3a3a
--- src/cmd/spell/code.h
+++ src/cmd/spell/code.h
*/
#define ED (1<<0) /* +ed, +ing */
-#define ADJ (1<<1) /* (nce)-t_ce, +ize,+al, +ness, -t+cy, +ity, +ly */
+#define ADJ (1<<1) /* (nce)-t_ce, +ize,+al, +ness, -t+cy, +ity, +ly */
#define NOUN (1<<2) /* +s (+es), +make, +hood, +ship +less */
#define PROP_COLLECT (1<<3) /* +'s, +an, +ship(for -manship) +less */
#define ACTOR (1<<4) /* +er */
#define N_AFFIX (1<<8) /* +ic, +ive, +ize, +like, +al, +ful, +ism, +ist, -t+cy, +c (maniac) */
#define V_AFFIX (1<<9) /* +able, +ive, +ity((bility), +ment */
#define V_IRREG (1<<10) /* +ing +es +s*/
-#define VERB (V_IRREG|ED)
+#define VERB (V_IRREG|ED)
#define MAN (1<<11) /* +man, +men, +women, +woman */
#define ADV (1<<12) /* +hood, +ness */
#define STOP (1<<14) /* stop list */
blob - 6eaa026f8a3245e9aaf94e77f356be1d0305d2a2
blob + 1627829c0b875383177a7d27c7f73a6466ebeb42
--- src/cmd/spell/sprog.c
+++ src/cmd/spell/sprog.c
print("-");
else if(!vflag)
print("+");
- else
+ else
print("%c",'0' + (suffcount>0) +
(prefcount>4? 8: 2*prefcount));
} else if(!h || Set(h,STOP)) {
loop:
if(bp >= ep) {
- if(xflag)
+ if(xflag)
fprint(2, "=%.*s\n", utfnlen(w, n), w);
return 0;
}
blob - e758786ce8c65abd7d7572ab9ae2f042a5b43970
blob + 14d55ef74363bcb35ca2279a7f1871bcc96c5318
--- src/cmd/split.c
+++ src/cmd/split.c
}
/*
- * in case we didn't end with a newline, tack whatever's
+ * in case we didn't end with a newline, tack whatever's
* left onto the last file
*/
while((n = Bread(b, buf, sizeof(buf))) > 0)
} else {
strcpy(name, stem);
strcat(name, suff);
- if(++suff[1] > 'z')
+ if(++suff[1] > 'z')
suff[1] = 'a', ++suff[0];
openf();
}
strcpy(name+len, suffix);
openf();
return 1;
- }
+ }
return nextfile();
}
blob - e53c99c88e9c874339b04656fa6c798d7cae0f56
blob + c4e79cc44eb1714242d6b39bf2b75d3cc701c975
--- src/cmd/srv.c
+++ src/cmd/srv.c
fmtinstall('F', fcallfmt);
fmtinstall('M', dirmodefmt);
-
+
ARGBEGIN{
case 'D':
debug = 1;
default:
usage();
}ARGEND
-
+
if(argc != 1 && argc != 2)
usage();
static uchar buf[9000];
static char ebuf[200];
int n;
-
+
n = convS2M(tx, buf, sizeof buf);
if(n == BIT16SZ){
werrstr("convS2M failed");
if(rx.type == Rerror)
sysfatal("Tversion: %s", rx.ename);
msize = rx.msize;
-
+
tx.type = Tauth;
tx.tag = 1;
tx.afid = afid;
xread(void *buf, int n)
{
Fcall tx, rx;
-
+
tx.type = Tread;
tx.tag = 1;
tx.fid = 0; /* afid above */
werrstr("%s", rx.ename);
return -1;
}
-
+
if(rx.count > n){
werrstr("too much data returned");
return -1;
xwrite(void *buf, int n)
{
Fcall tx, rx;
-
+
tx.type = Twrite;
tx.tag = 1;
tx.fid = 0; /* afid above */
auth_freerpc(rpc);
return ai;
}
-
blob - 6e7748baa5f8fb728526dd46499e3e6e197d394d
blob + 1fdbec1d38a704108b89e22d5df9e8f699121a50
--- src/cmd/strings.c
+++ src/cmd/strings.c
}
start = 0;
cnt = 0;
- }
+ }
posn = Boffset(fin);
}
blob - bec41e47a7d930ec79bd12cdedfc421b2e876bd4
blob + 4cb16957be7b3e0785ebfd741fc366f7b0058aaf
--- src/cmd/svgpic/arcgen.c
+++ src/cmd/svgpic/arcgen.c
else if( x> 0.0 && y<=0.0) return(4);
else return 0; /* shut up lint */
}
-
blob - e0db5fc6c5502b902f5c259e9aafdbadcaa19a1f
blob + bc7e933515ecee88984552ec7b149b24c3f2025d
--- src/cmd/svgpic/linegen.c
+++ src/cmd/svgpic/linegen.c
extreme(ex, ey);
nx = xi; ny = yi;
}
-
+
}
p->o_ddval = ddval;
if (dbg) {
blob - e888fafc827612055d05f390f5eb05f21508489e
blob + 1e2db1b5218c4bf2d0dab056e2cd012c1833f4c2
--- src/cmd/svgpic/misc.c
+++ src/cmd/svgpic/misc.c
return 0;
}
-double
+double
getcomp(obj *p, int t) /* return component of a position */
{
switch (t) {
blob - 7f6db9d49d41cf0f47f01f2a0d024526560e02f6
blob + 575dc356f1cdbdd399afd08bf3c16240db5168f7
--- src/cmd/svgpic/plsvg.c
+++ src/cmd/svgpic/plsvg.c
if(i == 1)
printf("M %.3f %.3f L %.3f %.3f", xconv(x1+dx), yconv(y1+dy), xconv(x1), yconv(y1));
else
- printf(" L %.3f %.3f", xconv(x1+dx), yconv(y1+dy));
+ printf(" L %.3f %.3f", xconv(x1+dx), yconv(y1+dy));
}
if (nhead > 2)
printf(" Z");
blob - b40552bfd98cb6fe699e82e68d77e4cd82a016de
blob + 68f7c5eb83f57e4902606135fb66de230d08c848
--- src/cmd/tail.c
+++ src/cmd/tail.c
if(count < 0 || (int)count != count)
fatal("too big");
return 1;
-}
+}
-void
+void
fatal(char *s)
{
char buf[ERRMAX];
blob - 1d917f82c877b7712f068f4918196fcd17bc87de
blob + af5f520032f494d247624f49fe116673ddf4233b
--- src/cmd/tapefs/32vfs.c
+++ src/cmd/tapefs/32vfs.c
if ((flags&VFMT)==VIFDIR)
f.mode |= DMDIR;
f.uid = g2byte(dp->uid);
- f.gid = g2byte(dp->gid);
+ f.gid = g2byte(dp->gid);
f.mdate = g4byte(dp->mtime);
return f;
}
blob - 199235f386d27713b5801031b4324740b54c87c9
blob + a166dcd0f068eb834f9f28d7ee0d067dd190f384
--- src/cmd/tapefs/util.c
+++ src/cmd/tapefs/util.c
up[nid].id = atoi(line[2]);
up[nid].name = strdup(line[0]);
nid++;
- }
+ }
Bterm(bp);
up[nid].name = 0;
return up;
blob - c2875b845a21a8706c46b36a23e0b3fb59b248e4
blob + 0b695dba15c3e74391133e375f9391bad25b00b1
--- src/cmd/tapefs/v10fs.c
+++ src/cmd/tapefs/v10fs.c
if ((flags&VFMT)==VIFDIR)
f.mode |= DMDIR;
f.uid = g2byte(dp->uid);
- f.gid = g2byte(dp->gid);
+ f.gid = g2byte(dp->gid);
f.mdate = g4byte(dp->mtime);
return f;
}
blob - 74c6737c7e6f70c25769216648d567ad2ddf5c7d
blob + 43de410c1e0ac7b2be60bb73498d0ec6ecc5c010
--- src/cmd/tapefs/v6fs.c
+++ src/cmd/tapefs/v6fs.c
if ((flags&V6FMT)==V6IFDIR)
f.mode |= DMDIR;
f.uid = dp->uid;
- f.gid = dp->gid;
+ f.gid = dp->gid;
f.mdate = (dp->mtime[2]<<0) + (dp->mtime[3]<<8)
+(dp->mtime[0]<<16) + (dp->mtime[1]<<24);
return f;
blob - e9354f7b4f80daa4b10e09b11d736624deba022b
blob + 8725e0c94fa847352dfe3a25daabf1ecf7ee4e40
--- src/cmd/tapefs/zipfs.c
+++ src/cmd/tapefs/zipfs.c
sysfatal("%d - unsupported compression method", zh.meth);
break;
}
-
+
return buf;
}
return tm2sec(&tm);
}
-
blob - 934fba9d98f6c38da4bd590d8cf508737beefe79
blob + 61e9c4a63c62216e12cd1d7376f181acb7c51d84
--- src/cmd/tar.c
+++ src/cmd/tar.c
char devmajor[8];
char devminor[8];
char prefix[Maxpfx]; /* if non-null, path= prefix "/" name */
-
+
char pad[12];
} Hdr;
blob - 1e6cbf1140ce358f8c5f800685cb984bff664afd
blob + 6cb7ada10591a4a2455ca0015f69f0e5a7ba0d54
--- src/cmd/tbl/t1.c
+++ src/cmd/tbl/t1.c
{
sargc = argc;
sargv = argv;
- sargc--;
+ sargc--;
sargv++;
if (sargc > 0)
swapin();
pr1403 = 1;
if (match("-", *sargv))
break;
- sargc--;
+ sargc--;
sargv++;
}
- if (sargc <= 0)
+ if (sargc <= 0)
return(0);
/* file closing is done by GCOS troff preprocessor */
if(tabin)
blob - 6d2d7414a77b3275a4860b7d23ffe7095454c534
blob + c3ecce7d905dde302b8a60c56caaa8b04344fd0d
--- src/cmd/tbl/t2.c
+++ src/cmd/tbl/t2.c
freearr();
restline();
}
-
-
blob - a4dc9f9f536e615eef305576b3e84837c7549b90
blob + f2f81309e1e0baf4459b69d8f7bd7c2a6f1364ae
--- src/cmd/tbl/t3.c
+++ src/cmd/tbl/t3.c
/* t3.c: interpret commands affecting whole table */
# include "t.h"
struct optstr {
- char *optnam;
+ char *optnam;
int *optadd;
} options [] = {
"expand", &expflg,
return;
}
for (cp = line; (c = *cp) != ';'; cp++) {
- if (!letter(c))
+ if (!letter(c))
continue;
found = 0;
for (lp = options; lp->optadd; lp++) {
if ( *cp == '(')
while ((ci = *++cp) != ')')
*t++ = ci;
- else
+ else
cp--;
- *t++ = 0;
+ *t++ = 0;
*t = 0;
if (lp->optadd == &tab) {
if (nb[0])
un1getc(*--s);
return;
}
-
-
blob - 558d3ba3ab9246e78901081cf0b6159f69d12343
blob + 21fd82c67c473dde42a9ac409622134bc9a7a6e3
--- src/cmd/tbl/t4.c
+++ src/cmd/tbl/t4.c
case ' ': /* note this is also case tab */
continue;
case '\n':
- if (sawchar == 0)
+ if (sawchar == 0)
continue;
case ',':
case '.': /* end of table specification */
ncol = max(ncol, icol);
if (lefline[ncol][nclin] > 0) {
- ncol++;
+ ncol++;
rightl++;
};
if (sawchar)
}
sawchar = 0;
continue;
- case 'C':
- case 'S':
- case 'R':
- case 'N':
- case 'L':
+ case 'C':
+ case 'S':
+ case 'R':
+ case 'N':
+ case 'L':
case 'A':
c += ('a' - 'A');
- case '_':
- if (c == '_')
+ case '_':
+ if (c == '_')
c = '-';
- case '=':
+ case '=':
case '-':
case '^':
- case 'c':
- case 's':
- case 'n':
- case 'r':
- case 'l':
+ case 'c':
+ case 's':
+ case 'n':
+ case 'r':
+ case 'l':
case 'a':
style[icol][nclin] = c;
if (c == 's' && icol <= 0)
error("too many columns in table");
sawchar = 1;
continue;
- case 'b':
+ case 'b':
case 'i':
c += 'A' - 'a';
- case 'B':
+ case 'B':
case 'I':
- if (icol == 0)
+ if (icol == 0)
continue;
snp = font[icol-1][nclin];
snp[0] = (c == 'I' ? '2' : '3');
snp[1] = 0;
continue;
- case 't':
+ case 't':
case 'T':
if (icol > 0)
flags[icol-1][nclin] |= CTOP;
continue;
- case 'd':
+ case 'd':
case 'D':
if (icol > 0)
flags[icol-1][nclin] |= CDOWN;
continue;
- case 'f':
+ case 'f':
case 'F':
- if (icol == 0)
+ if (icol == 0)
continue;
snp = font[icol-1][nclin];
snp[0] = snp[1] = stopc = 0;
stopc = ')';
c = get1char();
}
- if (c == 0)
+ if (c == 0)
break;
if (c == stopc) {
- stopc = 0;
+ stopc = 0;
break;
}
- if (stopc == 0)
- if (c == ' ' || c == tab )
+ if (stopc == 0)
+ if (c == ' ' || c == tab )
break;
if (c == '\n' || c == '|') {
- un1getc(c);
+ un1getc(c);
break;
}
snp[i] = c;
- if (c >= '0' && c <= '9')
+ if (c >= '0' && c <= '9')
break;
}
- if (stopc)
+ if (stopc)
if (get1char() != stopc)
error("Nonterminated font name");
continue;
- case 'P':
+ case 'P':
case 'p':
- if (icol <= 0)
+ if (icol <= 0)
continue;
temp = snp = csize[icol-1][nclin];
while (c = get1char()) {
- if (c == ' ' || c == tab || c == '\n')
+ if (c == ' ' || c == tab || c == '\n')
break;
if (c == '-' || c == '+')
if (snp > temp)
*snp++ = c;
else if (digit(c))
*snp++ = c;
- else
+ else
break;
if (snp - temp > 4)
error("point size too large");
error("point size unreasonable");
un1getc (c);
continue;
- case 'V':
+ case 'V':
case 'v':
- if (icol <= 0)
+ if (icol <= 0)
continue;
temp = snp = vsize[icol-1][nclin];
while (c = get1char()) {
- if (c == ' ' || c == tab || c == '\n')
+ if (c == ' ' || c == tab || c == '\n')
break;
if (c == '-' || c == '+')
if (snp > temp)
*snp++ = c;
else if (digit(c))
*snp++ = c;
- else
+ else
break;
if (snp - temp > 4)
error("vertical spacing value too large");
*snp = 0;
un1getc(c);
continue;
- case 'w':
+ case 'w':
case 'W':
snp = cll [icol-1];
/* Dale Smith didn't like this check - possible to have two text blocks
if (!stopc)
un1getc(c);
continue;
- case 'e':
+ case 'e':
case 'E':
- if (icol < 1)
+ if (icol < 1)
continue;
evenup[icol-1] = 1;
evenflg = 1;
continue;
- case 'z':
+ case 'z':
case 'Z': /* zero width-ignre width this item */
- if (icol < 1)
+ if (icol < 1)
continue;
flags[icol-1][nclin] |= ZEROW;
continue;
- case 'u':
+ case 'u':
case 'U': /* half line up */
- if (icol < 1)
+ if (icol < 1)
continue;
flags[icol-1][nclin] |= HALFUP;
continue;
- case '0':
- case '1':
- case '2':
- case '3':
+ case '0':
+ case '1':
+ case '2':
+ case '3':
case '4':
- case '5':
- case '6':
- case '7':
- case '8':
+ case '5':
+ case '6':
+ case '7':
+ case '8':
case '9':
sn[0] = c;
snp = sn + 1;
continue;
case '|':
lefline[icol][nclin]++;
- if (icol == 0)
+ if (icol == 0)
left1flg = 1;
continue;
}
if (c != '\n')
un1getc(c);
for (s = line; *s = c = get1char(); s++) {
- if (c == ')')
+ if (c == ')')
inpar = 0;
- if (inpar)
+ if (inpar)
continue;
if (c == '\n' || c == 0 || c == '.' || c == ',')
break;
}
for (p = line; p < s; p++)
switch (*p) {
- case 'l':
- case 'r':
- case 'c':
- case 'n':
- case 'a':
+ case 'l':
+ case 'r':
+ case 'c':
+ case 'n':
+ case 'a':
case 's':
- case 'L':
- case 'R':
- case 'C':
- case 'N':
- case 'A':
+ case 'L':
+ case 'R':
+ case 'C':
+ case 'N':
+ case 'A':
case 'S':
- case '-':
- case '=':
+ case '-':
+ case '=':
case '_':
n++;
}
free(acase);
free(topat);
}
-
-
blob - e23784be2c7e13d1dd82e21cb0db57ec2ea21178
blob + c50077e7c1ff2cc13501f6f3d2e09988b5d6def3
--- src/cmd/tbl/t5.c
+++ src/cmd/tbl/t5.c
while (*cstore++)
;
continue;
- } else
+ } else
instead[nlin] = 0;
if (nodata(nlin)) {
if (ch = oneh(nlin))
table[nlin] = (struct colstr *) alocv((ncol + 2) * sizeof(table[0][0]));
if (cstore[1] == 0)
switch (cstore[0]) {
- case '_':
- fullbot[nlin] = '-';
+ case '_':
+ fullbot[nlin] = '-';
continue;
- case '=':
- fullbot[nlin] = '=';
+ case '=':
+ fullbot[nlin] = '=';
continue;
}
stynum[nlin] = nslin;
table[nlin][icol].rcol = 0;
ch = 1;
if (match(cstore, "T{")) { /* text follows */
- table[nlin][icol].col =
+ table[nlin][icol].col =
(char *)(uintptr)gettext(cstore, nlin, icol,
font[icol][stynum[nlin]],
csize[icol][stynum[nlin]]);
}
while (ctype(nlin, icol + 1) == 's') /* spanning */
table[nlin][++icol].col = "";
- if (ch == '\0')
+ if (ch == '\0')
break;
}
while (++icol < ncol + 2) {
}
last = cstore;
permute();
- if (textflg)
+ if (textflg)
untext();
return;
}
for (c = 0; c < ncol; c++) {
switch (ctype(il, c)) {
- case 'c':
- case 'n':
- case 'r':
- case 'l':
- case 's':
+ case 'c':
+ case 'n':
+ case 'r':
+ case 'l':
+ case 's':
case 'a':
return(0);
}
int
vspand(int ir, int ij, int ifform)
{
- if (ir < 0)
+ if (ir < 0)
return(0);
if (ir >= nlin)
return(0);
- if (instead[ir])
+ if (instead[ir])
return(0);
- if (ifform == 0 && ctype(ir, ij) == '^')
+ if (ifform == 0 && ctype(ir, ij) == '^')
return(1);
- if (table[ir][ij].rcol != 0)
+ if (table[ir][ij].rcol != 0)
return(0);
- if (fullbot[ir])
+ if (fullbot[ir])
return(0);
return(vspen(table[ir][ij].col));
}
int
vspen(char *s)
{
- if (s == 0)
+ if (s == 0)
return(0);
- if (!point(s))
+ if (!point(s))
return(0);
return(match(s, SPAN));
}
-
-
blob - 463bfa1070d4f8246644c028d7a0ae6548d2907f
blob + aed42a071da23aae9d9ac5f5ce739c3a73a9bead
--- src/cmd/tbl/t6.c
+++ src/cmd/tbl/t6.c
Bprint(&tabout, ".%2s\n.rm %2s\n", reg(icol, CRIGHT),
reg(icol, CRIGHT));
for (ilin = 0; ilin < nlin; ilin++) {
- if (instead[ilin] || fullbot[ilin])
+ if (instead[ilin] || fullbot[ilin])
continue;
vforml = ilin;
for (il = prev(ilin); il >= 0 && vspen(table[il][icol].col); il = prev(il))
vforml = il;
- if (fspan(vforml, icol))
+ if (fspan(vforml, icol))
continue;
- if (filler(table[ilin][icol].col))
+ if (filler(table[ilin][icol].col))
continue;
- if ((flags[icol][stynum[ilin]] & ZEROW) != 0)
+ if ((flags[icol][stynum[ilin]] & ZEROW) != 0)
continue;
switch (ctype(vforml, icol)) {
case 'a':
doubled[icol] = 1;
if (real(ss = table[ilin][icol].col) && !vspen(ss)) {
s = (int)(uintptr)ss;
- if (tx(s) != text)
+ if (tx(s) != text)
continue;
Bprint(&tabout, ".nr %d ", TMP);
- wide(ss, FN(vforml, icol), SZ(vforml, icol));
+ wide(ss, FN(vforml, icol), SZ(vforml, icol));
Bprint(&tabout, "\n");
Bprint(&tabout, ".if \\n(%d<\\n(%d .nr %d \\n(%d\n",
S1, TMP, S1, TMP);
case 'l':
if (real(ss = table[ilin][icol].col) && !vspen(ss)) {
s = (int)(uintptr)ss;
- if (tx(s) != text)
+ if (tx(s) != text)
continue;
Bprint(&tabout, ".nr %d ", TMP);
- wide(ss, FN(vforml, icol), SZ(vforml, icol));
+ wide(ss, FN(vforml, icol), SZ(vforml, icol));
Bprint(&tabout, "\n");
Bprint(&tabout, ".if \\n(%2s<\\n(%d .nr %2s \\n(%d\n",
reg(icol, CRIGHT), TMP, reg(icol, CRIGHT), TMP);
}
}
if (acase[icol]) {
- Bprint(&tabout, ".if \\n(%d>=\\n(%2s .nr %2s \\n(%du+2n\n",
+ Bprint(&tabout, ".if \\n(%d>=\\n(%2s .nr %2s \\n(%du+2n\n",
S2, reg(icol, CRIGHT), reg(icol, CRIGHT), S2);
}
if (doubled[icol]) {
for (ilin = 0; ilin < nlin; ilin++)
if (k = lspan(ilin, icol)) {
ss = table[ilin][icol-k].col;
- if (!real(ss) || barent(ss) || vspen(ss) )
+ if (!real(ss) || barent(ss) || vspen(ss) )
continue;
Bprint(&tabout, ".nr %d ", TMP);
wide(table[ilin][icol-k].col, FN(ilin, icol - k), SZ(ilin, icol - k));
for (ik = k; ik >= 0; ik--) {
Bprint(&tabout, "-\\n(%2s", reg(icol - ik, CRIGHT));
- if (!expflg && ik > 0)
+ if (!expflg && ik > 0)
Bprint(&tabout, "-%dn", sep[icol-ik]);
}
Bprint(&tabout, "\n");
}
}
}
- if (textflg)
+ if (textflg)
untext();
/* if even requested, make all columns widest width */
if (evenflg) {
Bprint(&tabout, ".nr %d 0\n", TMP);
for (icol = 0; icol < ncol; icol++) {
- if (evenup[icol] == 0)
+ if (evenup[icol] == 0)
continue;
Bprint(&tabout, ".if \\n(%2s>\\n(%d .nr %d \\n(%2s\n",
reg(icol, CRIGHT), TMP, TMP, reg(icol, CRIGHT));
Bprint(&tabout, ".nr %d 1n\n", TMP);
Bprint(&tabout, ".nr %2s 0\n", reg(-1, CRIGHT));
tsep = (boxflg || allflg || dboxflg || left1flg) ? 2 : 0;
- if (sep[-1] >= 0)
+ if (sep[-1] >= 0)
tsep = sep[-1];
for (icol = 0; icol < ncol; icol++) {
Bprint(&tabout, ".nr %2s \\n(%2s+((%d*\\n(%d)/2)\n", reg(icol, CLEFT),
{
if (point(s)) {
Bprint(&tabout, "\\w%c", F1);
- if (*fn > 0)
+ if (*fn > 0)
putfont(fn);
- if (*size)
+ if (*size)
putsize(size);
Bprint(&tabout, "%s", s);
- if (*fn > 0)
+ if (*fn > 0)
putfont("P");
- if (*size)
+ if (*size)
putsize("0");
Bprint(&tabout, "%c", F1);
} else
{
return (point(s) && s[0] == '\\' && s[1] == 'R');
}
-
-
blob - 2fa9de53bbfcc30b7b04135f7d22bf590983795f
blob + 6a873d617abcecb7aab65717378d84aeeffdb919
--- src/cmd/tbl/t7.c
+++ src/cmd/tbl/t7.c
{
int i;
- if (boxflg || allflg || dboxflg)
+ if (boxflg || allflg || dboxflg)
need();
if (ctrflg) {
Bprint(&tabout, ".nr #I \\n(.i\n");
int
ifline(char *s)
{
- if (!point(s))
+ if (!point(s))
return(0);
- if (s[0] == '\\')
+ if (s[0] == '\\')
s++;
- if (s[1] )
+ if (s[1] )
return(0);
- if (s[0] == '_')
+ if (s[0] == '_')
return('-');
- if (s[0] == '=')
+ if (s[0] == '=')
return('=');
return(0);
}
Bprint(&tabout, ".if \\n(T. ");
drawline(nlin, 0, ncol, dboxflg ? '=' : '-', 1, 0);
Bprint(&tabout, "\n.if \\n(T. .vs\n");
- /* T. is really an argument to a macro but because of
+ /* T. is really an argument to a macro but because of
eqn we don't dare pass it as an argument and reference by $1 */
}
for (c = 0; c < ncol; c++) {
Bprint(&tabout, "..\n");
Bprint(&tabout, ".ec\n");
}
-
-
blob - bfa21ecffee60452851ca7c81923daf7f5e46729
blob + 26375df5a71854ad8c8dca5b4c469c86c0d2644b
--- src/cmd/tbl/t8.c
+++ src/cmd/tbl/t8.c
char *ss, *size, *fn, *rct;
cmidx = watchout = vspf = exvspen = 0;
- if (i == 0)
+ if (i == 0)
once = 0;
if (i == 0 && ( allflg || boxflg || dboxflg))
fullwide(0, dboxflg ? '=' : '-');
if (instead[nl] == 0 && fullbot[nl] == 0)
for (c = 0; c < ncol; c++) {
ss = table[nl][c].col;
- if (ss == 0)
+ if (ss == 0)
continue;
if (vspen(ss)) {
for (ip = nl; ip < nlin; ip = next(ip))
- if (!vspen(ss = table[ip][c].col))
+ if (!vspen(ss = table[ip][c].col))
break;
s = (int)(uintptr)ss;
if (s > 0 && s < 128)
Bprint(&tabout, ".ne \\n(%c|u+\\n(.Vu\n", (int)s);
continue;
}
- if (point(ss))
+ if (point(ss))
continue;
s = (int)(uintptr)ss;
Bprint(&tabout, ".ne \\n(%c|u+\\n(.Vu\n", s);
}
for (c = 0; c < ncol; c++) {
if (instead[nl] == 0 && fullbot[nl] == 0)
- if (vspen(table[nl][c].col))
+ if (vspen(table[nl][c].col))
vspf = 1;
if (lf >= 0)
- if (vspen(table[lf][c].col))
+ if (vspen(table[lf][c].col))
vspf = 1;
}
if (vspf) {
chfont = 0;
for (c = 0; c < ncol; c++) {
ss = table[nl][c].col;
- if (ss == 0)
+ if (ss == 0)
continue;
if(font[c][stynum[nl]])
chfont = 1;
drawvert(lf, i, c, lwid);
vct += 2;
}
- if (rightl && c + 1 == ncol)
+ if (rightl && c + 1 == ncol)
continue;
vforml = i;
for (lf = prev(nl); lf >= 0 && vspen(table[lf][c].col); lf = prev(lf))
form = ctype(vforml, c);
if (form != 's') {
rct = reg(c, CLEFT);
- if (form == 'a')
+ if (form == 'a')
rct = reg(c, CMID);
- if (form == 'n' && table[nl][c].rcol && lused[c] == 0)
+ if (form == 'n' && table[nl][c].rcol && lused[c] == 0)
rct = reg(c, CMID);
Bprint(&tabout, "\\h'|\\n(%2su'", rct);
}
}
}
Bprint(&tabout, "%c%c", F1, F2);
- if (uphalf)
+ if (uphalf)
Bprint(&tabout, "\\u");
puttext(ss, fn, size);
- if (uphalf)
+ if (uphalf)
Bprint(&tabout, "\\d");
Bprint(&tabout, "%c", F1);
}
break;
}
case 'c':
- form = 3;
+ form = 3;
break;
case 'r':
- form = 2;
+ form = 2;
break;
case 'l':
- form = 1;
+ form = 1;
break;
case '-':
case '=':
vspf = 1;
else
{
- if (uphalf)
+ if (uphalf)
Bprint(&tabout, "\\u");
puttext(ss, fn, size);
- if (uphalf)
+ if (uphalf)
Bprint(&tabout, "\\d");
}
if (form != 2)
ip = prev(nl);
if (ip >= 0)
if (vspen(table[ip][c].col)) {
- exvspen = (c + 1 < ncol) && vspen(table[ip][c+1].col) &&
- (topat[c] == topat[c+1]) &&
+ exvspen = (c + 1 < ncol) && vspen(table[ip][c+1].col) &&
+ (topat[c] == topat[c+1]) &&
(cmidx == (flags[c+1] [stynum[nl]] & (CTOP | CDOWN) == 0))
&& (left(i, c + 1, &lwid) < 0);
if (exvspen == 0) {
}
}
Bprint(&tabout, "\n");
- if (allh(i) && !pr1403)
+ if (allh(i) && !pr1403)
Bprint(&tabout, ".vs \\n(%du\n", SVS);
if (watchout)
funnies(i, nl);
putfont(fn);
putsize(size);
Bprint(&tabout, "%s", s);
- if (*fn > 0)
+ if (*fn > 0)
Bprint(&tabout, "\\f\\n(%2d", S1);
- if (size != 0)
+ if (size != 0)
putsize("0");
}
}
Bprint(&tabout, ".nr %d \\n(##\n", S1); /* bottom position */
for (c = 0; c < ncol; c++) {
ss = table[lin][c].col;
- if (point(ss))
+ if (point(ss))
continue;
- if (ss == 0)
+ if (ss == 0)
continue;
s = (int)(uintptr)ss;
Bprint(&tabout, ".sp |\\n(##u-1v\n");
}
Bprint(&tabout, ".%c+\n", s);
Bprint(&tabout, ".in -\\n(%du\n", SIND);
- if (*fn > 0)
+ if (*fn > 0)
putfont("P");
Bprint(&tabout, ".mk %d\n", S2);
Bprint(&tabout, ".if \\n(%d>\\n(%d .nr %d \\n(%d\n", S2, S1, S1, S2);
if (s && *s)
Bprint(&tabout, "\\s%s", s);
}
-
-
blob - 69e9d6c776fd3b20c403e8f9b523545c8eff05be
blob + db3a4d11692b389256bf218061b2377764fe7717
--- src/cmd/tbl/t9.c
+++ src/cmd/tbl/t9.c
instead[0] = (char *)0;
if (dataln[1] == 0)
switch (dataln[0]) {
- case '_':
- fullbot[0] = '-';
- putline(useln, 0);
+ case '_':
+ fullbot[0] = '-';
+ putline(useln, 0);
return(1);
- case '=':
- fullbot[0] = '=';
- putline(useln, 0);
+ case '=':
+ fullbot[0] = '=';
+ putline(useln, 0);
return(1);
}
for (icol = 0; icol < ncol; icol++) {
}
while (ctype(useln, icol + 1) == 's') /* spanning */
table[0][++icol].col = "";
- if (ch == '\0')
+ if (ch == '\0')
break;
}
while (++icol < ncol)
exstore = exspace; /* reuse space for numerical items */
return(1);
}
-
-
blob - 5cc59880165974a8ef51d2d1af76c235754e3869
blob + 213d371c243247223ceef18ae6330d44f4b24d32
--- src/cmd/tbl/tb.c
+++ src/cmd/tbl/tb.c
for (c = 0; c < ncol; c++) {
used[c] = lused[c] = rused[c] = 0;
for (i = 0; i < nlin; i++) {
- if (instead[i] || fullbot[i])
+ if (instead[i] || fullbot[i])
continue;
k = ctype(i, c);
- if (k == '-' || k == '=')
+ if (k == '-' || k == '=')
continue;
if ((k == 'n' || k == 'a')) {
rused[c] |= real(table[i][c].rcol);
int
real(char *s)
{
- if (s == 0)
+ if (s == 0)
return(0);
- if (!point(s))
+ if (!point(s))
return(1);
- if (*s == 0)
+ if (*s == 0)
return(0);
return(1);
}
tpcount = -1;
exstore = 0;
}
-
-
blob - a89fc0f0415ac4d31b5b9c357981bf666e139a31
blob + 0b9d196100561dadf217daad581d57b1ffa49753
--- src/cmd/tbl/tc.c
+++ src/cmd/tbl/tc.c
had[icol] = 0;
F1 = F2 = 0;
for (ilin = 0; ilin < nlin; ilin++) {
- if (instead[ilin])
+ if (instead[ilin])
continue;
- if (fullbot[ilin])
+ if (fullbot[ilin])
continue;
for (icol = 0; icol < ncol; icol++) {
k = ctype(ilin, icol);
}
/* choose first funny character */
for (
- s = "\002\003\005\006\007!%&#/?,:;<=>@`^~_{}+-*ABCDEFGHIJKMNOPQRSTUVWXYZabcdefgjkoqrstwxyz";
+ s = "\002\003\005\006\007!%&#/?,:;<=>@`^~_{}+-*ABCDEFGHIJKMNOPQRSTUVWXYZabcdefgjkoqrstwxyz";
*s; s++) {
if (had[(unsigned char)*s] == 0) {
F1 = (unsigned char)*s;
}
/* choose second funny character */
for (
- s = "\002\003\005\006\007:_~^`@;,<=>#%&!/?{}+-*ABCDEFGHIJKMNOPQRSTUVWXZabcdefgjkoqrstuwxyz";
+ s = "\002\003\005\006\007:_~^`@;,<=>#%&!/?{}+-*ABCDEFGHIJKMNOPQRSTUVWXZabcdefgjkoqrstuwxyz";
*s; s++) {
if (had[(unsigned char)*s] == 0) {
F2 = (unsigned char)*s;
int s = (int)(uintptr)ss;
return(s >= 128 || s < 0);
}
-
-
blob - 3df8d445d4463329c46b451afbc6a8ea99279f0b
blob + 54df7e82e1b1da992d59ac4237273af4db49dd0c
--- src/cmd/tbl/te.c
+++ src/cmd/tbl/te.c
iline++;
return(c);
}
-
-
blob - 3791c32fe25ffc0804444615064a174ec1b81ad5
blob + 097dfe36a5b2315f911090bc5c4d839ce3347c12
--- src/cmd/tbl/tf.c
+++ src/cmd/tbl/tf.c
{
Bprint(&tabout, ".fc\n");
}
-
-
blob - 3afc88c688965e62c8ea9812285d3afcb70ae691
blob + 7b5374bde1b708d6960636709dfb72c7d835e7b6
--- src/cmd/tbl/tg.c
+++ src/cmd/tbl/tg.c
char *vs;
startline = iline;
- if (texname == 0)
+ if (texname == 0)
error("Too many text block diversions");
if (textflg == 0) {
Bprint(&tabout, ".nr %d \\n(.lu\n", SL); /* remember old line length */
Bprint(&tabout, ".br\n");
Bprint(&tabout, ".di %c+\n", texname);
rstofill();
- if (fn && *fn)
+ if (fn && *fn)
Bprint(&tabout, ".nr %d \\n(.f\n.ft %s\n", S1, fn);
Bprint(&tabout, ".ft \\n(.f\n"); /* protect font */
vs = vsize[icol][stynum[ilin]];
if ((sz && *sz) || (vs && *vs)) {
Bprint(&tabout, ".nr %d \\n(.v\n", S9);
- if (vs == 0 || *vs == 0)
+ if (vs == 0 || *vs == 0)
vs = "\\n(.s+2";
if (sz && *sz)
Bprint(&tabout, ".ps %s\n", sz);
iline = startline;
error("missing closing T}");
}
- if (line[0] == 'T' && line[1] == '}' && line[2] == tab)
+ if (line[0] == 'T' && line[1] == '}' && line[2] == tab)
break;
- if (match("T}", line))
+ if (match("T}", line))
break;
Bprint(&tabout, "%s\n", line);
}
- if (fn && *fn)
+ if (fn && *fn)
Bprint(&tabout, ".ft \\n(%d\n", S1);
- if (sz && *sz)
+ if (sz && *sz)
Bprint(&tabout, ".br\n.ps\n.vs\n");
Bprint(&tabout, ".br\n");
Bprint(&tabout, ".di\n");
Bprint(&tabout, ".nf\n");
Bprint(&tabout, ".ll \\n(%du\n", SL);
}
-
-
blob - ef995bbb35e0237a497ced61647d691de3c7f3fd
blob + d4a2ab4db46a15706c6a082ef8db2d267fd2c8cc
--- src/cmd/tbl/ti.c
+++ src/cmd/tbl/ti.c
if (c >= ncol || c == 0) {
if (dboxflg) {
- if (i == 0)
+ if (i == 0)
return(BOT);
- if (i >= nlin)
+ if (i >= nlin)
return(TOP);
return(THRU);
}
kl = 0;
else
kl = lefdata(allh(i) ? i + 1 : i, c);
- if (ku == 2 && kl == 2)
+ if (ku == 2 && kl == 2)
return(THRU);
- if (ku == 2)
+ if (ku == 2)
return(TOP);
- if (kl == BOT)
+ if (kl == BOT)
return(2);
return(0);
}
return(RIGHT);
return(THRU);
}
- if (i >= nlin)
+ if (i >= nlin)
return(0);
kl = c > 0 ? thish (i, c - 1) : 0;
if (kl <= 1 && i > 0 && allh(up1(i)))
kr = thish(i, c);
if (kr <= 1 && i > 0 && allh(up1(i)))
kr = c > 0 ? thish(up1(i), c) : 0;
- if (kl == '=' && kr == '=')
+ if (kl == '=' && kr == '=')
return(THRU);
- if (kl == '=')
+ if (kl == '=')
return(LEFT);
- if (kr == '=')
+ if (kr == '=')
return(RIGHT);
return(0);
}
up1(int i)
{
i--;
- while (instead[i] && i > 0)
+ while (instead[i] && i > 0)
i--;
return(i);
}
-
-
blob - 5b58f0d1bb82e806a4ed42aab6f4f63aa4b36805
blob + cee294c4fe462c6c4a58abdd0693a41d11343628
--- src/cmd/tbl/tm.c
+++ src/cmd/tbl/tm.c
str = p;
if (ba == 0) {
for (dpoint = 0; *str; str++) {
- if (*str == '.' && !ineqn(str, p) &&
- (str > p && digit(*(str - 1)) ||
+ if (*str == '.' && !ineqn(str, p) &&
+ (str > p && digit(*(str - 1)) ||
digit(*(str + 1))))
dpoint = str;
}
}
if (!dpoint && p == str) /* not numerical, don't split */
return(0);
- if (dpoint)
+ if (dpoint)
str = dpoint;
} else
str = ba;
}
return(0);
}
-
-
blob - 7d586e8b8388622eb1f651460a936bb16da1dcdc
blob + 6a626115332f05b4b7dfb579f4cc1abae10d274a
--- src/cmd/tbl/tr.c
+++ src/cmd/tbl/tr.c
error("Too many columns for registers");
return (nregs[qcol*place+col]);
}
-
-
blob - 43cc84ecdf85ab5021de973c4d5e28572364d073
blob + 2a98b5d639a1101c688c700ad1236e888f3a05fb
--- src/cmd/tbl/ts.c
+++ src/cmd/tbl/ts.c
int c;
while ((c = *small++) == *big++)
- if (c == 0)
+ if (c == 0)
return(1);
return(c == 0);
}
while (*s++ = *t++)
;
}
-
-
blob - 96270b7580ae4955da049991ce787dc831ca9895
blob + 54c6180e8515876023ebfdfa2cad6a8300d8f1a9
--- src/cmd/tbl/tt.c
+++ src/cmd/tbl/tt.c
{
int k;
- if (ctype(i, c) != 's')
+ if (ctype(i, c) != 's')
return(0);
c++;
if (c < ncol && ctype(i, c) == 's')
/* also at least one must be horizontl */
int c, one, k;
- if (fullbot[i])
+ if (fullbot[i])
return(1);
- if (i >= nlin)
+ if (i >= nlin)
return(dboxflg || boxflg);
for (one = c = 0; c < ncol; c++) {
k = thish(i, c);
- if (k == 0)
+ if (k == 0)
return(0);
- if (k == 1)
+ if (k == 1)
continue;
one = 1;
}
if (c < 0)
return(0);
- if (i < 0)
+ if (i < 0)
return(0);
t = ctype(i, c);
if (t == '_' || t == '-')
return('-');
if (t == '=')
return('=');
- if (t == '^')
+ if (t == '^')
return(1);
if (fullbot[i] )
return(fullbot[i]);
- if (t == 's')
+ if (t == 's')
return(thish(i, c - 1));
- if (t == 0)
+ if (t == 0)
return(1);
pc = &table[i][c];
s = (t == 'a' ? pc->rcol : pc->col);
if (s == 0 || (point(s) && *s == 0))
return(1);
- if (vspen(s))
+ if (vspen(s))
return(1);
if (t = barent( s))
return(t);
return(0);
}
-
-
blob - 217869e1a46759cae0e91957d6043354f0e03b90
blob + 940895775a60290d4618207830d88bc5723ef88e
--- src/cmd/tbl/tu.c
+++ src/cmd/tbl/tu.c
int cr, type, shortl;
type = thish(i, c);
- if (type == 0)
+ if (type == 0)
return;
shortl = (table[i][c].col[0] == '\\');
if (c > 0 && !shortl && thish(i, c - 1) == type)
lcount = 0;
exhr = exhl = "";
switch (lintype) {
- case '-':
+ case '-':
lcount = 1;
break;
- case '=':
- lcount = pr1403 ? 1 : 2;
+ case '=':
+ lcount = pr1403 ? 1 : 2;
break;
- case SHORTLINE:
- lcount = 1;
+ case SHORTLINE:
+ lcount = 1;
break;
}
- if (lcount <= 0)
+ if (lcount <= 0)
return;
nodata = cr - cl >= ncol || noheight || allh(i);
if (!nodata)
tohcol(cl);
if (lcount > 1) {
switch (interv(i, cl)) {
- case TOP:
- exhl = ln == 0 ? "1p" : "-1p";
+ case TOP:
+ exhl = ln == 0 ? "1p" : "-1p";
break;
- case BOT:
- exhl = ln == 1 ? "1p" : "-1p";
+ case BOT:
+ exhl = ln == 1 ? "1p" : "-1p";
break;
- case THRU:
- exhl = "1p";
+ case THRU:
+ exhl = "1p";
break;
}
if (exhl[0])
Bprint(&tabout, "\\h'%s'", exhl);
} else if (lcount == 1) {
switch (interv(i, cl)) {
- case TOP:
- case BOT:
- exhl = "-1p";
+ case TOP:
+ case BOT:
+ exhl = "-1p";
break;
- case THRU:
- exhl = "1p";
+ case THRU:
+ exhl = "1p";
break;
}
if (exhl[0])
}
if (lcount > 1) {
switch (interv(i, cr + 1)) {
- case TOP:
- exhr = ln == 0 ? "-1p" : "+1p";
- break;
- case BOT:
- exhr = ln == 1 ? "-1p" : "+1p";
+ case TOP:
+ exhr = ln == 0 ? "-1p" : "+1p";
break;
- case THRU:
- exhr = "-1p";
+ case BOT:
+ exhr = ln == 1 ? "-1p" : "+1p";
break;
+ case THRU:
+ exhr = "-1p";
+ break;
}
} else if (lcount == 1) {
switch (interv(i, cr + 1)) {
- case TOP:
- case BOT:
- exhr = "+1p";
+ case TOP:
+ case BOT:
+ exhr = "+1p";
break;
- case THRU:
- exhr = "-1p";
+ case THRU:
+ exhr = "-1p";
break;
}
}
/* returns number of line where it starts */
/* stores into lwid the kind of line */
*lwidp = 0;
- if (i < 0)
+ if (i < 0)
return(-1);
kind = lefdata(i, c);
- if (kind == 0)
+ if (kind == 0)
return(-1);
if (i + 1 < nlin)
- if (lefdata(next(i), c) == kind)
+ if (lefdata(next(i), c) == kind)
return(-1);
li = i;
while (i >= 0 && lefdata(i, c) == kind)
i = prev(li = i);
- if (prev(li) == -1)
+ if (prev(li) == -1)
li = 0;
*lwidp = kind;
for (lj = i + 1; lj < li; lj++)
{
int ck;
- if (i >= nlin)
+ if (i >= nlin)
i = nlin - 1;
if (ctype(i, c) == 's') {
for (ck = c; ctype(i, ck) == 's'; ck--)
}
i = stynum[i];
i = lefline[c][i];
- if (i > 0)
+ if (i > 0)
return(i);
- if (dboxflg && c == 0)
+ if (dboxflg && c == 0)
return(2);
if (allflg)
return(1);
- if (boxflg && c == 0)
+ if (boxflg && c == 0)
return(1);
return(0);
}
{
while (i + 1 < nlin) {
i++;
- if (!fullbot[i] && !instead[i])
+ if (!fullbot[i] && !instead[i])
break;
}
return(i);
;
return(i);
}
-
-
blob - 19a4b03fda16cf4977869fc761af16e0a159c98b
blob + 0fb330cc3db36e690552985089108d923f9e9945
--- src/cmd/tbl/tv.c
+++ src/cmd/tbl/tv.c
end++;
vm = 'v';
/* note: nr 35 has value of 1m outside of linesize */
- while (instead[end])
+ while (instead[end])
end++;
for (ln = 0; ln < lwid; ln++) {
epb = ept = 0;
pos = 2 * ln - lwid + 1;
- if (pos != tp)
+ if (pos != tp)
Bprint(&tabout, "\\h'%dp'", pos - tp);
tp = pos;
if (end < nlin) {
else
switch (midbar(end, c)) {
case '-':
- exb = "1v-.5m";
+ exb = "1v-.5m";
break;
case '=':
exb = "1v-.5m";
- epb = 1;
+ epb = 1;
break;
}
}
if (lwid > 1)
switch (interh(end, c)) {
- case THRU:
- epb -= 1;
+ case THRU:
+ epb -= 1;
break;
- case RIGHT:
- epb += (ln == 0 ? 1 : -1);
+ case RIGHT:
+ epb += (ln == 0 ? 1 : -1);
break;
- case LEFT:
- epb += (ln == 1 ? 1 : -1);
+ case LEFT:
+ epb += (ln == 1 ? 1 : -1);
break;
}
if (lwid == 1)
switch (interh(end, c)) {
- case THRU:
- epb -= 1;
+ case THRU:
+ epb -= 1;
break;
- case RIGHT:
- case LEFT:
- epb += 1;
+ case RIGHT:
+ case LEFT:
+ epb += 1;
break;
}
if (start > 0) {
sl = start - 1;
- while (sl >= 0 && instead[sl])
+ while (sl >= 0 && instead[sl])
sl--;
if (sl >= 0 && (fullbot[sl] || allh(sl)))
ept = 0;
else if (sl >= 0)
switch (midbar(sl, c)) {
case '-':
- ext = ".5m";
+ ext = ".5m";
break;
case '=':
- ext = ".5m";
- ept = -1;
+ ext = ".5m";
+ ept = -1;
break;
default:
- vm = 'm';
+ vm = 'm';
break;
}
else
}
if (lwid > 1)
switch (interh(start, c)) {
- case THRU:
- ept += 1;
+ case THRU:
+ ept += 1;
break;
- case LEFT:
- ept += (ln == 0 ? 1 : -1);
+ case LEFT:
+ ept += (ln == 0 ? 1 : -1);
break;
- case RIGHT:
- ept += (ln == 1 ? 1 : -1);
+ case RIGHT:
+ ept += (ln == 1 ? 1 : -1);
break;
}
else if (lwid == 1)
switch (interh(start, c)) {
- case THRU:
- ept += 1;
+ case THRU:
+ ept += 1;
break;
- case LEFT:
- case RIGHT:
- ept -= 1;
+ case LEFT:
+ case RIGHT:
+ ept -= 1;
break;
}
if (exb)
int
barent(char *s)
{
- if (s == 0)
+ if (s == 0)
return (1);
- if (!point(s))
+ if (!point(s))
return(0);
- if (s[0] == '\\')
+ if (s[0] == '\\')
s++;
if (s[1] != 0)
return(0);
}
return(0);
}
-
-
blob - 293ffad1afc9cdcf4c6608578a3c8ec4f0c5a2a2
blob + da1ebe0a3a1908e9a644677c537e80fe29e79cb3
--- src/cmd/tcs/conv_ksc.c
+++ src/cmd/tcs/conv_ksc.c
if(p > obuf)
write(1, obuf, p-obuf);
}
-
blob - e488033694d619ebb7ef6621aa4aa38a56f85893
blob + feb2d755ff6278b1a7cddb498af3c25cd97465ba
--- src/cmd/tcs/font/bbits.c
+++ src/cmd/tcs/font/bbits.c
enum {
Charsperfont = 157,
Void1b = (0xC6-0xA2)*Charsperfont+0x3f,
- Void1e = (0xC9-0xA2)*Charsperfont - 1
+ Void1e = (0xC9-0xA2)*Charsperfont - 1
};
Bitmap *
blob - 93bd9e5ad61aa02ae5eb886474cfa3bbee0eb4fb
blob + be71c0800bda584ec877cec6f9a9137f66fc443a
--- src/cmd/tcs/html.c
+++ src/cmd/tcs/html.c
hnamecmp(const void *va, const void *vb)
{
Hchar *a, *b;
-
+
a = (Hchar*)va;
b = (Hchar*)vb;
return strcmp(a->s, b->s);
hrunecmp(const void *va, const void *vb)
{
Hchar *a, *b;
-
+
a = (Hchar*)va;
b = (Hchar*)vb;
return a->r - b->r;
{
static int init;
int i;
-
+
if(init)
return;
init = 1;
memmove(byrune, byname, sizeof byrune);
-
+
/* Eliminate names we aren't allowed to generate. */
for(i=0; i<nelem(byrune); i++){
if(byrune[i].s[0] == '_'){
byname[i].s++;
}
}
-
+
qsort(byname, nelem(byname), sizeof byname[0], hnamecmp);
qsort(byrune, nelem(byrune), sizeof byrune[0], hrunecmp);
}
{
Hchar *h;
int n, m, x;
-
+
h = byname;
n = nelem(byname);
while(n > 0){
Rune rbuf[N];
Rune *r, *er;
int c, i;
-
+
USED(x);
-
+
html_init();
r = rbuf;
er = rbuf+N;
char *s;
Biobuf b;
Rune *er;
-
+
USED(x);
html_init();
Binit(&b, 1, OWRITE);
}
Bflush(&b);
}
-
blob - 9b6d1dcc6465c665d593c3aab939d85959acbf91
blob + 9c726ee26c79e84a94e620704c6afa1d04f2f4c6
--- src/cmd/tcs/jis.h
+++ src/cmd/tcs/jis.h
* Returns 1 if they are, or 0 otherwise.
*/
#define CANJ2S(_h, _l) (CANJ2SB(_h) && CANJ2SB(_l))
-
blob - 90d6793bb3e1c399500a84a5005525507b6906ee
blob + 05b0ecafa11b7b39f6064668dbb434b1a0356e04
--- src/cmd/tcs/ksc.c
+++ src/cmd/tcs/ksc.c
#include "ksc.h"
/* KSC5601 -> Unicode mapping table, compressed for the 94*94 codeset. */
-/*
+/*
* Unlike kuten-table, needed offset is 33 (0x21) instead of
* 32 for 7-bit portion of each byte. i.e., a Unicode
* codepoint for KSC's codepoint (n, m) would be found at
*/
long tabksc5601[] = {
/* KSC 5601 -> Unicode mapping table; max codepoint = 0x7d7e */
- 0x3000, 0x3001, 0x3002, 0x00b7, 0x2025, 0x2026, 0x00a8, 0x3003, 0x00ad,
- 0x2015, 0x2225, 0xff3c, 0x223c, 0x2018, 0x2019, 0x201c, 0x201d, 0x3014,
- 0x3015, 0x3008, 0x3009, 0x300a, 0x300b, 0x300c, 0x300d, 0x300e, 0x300f,
- 0x3010, 0x3011, 0x00b1, 0x00d7, 0x00f7, 0x2260, 0x2264, 0x2265, 0x221e,
- 0x2234, 0x00b0, 0x2032, 0x2033, 0x2103, 0x212b, 0xffe0, 0xffe1, 0xffe5,
- 0x2642, 0x2640, 0x2220, 0x22a5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252,
- 0x00a7, 0x203b, 0x2606, 0x2605, 0x25cb, 0x25cf, 0x25ce, 0x25c7, 0x25c6,
- 0x25a1, 0x25a0, 0x25b3, 0x25b2, 0x25bd, 0x25bc, 0x2192, 0x2190, 0x2191,
- 0x2193, 0x2194, 0x3013, 0x226a, 0x226b, 0x221a, 0x223d, 0x221d, 0x2235,
- 0x222b, 0x222c, 0x2208, 0x220b, 0x2286, 0x2287, 0x2282, 0x2283, 0x222a,
- 0x2229, 0x2227, 0x2228, 0xffe2, 0x21d2, 0x21d4, 0x2200, 0x2203, 0x00b4,
- 0xff5e, 0x02c7, 0x02d8, 0x02dd, 0x02da, 0x02d9, 0x00b8, 0x02db, 0x00a1,
- 0x00bf, 0x02d0, 0x222e, 0x2211, 0x220f, 0x00a4, 0x2109, 0x2030, 0x25c1,
- 0x25c0, 0x25b7, 0x25b6, 0x2664, 0x2660, 0x2661, 0x2665, 0x2667, 0x2663,
- 0x25c9, 0x25c8, 0x25a3, 0x25d0, 0x25d1, 0x2592, 0x25a4, 0x25a5, 0x25a8,
- 0x25a7, 0x25a6, 0x25a9, 0x2668, 0x260f, 0x260e, 0x261c, 0x261e, 0x00b6,
- 0x2020, 0x2021, 0x2195, 0x2197, 0x2199, 0x2196, 0x2198, 0x266d, 0x2669,
- 0x266a, 0x266c, 0x327f, 0x321c, 0x2116, 0x33c7, 0x2122, 0x33c2, 0x33d8,
- 0x2121, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, 0xff01,
- 0xff02, 0xff03, 0xff04, 0xff05, 0xff06, 0xff07, 0xff08, 0xff09, 0xff0a,
- 0xff0b, 0xff0c, 0xff0d, 0xff0e, 0xff0f, 0xff10, 0xff11, 0xff12, 0xff13,
- 0xff14, 0xff15, 0xff16, 0xff17, 0xff18, 0xff19, 0xff1a, 0xff1b, 0xff1c,
- 0xff1d, 0xff1e, 0xff1f, 0xff20, 0xff21, 0xff22, 0xff23, 0xff24, 0xff25,
- 0xff26, 0xff27, 0xff28, 0xff29, 0xff2a, 0xff2b, 0xff2c, 0xff2d, 0xff2e,
- 0xff2f, 0xff30, 0xff31, 0xff32, 0xff33, 0xff34, 0xff35, 0xff36, 0xff37,
- 0xff38, 0xff39, 0xff3a, 0xff3b, 0xffe6, 0xff3d, 0xff3e, 0xff3f, 0xff40,
- 0xff41, 0xff42, 0xff43, 0xff44, 0xff45, 0xff46, 0xff47, 0xff48, 0xff49,
- 0xff4a, 0xff4b, 0xff4c, 0xff4d, 0xff4e, 0xff4f, 0xff50, 0xff51, 0xff52,
- 0xff53, 0xff54, 0xff55, 0xff56, 0xff57, 0xff58, 0xff59, 0xff5a, 0xff5b,
- 0xff5c, 0xff5d, 0xffe3, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136,
- 0x3137, 0x3138, 0x3139, 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
- 0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147, 0x3148,
- 0x3149, 0x314a, 0x314b, 0x314c, 0x314d, 0x314e, 0x314f, 0x3150, 0x3151,
- 0x3152, 0x3153, 0x3154, 0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315a,
- 0x315b, 0x315c, 0x315d, 0x315e, 0x315f, 0x3160, 0x3161, 0x3162, 0x3163,
- 0x3164, 0x3165, 0x3166, 0x3167, 0x3168, 0x3169, 0x316a, 0x316b, 0x316c,
- 0x316d, 0x316e, 0x316f, 0x3170, 0x3171, 0x3172, 0x3173, 0x3174, 0x3175,
- 0x3176, 0x3177, 0x3178, 0x3179, 0x317a, 0x317b, 0x317c, 0x317d, 0x317e,
- 0x317f, 0x3180, 0x3181, 0x3182, 0x3183, 0x3184, 0x3185, 0x3186, 0x3187,
- 0x3188, 0x3189, 0x318a, 0x318b, 0x318c, 0x318d, 0x318e, 0x2170, 0x2171,
- 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, -1,
- -1, -1, -1, -1, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164,
- 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, -1, -1, -1, -1,
- -1, -1, -1, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
- 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
- 0x03a0, 0x03a1, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9,
- -1, -1, -1, -1, -1, -1, -1, -1, 0x03b1,
- 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba,
- 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03c0, 0x03c1, 0x03c3, 0x03c4,
- 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, -1, -1, -1, -1,
- -1, -1, 0x2500, 0x2502, 0x250c, 0x2510, 0x2518, 0x2514, 0x251c,
- 0x252c, 0x2524, 0x2534, 0x253c, 0x2501, 0x2503, 0x250f, 0x2513, 0x251b,
- 0x2517, 0x2523, 0x2533, 0x252b, 0x253b, 0x254b, 0x2520, 0x252f, 0x2528,
- 0x2537, 0x253f, 0x251d, 0x2530, 0x2525, 0x2538, 0x2542, 0x2512, 0x2511,
- 0x251a, 0x2519, 0x2516, 0x2515, 0x250e, 0x250d, 0x251e, 0x251f, 0x2521,
- 0x2522, 0x2526, 0x2527, 0x2529, 0x252a, 0x252d, 0x252e, 0x2531, 0x2532,
- 0x2535, 0x2536, 0x2539, 0x253a, 0x253d, 0x253e, 0x2540, 0x2541, 0x2543,
- 0x2544, 0x2545, 0x2546, 0x2547, 0x2548, 0x2549, 0x254a, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 0x3395, 0x3396, 0x3397,
- 0x2113, 0x3398, 0x33c4, 0x33a3, 0x33a4, 0x33a5, 0x33a6, 0x3399, 0x339a,
- 0x339b, 0x339c, 0x339d, 0x339e, 0x339f, 0x33a0, 0x33a1, 0x33a2, 0x33ca,
- 0x338d, 0x338e, 0x338f, 0x33cf, 0x3388, 0x3389, 0x33c8, 0x33a7, 0x33a8,
- 0x33b0, 0x33b1, 0x33b2, 0x33b3, 0x33b4, 0x33b5, 0x33b6, 0x33b7, 0x33b8,
- 0x33b9, 0x3380, 0x3381, 0x3382, 0x3383, 0x3384, 0x33ba, 0x33bb, 0x33bc,
- 0x33bd, 0x33be, 0x33bf, 0x3390, 0x3391, 0x3392, 0x3393, 0x3394, 0x2126,
- 0x33c0, 0x33c1, 0x338a, 0x338b, 0x338c, 0x33d6, 0x33c5, 0x33ad, 0x33ae,
- 0x33af, 0x33db, 0x33a9, 0x33aa, 0x33ab, 0x33ac, 0x33dd, 0x33d0, 0x33d3,
- 0x33c3, 0x33c9, 0x33dc, 0x33c6, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, 0x00c6, 0x00d0, 0x00aa, 0x0126, -1, 0x0132, -1, 0x013f,
- 0x0141, 0x00d8, 0x0152, 0x00ba, 0x00de, 0x0166, 0x014a, -1, 0x3260,
- 0x3261, 0x3262, 0x3263, 0x3264, 0x3265, 0x3266, 0x3267, 0x3268, 0x3269,
- 0x326a, 0x326b, 0x326c, 0x326d, 0x326e, 0x326f, 0x3270, 0x3271, 0x3272,
- 0x3273, 0x3274, 0x3275, 0x3276, 0x3277, 0x3278, 0x3279, 0x327a, 0x327b,
- 0x24d0, 0x24d1, 0x24d2, 0x24d3, 0x24d4, 0x24d5, 0x24d6, 0x24d7, 0x24d8,
- 0x24d9, 0x24da, 0x24db, 0x24dc, 0x24dd, 0x24de, 0x24df, 0x24e0, 0x24e1,
- 0x24e2, 0x24e3, 0x24e4, 0x24e5, 0x24e6, 0x24e7, 0x24e8, 0x24e9, 0x2460,
- 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469,
- 0x246a, 0x246b, 0x246c, 0x246d, 0x246e, 0x00bd, 0x2153, 0x2154, 0x00bc,
- 0x00be, 0x215b, 0x215c, 0x215d, 0x215e, 0x00e6, 0x0111, 0x00f0, 0x0127,
- 0x0131, 0x0133, 0x0138, 0x0140, 0x0142, 0x00f8, 0x0153, 0x00df, 0x00fe,
- 0x0167, 0x014b, 0x0149, 0x3200, 0x3201, 0x3202, 0x3203, 0x3204, 0x3205,
- 0x3206, 0x3207, 0x3208, 0x3209, 0x320a, 0x320b, 0x320c, 0x320d, 0x320e,
- 0x320f, 0x3210, 0x3211, 0x3212, 0x3213, 0x3214, 0x3215, 0x3216, 0x3217,
- 0x3218, 0x3219, 0x321a, 0x321b, 0x249c, 0x249d, 0x249e, 0x249f, 0x24a0,
- 0x24a1, 0x24a2, 0x24a3, 0x24a4, 0x24a5, 0x24a6, 0x24a7, 0x24a8, 0x24a9,
- 0x24aa, 0x24ab, 0x24ac, 0x24ad, 0x24ae, 0x24af, 0x24b0, 0x24b1, 0x24b2,
- 0x24b3, 0x24b4, 0x24b5, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
- 0x247a, 0x247b, 0x247c, 0x247d, 0x247e, 0x247f, 0x2480, 0x2481, 0x2482,
- 0x00b9, 0x00b2, 0x00b3, 0x2074, 0x207f, 0x2081, 0x2082, 0x2083, 0x2084,
- 0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046, 0x3047, 0x3048, 0x3049,
- 0x304a, 0x304b, 0x304c, 0x304d, 0x304e, 0x304f, 0x3050, 0x3051, 0x3052,
- 0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058, 0x3059, 0x305a, 0x305b,
- 0x305c, 0x305d, 0x305e, 0x305f, 0x3060, 0x3061, 0x3062, 0x3063, 0x3064,
- 0x3065, 0x3066, 0x3067, 0x3068, 0x3069, 0x306a, 0x306b, 0x306c, 0x306d,
- 0x306e, 0x306f, 0x3070, 0x3071, 0x3072, 0x3073, 0x3074, 0x3075, 0x3076,
- 0x3077, 0x3078, 0x3079, 0x307a, 0x307b, 0x307c, 0x307d, 0x307e, 0x307f,
- 0x3080, 0x3081, 0x3082, 0x3083, 0x3084, 0x3085, 0x3086, 0x3087, 0x3088,
- 0x3089, 0x308a, 0x308b, 0x308c, 0x308d, 0x308e, 0x308f, 0x3090, 0x3091,
- 0x3092, 0x3093, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, 0x30a1, 0x30a2, 0x30a3, 0x30a4, 0x30a5,
- 0x30a6, 0x30a7, 0x30a8, 0x30a9, 0x30aa, 0x30ab, 0x30ac, 0x30ad, 0x30ae,
- 0x30af, 0x30b0, 0x30b1, 0x30b2, 0x30b3, 0x30b4, 0x30b5, 0x30b6, 0x30b7,
- 0x30b8, 0x30b9, 0x30ba, 0x30bb, 0x30bc, 0x30bd, 0x30be, 0x30bf, 0x30c0,
- 0x30c1, 0x30c2, 0x30c3, 0x30c4, 0x30c5, 0x30c6, 0x30c7, 0x30c8, 0x30c9,
- 0x30ca, 0x30cb, 0x30cc, 0x30cd, 0x30ce, 0x30cf, 0x30d0, 0x30d1, 0x30d2,
- 0x30d3, 0x30d4, 0x30d5, 0x30d6, 0x30d7, 0x30d8, 0x30d9, 0x30da, 0x30db,
- 0x30dc, 0x30dd, 0x30de, 0x30df, 0x30e0, 0x30e1, 0x30e2, 0x30e3, 0x30e4,
- 0x30e5, 0x30e6, 0x30e7, 0x30e8, 0x30e9, 0x30ea, 0x30eb, 0x30ec, 0x30ed,
- 0x30ee, 0x30ef, 0x30f0, 0x30f1, 0x30f2, 0x30f3, 0x30f4, 0x30f5, 0x30f6,
- -1, -1, -1, -1, -1, -1, -1, -1, 0x0410,
- 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416, 0x0417, 0x0418,
- 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f, 0x0420, 0x0421,
- 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a,
- 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451,
- 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e,
- 0x043f, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
- 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, 0x3400, 0x3401, 0x3402,
- 0x3403, 0x3404, 0x3405, 0x3406, 0x3407, 0x3408, 0x3409, 0x340a, 0x340b,
- 0x340c, 0x340d, 0x340e, 0x340f, 0x3410, 0x3411, 0x3412, 0x3413, 0x3414,
- 0x3415, 0x3416, 0x3417, 0x3418, 0x3419, 0x341a, 0x341b, 0x341c, 0x341d,
- 0x341e, 0x341f, 0x3420, 0x3421, 0x3422, 0x3423, 0x3424, 0x3425, 0x3426,
- 0x3427, 0x3428, 0x3429, 0x342a, 0x342b, 0x342c, 0x342d, 0x342e, 0x342f,
- 0x3430, 0x3431, 0x3432, 0x3433, 0x3434, 0x3435, 0x3436, 0x3437, 0x3438,
- 0x3439, 0x343a, 0x343b, 0x343c, 0x343d, 0x343e, 0x343f, 0x3440, 0x3441,
- 0x3442, 0x3443, 0x3444, 0x3445, 0x3446, 0x3447, 0x3448, 0x3449, 0x344a,
- 0x344b, 0x344c, 0x344d, 0x344e, 0x344f, 0x3450, 0x3451, 0x3452, 0x3453,
- 0x3454, 0x3455, 0x3456, 0x3457, 0x3458, 0x3459, 0x345a, 0x345b, 0x345c,
- 0x345d, 0x345e, 0x345f, 0x3460, 0x3461, 0x3462, 0x3463, 0x3464, 0x3465,
- 0x3466, 0x3467, 0x3468, 0x3469, 0x346a, 0x346b, 0x346c, 0x346d, 0x346e,
- 0x346f, 0x3470, 0x3471, 0x3472, 0x3473, 0x3474, 0x3475, 0x3476, 0x3477,
- 0x3478, 0x3479, 0x347a, 0x347b, 0x347c, 0x347d, 0x347e, 0x347f, 0x3480,
- 0x3481, 0x3482, 0x3483, 0x3484, 0x3485, 0x3486, 0x3487, 0x3488, 0x3489,
- 0x348a, 0x348b, 0x348c, 0x348d, 0x348e, 0x348f, 0x3490, 0x3491, 0x3492,
- 0x3493, 0x3494, 0x3495, 0x3496, 0x3497, 0x3498, 0x3499, 0x349a, 0x349b,
- 0x349c, 0x349d, 0x349e, 0x349f, 0x34a0, 0x34a1, 0x34a2, 0x34a3, 0x34a4,
- 0x34a5, 0x34a6, 0x34a7, 0x34a8, 0x34a9, 0x34aa, 0x34ab, 0x34ac, 0x34ad,
- 0x34ae, 0x34af, 0x34b0, 0x34b1, 0x34b2, 0x34b3, 0x34b4, 0x34b5, 0x34b6,
- 0x34b7, 0x34b8, 0x34b9, 0x34ba, 0x34bb, 0x34bc, 0x34bd, 0x34be, 0x34bf,
- 0x34c0, 0x34c1, 0x34c2, 0x34c3, 0x34c4, 0x34c5, 0x34c6, 0x34c7, 0x34c8,
- 0x34c9, 0x34ca, 0x34cb, 0x34cc, 0x34cd, 0x34ce, 0x34cf, 0x34d0, 0x34d1,
- 0x34d2, 0x34d3, 0x34d4, 0x34d5, 0x34d6, 0x34d7, 0x34d8, 0x34d9, 0x34da,
- 0x34db, 0x34dc, 0x34dd, 0x34de, 0x34df, 0x34e0, 0x34e1, 0x34e2, 0x34e3,
- 0x34e4, 0x34e5, 0x34e6, 0x34e7, 0x34e8, 0x34e9, 0x34ea, 0x34eb, 0x34ec,
- 0x34ed, 0x34ee, 0x34ef, 0x34f0, 0x34f1, 0x34f2, 0x34f3, 0x34f4, 0x34f5,
- 0x34f6, 0x34f7, 0x34f8, 0x34f9, 0x34fa, 0x34fb, 0x34fc, 0x34fd, 0x34fe,
- 0x34ff, 0x3500, 0x3501, 0x3502, 0x3503, 0x3504, 0x3505, 0x3506, 0x3507,
- 0x3508, 0x3509, 0x350a, 0x350b, 0x350c, 0x350d, 0x350e, 0x350f, 0x3510,
- 0x3511, 0x3512, 0x3513, 0x3514, 0x3515, 0x3516, 0x3517, 0x3518, 0x3519,
- 0x351a, 0x351b, 0x351c, 0x351d, 0x351e, 0x351f, 0x3520, 0x3521, 0x3522,
- 0x3523, 0x3524, 0x3525, 0x3526, 0x3527, 0x3528, 0x3529, 0x352a, 0x352b,
- 0x352c, 0x352d, 0x352e, 0x352f, 0x3530, 0x3531, 0x3532, 0x3533, 0x3534,
- 0x3535, 0x3536, 0x3537, 0x3538, 0x3539, 0x353a, 0x353b, 0x353c, 0x353d,
- 0x353e, 0x353f, 0x3540, 0x3541, 0x3542, 0x3543, 0x3544, 0x3545, 0x3546,
- 0x3547, 0x3548, 0x3549, 0x354a, 0x354b, 0x354c, 0x354d, 0x354e, 0x354f,
- 0x3550, 0x3551, 0x3552, 0x3553, 0x3554, 0x3555, 0x3556, 0x3557, 0x3558,
- 0x3559, 0x355a, 0x355b, 0x355c, 0x355d, 0x355e, 0x355f, 0x3560, 0x3561,
- 0x3562, 0x3563, 0x3564, 0x3565, 0x3566, 0x3567, 0x3568, 0x3569, 0x356a,
- 0x356b, 0x356c, 0x356d, 0x356e, 0x356f, 0x3570, 0x3571, 0x3572, 0x3573,
- 0x3574, 0x3575, 0x3576, 0x3577, 0x3578, 0x3579, 0x357a, 0x357b, 0x357c,
- 0x357d, 0x357e, 0x357f, 0x3580, 0x3581, 0x3582, 0x3583, 0x3584, 0x3585,
- 0x3586, 0x3587, 0x3588, 0x3589, 0x358a, 0x358b, 0x358c, 0x358d, 0x358e,
- 0x358f, 0x3590, 0x3591, 0x3592, 0x3593, 0x3594, 0x3595, 0x3596, 0x3597,
- 0x3598, 0x3599, 0x359a, 0x359b, 0x359c, 0x359d, 0x359e, 0x359f, 0x35a0,
- 0x35a1, 0x35a2, 0x35a3, 0x35a4, 0x35a5, 0x35a6, 0x35a7, 0x35a8, 0x35a9,
- 0x35aa, 0x35ab, 0x35ac, 0x35ad, 0x35ae, 0x35af, 0x35b0, 0x35b1, 0x35b2,
- 0x35b3, 0x35b4, 0x35b5, 0x35b6, 0x35b7, 0x35b8, 0x35b9, 0x35ba, 0x35bb,
- 0x35bc, 0x35bd, 0x35be, 0x35bf, 0x35c0, 0x35c1, 0x35c2, 0x35c3, 0x35c4,
- 0x35c5, 0x35c6, 0x35c7, 0x35c8, 0x35c9, 0x35ca, 0x35cb, 0x35cc, 0x35cd,
- 0x35ce, 0x35cf, 0x35d0, 0x35d1, 0x35d2, 0x35d3, 0x35d4, 0x35d5, 0x35d6,
- 0x35d7, 0x35d8, 0x35d9, 0x35da, 0x35db, 0x35dc, 0x35dd, 0x35de, 0x35df,
- 0x35e0, 0x35e1, 0x35e2, 0x35e3, 0x35e4, 0x35e5, 0x35e6, 0x35e7, 0x35e8,
- 0x35e9, 0x35ea, 0x35eb, 0x35ec, 0x35ed, 0x35ee, 0x35ef, 0x35f0, 0x35f1,
- 0x35f2, 0x35f3, 0x35f4, 0x35f5, 0x35f6, 0x35f7, 0x35f8, 0x35f9, 0x35fa,
- 0x35fb, 0x35fc, 0x35fd, 0x35fe, 0x35ff, 0x3600, 0x3601, 0x3602, 0x3603,
- 0x3604, 0x3605, 0x3606, 0x3607, 0x3608, 0x3609, 0x360a, 0x360b, 0x360c,
- 0x360d, 0x360e, 0x360f, 0x3610, 0x3611, 0x3612, 0x3613, 0x3614, 0x3615,
- 0x3616, 0x3617, 0x3618, 0x3619, 0x361a, 0x361b, 0x361c, 0x361d, 0x361e,
- 0x361f, 0x3620, 0x3621, 0x3622, 0x3623, 0x3624, 0x3625, 0x3626, 0x3627,
- 0x3628, 0x3629, 0x362a, 0x362b, 0x362c, 0x362d, 0x362e, 0x362f, 0x3630,
- 0x3631, 0x3632, 0x3633, 0x3634, 0x3635, 0x3636, 0x3637, 0x3638, 0x3639,
- 0x363a, 0x363b, 0x363c, 0x363d, 0x363e, 0x363f, 0x3640, 0x3641, 0x3642,
- 0x3643, 0x3644, 0x3645, 0x3646, 0x3647, 0x3648, 0x3649, 0x364a, 0x364b,
- 0x364c, 0x364d, 0x364e, 0x364f, 0x3650, 0x3651, 0x3652, 0x3653, 0x3654,
- 0x3655, 0x3656, 0x3657, 0x3658, 0x3659, 0x365a, 0x365b, 0x365c, 0x365d,
- 0x365e, 0x365f, 0x3660, 0x3661, 0x3662, 0x3663, 0x3664, 0x3665, 0x3666,
- 0x3667, 0x3668, 0x3669, 0x366a, 0x366b, 0x366c, 0x366d, 0x366e, 0x366f,
- 0x3670, 0x3671, 0x3672, 0x3673, 0x3674, 0x3675, 0x3676, 0x3677, 0x3678,
- 0x3679, 0x367a, 0x367b, 0x367c, 0x367d, 0x367e, 0x367f, 0x3680, 0x3681,
- 0x3682, 0x3683, 0x3684, 0x3685, 0x3686, 0x3687, 0x3688, 0x3689, 0x368a,
- 0x368b, 0x368c, 0x368d, 0x368e, 0x368f, 0x3690, 0x3691, 0x3692, 0x3693,
- 0x3694, 0x3695, 0x3696, 0x3697, 0x3698, 0x3699, 0x369a, 0x369b, 0x369c,
- 0x369d, 0x369e, 0x369f, 0x36a0, 0x36a1, 0x36a2, 0x36a3, 0x36a4, 0x36a5,
- 0x36a6, 0x36a7, 0x36a8, 0x36a9, 0x36aa, 0x36ab, 0x36ac, 0x36ad, 0x36ae,
- 0x36af, 0x36b0, 0x36b1, 0x36b2, 0x36b3, 0x36b4, 0x36b5, 0x36b6, 0x36b7,
- 0x36b8, 0x36b9, 0x36ba, 0x36bb, 0x36bc, 0x36bd, 0x36be, 0x36bf, 0x36c0,
- 0x36c1, 0x36c2, 0x36c3, 0x36c4, 0x36c5, 0x36c6, 0x36c7, 0x36c8, 0x36c9,
- 0x36ca, 0x36cb, 0x36cc, 0x36cd, 0x36ce, 0x36cf, 0x36d0, 0x36d1, 0x36d2,
- 0x36d3, 0x36d4, 0x36d5, 0x36d6, 0x36d7, 0x36d8, 0x36d9, 0x36da, 0x36db,
- 0x36dc, 0x36dd, 0x36de, 0x36df, 0x36e0, 0x36e1, 0x36e2, 0x36e3, 0x36e4,
- 0x36e5, 0x36e6, 0x36e7, 0x36e8, 0x36e9, 0x36ea, 0x36eb, 0x36ec, 0x36ed,
- 0x36ee, 0x36ef, 0x36f0, 0x36f1, 0x36f2, 0x36f3, 0x36f4, 0x36f5, 0x36f6,
- 0x36f7, 0x36f8, 0x36f9, 0x36fa, 0x36fb, 0x36fc, 0x36fd, 0x36fe, 0x36ff,
- 0x3700, 0x3701, 0x3702, 0x3703, 0x3704, 0x3705, 0x3706, 0x3707, 0x3708,
- 0x3709, 0x370a, 0x370b, 0x370c, 0x370d, 0x370e, 0x370f, 0x3710, 0x3711,
- 0x3712, 0x3713, 0x3714, 0x3715, 0x3716, 0x3717, 0x3718, 0x3719, 0x371a,
- 0x371b, 0x371c, 0x371d, 0x371e, 0x371f, 0x3720, 0x3721, 0x3722, 0x3723,
- 0x3724, 0x3725, 0x3726, 0x3727, 0x3728, 0x3729, 0x372a, 0x372b, 0x372c,
- 0x372d, 0x372e, 0x372f, 0x3730, 0x3731, 0x3732, 0x3733, 0x3734, 0x3735,
- 0x3736, 0x3737, 0x3738, 0x3739, 0x373a, 0x373b, 0x373c, 0x373d, 0x373e,
- 0x373f, 0x3740, 0x3741, 0x3742, 0x3743, 0x3744, 0x3745, 0x3746, 0x3747,
- 0x3748, 0x3749, 0x374a, 0x374b, 0x374c, 0x374d, 0x374e, 0x374f, 0x3750,
- 0x3751, 0x3752, 0x3753, 0x3754, 0x3755, 0x3756, 0x3757, 0x3758, 0x3759,
- 0x375a, 0x375b, 0x375c, 0x375d, 0x375e, 0x375f, 0x3760, 0x3761, 0x3762,
- 0x3763, 0x3764, 0x3765, 0x3766, 0x3767, 0x3768, 0x3769, 0x376a, 0x376b,
- 0x376c, 0x376d, 0x376e, 0x376f, 0x3770, 0x3771, 0x3772, 0x3773, 0x3774,
- 0x3775, 0x3776, 0x3777, 0x3778, 0x3779, 0x377a, 0x377b, 0x377c, 0x377d,
- 0x377e, 0x377f, 0x3780, 0x3781, 0x3782, 0x3783, 0x3784, 0x3785, 0x3786,
- 0x3787, 0x3788, 0x3789, 0x378a, 0x378b, 0x378c, 0x378d, 0x378e, 0x378f,
- 0x3790, 0x3791, 0x3792, 0x3793, 0x3794, 0x3795, 0x3796, 0x3797, 0x3798,
- 0x3799, 0x379a, 0x379b, 0x379c, 0x379d, 0x379e, 0x379f, 0x37a0, 0x37a1,
- 0x37a2, 0x37a3, 0x37a4, 0x37a5, 0x37a6, 0x37a7, 0x37a8, 0x37a9, 0x37aa,
- 0x37ab, 0x37ac, 0x37ad, 0x37ae, 0x37af, 0x37b0, 0x37b1, 0x37b2, 0x37b3,
- 0x37b4, 0x37b5, 0x37b6, 0x37b7, 0x37b8, 0x37b9, 0x37ba, 0x37bb, 0x37bc,
- 0x37bd, 0x37be, 0x37bf, 0x37c0, 0x37c1, 0x37c2, 0x37c3, 0x37c4, 0x37c5,
- 0x37c6, 0x37c7, 0x37c8, 0x37c9, 0x37ca, 0x37cb, 0x37cc, 0x37cd, 0x37ce,
- 0x37cf, 0x37d0, 0x37d1, 0x37d2, 0x37d3, 0x37d4, 0x37d5, 0x37d6, 0x37d7,
- 0x37d8, 0x37d9, 0x37da, 0x37db, 0x37dc, 0x37dd, 0x37de, 0x37df, 0x37e0,
- 0x37e1, 0x37e2, 0x37e3, 0x37e4, 0x37e5, 0x37e6, 0x37e7, 0x37e8, 0x37e9,
- 0x37ea, 0x37eb, 0x37ec, 0x37ed, 0x37ee, 0x37ef, 0x37f0, 0x37f1, 0x37f2,
- 0x37f3, 0x37f4, 0x37f5, 0x37f6, 0x37f7, 0x37f8, 0x37f9, 0x37fa, 0x37fb,
- 0x37fc, 0x37fd, 0x37fe, 0x37ff, 0x3800, 0x3801, 0x3802, 0x3803, 0x3804,
- 0x3805, 0x3806, 0x3807, 0x3808, 0x3809, 0x380a, 0x380b, 0x380c, 0x380d,
- 0x380e, 0x380f, 0x3810, 0x3811, 0x3812, 0x3813, 0x3814, 0x3815, 0x3816,
- 0x3817, 0x3818, 0x3819, 0x381a, 0x381b, 0x381c, 0x381d, 0x381e, 0x381f,
- 0x3820, 0x3821, 0x3822, 0x3823, 0x3824, 0x3825, 0x3826, 0x3827, 0x3828,
- 0x3829, 0x382a, 0x382b, 0x382c, 0x382d, 0x382e, 0x382f, 0x3830, 0x3831,
- 0x3832, 0x3833, 0x3834, 0x3835, 0x3836, 0x3837, 0x3838, 0x3839, 0x383a,
- 0x383b, 0x383c, 0x383d, 0x383e, 0x383f, 0x3840, 0x3841, 0x3842, 0x3843,
- 0x3844, 0x3845, 0x3846, 0x3847, 0x3848, 0x3849, 0x384a, 0x384b, 0x384c,
- 0x384d, 0x384e, 0x384f, 0x3850, 0x3851, 0x3852, 0x3853, 0x3854, 0x3855,
- 0x3856, 0x3857, 0x3858, 0x3859, 0x385a, 0x385b, 0x385c, 0x385d, 0x385e,
- 0x385f, 0x3860, 0x3861, 0x3862, 0x3863, 0x3864, 0x3865, 0x3866, 0x3867,
- 0x3868, 0x3869, 0x386a, 0x386b, 0x386c, 0x386d, 0x386e, 0x386f, 0x3870,
- 0x3871, 0x3872, 0x3873, 0x3874, 0x3875, 0x3876, 0x3877, 0x3878, 0x3879,
- 0x387a, 0x387b, 0x387c, 0x387d, 0x387e, 0x387f, 0x3880, 0x3881, 0x3882,
- 0x3883, 0x3884, 0x3885, 0x3886, 0x3887, 0x3888, 0x3889, 0x388a, 0x388b,
- 0x388c, 0x388d, 0x388e, 0x388f, 0x3890, 0x3891, 0x3892, 0x3893, 0x3894,
- 0x3895, 0x3896, 0x3897, 0x3898, 0x3899, 0x389a, 0x389b, 0x389c, 0x389d,
- 0x389e, 0x389f, 0x38a0, 0x38a1, 0x38a2, 0x38a3, 0x38a4, 0x38a5, 0x38a6,
- 0x38a7, 0x38a8, 0x38a9, 0x38aa, 0x38ab, 0x38ac, 0x38ad, 0x38ae, 0x38af,
- 0x38b0, 0x38b1, 0x38b2, 0x38b3, 0x38b4, 0x38b5, 0x38b6, 0x38b7, 0x38b8,
- 0x38b9, 0x38ba, 0x38bb, 0x38bc, 0x38bd, 0x38be, 0x38bf, 0x38c0, 0x38c1,
- 0x38c2, 0x38c3, 0x38c4, 0x38c5, 0x38c6, 0x38c7, 0x38c8, 0x38c9, 0x38ca,
- 0x38cb, 0x38cc, 0x38cd, 0x38ce, 0x38cf, 0x38d0, 0x38d1, 0x38d2, 0x38d3,
- 0x38d4, 0x38d5, 0x38d6, 0x38d7, 0x38d8, 0x38d9, 0x38da, 0x38db, 0x38dc,
- 0x38dd, 0x38de, 0x38df, 0x38e0, 0x38e1, 0x38e2, 0x38e3, 0x38e4, 0x38e5,
- 0x38e6, 0x38e7, 0x38e8, 0x38e9, 0x38ea, 0x38eb, 0x38ec, 0x38ed, 0x38ee,
- 0x38ef, 0x38f0, 0x38f1, 0x38f2, 0x38f3, 0x38f4, 0x38f5, 0x38f6, 0x38f7,
- 0x38f8, 0x38f9, 0x38fa, 0x38fb, 0x38fc, 0x38fd, 0x38fe, 0x38ff, 0x3900,
- 0x3901, 0x3902, 0x3903, 0x3904, 0x3905, 0x3906, 0x3907, 0x3908, 0x3909,
- 0x390a, 0x390b, 0x390c, 0x390d, 0x390e, 0x390f, 0x3910, 0x3911, 0x3912,
- 0x3913, 0x3914, 0x3915, 0x3916, 0x3917, 0x3918, 0x3919, 0x391a, 0x391b,
- 0x391c, 0x391d, 0x391e, 0x391f, 0x3920, 0x3921, 0x3922, 0x3923, 0x3924,
- 0x3925, 0x3926, 0x3927, 0x3928, 0x3929, 0x392a, 0x392b, 0x392c, 0x392d,
- 0x392e, 0x392f, 0x3930, 0x3931, 0x3932, 0x3933, 0x3934, 0x3935, 0x3936,
- 0x3937, 0x3938, 0x3939, 0x393a, 0x393b, 0x393c, 0x393d, 0x393e, 0x393f,
- 0x3940, 0x3941, 0x3942, 0x3943, 0x3944, 0x3945, 0x3946, 0x3947, 0x3948,
- 0x3949, 0x394a, 0x394b, 0x394c, 0x394d, 0x394e, 0x394f, 0x3950, 0x3951,
- 0x3952, 0x3953, 0x3954, 0x3955, 0x3956, 0x3957, 0x3958, 0x3959, 0x395a,
- 0x395b, 0x395c, 0x395d, 0x395e, 0x395f, 0x3960, 0x3961, 0x3962, 0x3963,
- 0x3964, 0x3965, 0x3966, 0x3967, 0x3968, 0x3969, 0x396a, 0x396b, 0x396c,
- 0x396d, 0x396e, 0x396f, 0x3970, 0x3971, 0x3972, 0x3973, 0x3974, 0x3975,
- 0x3976, 0x3977, 0x3978, 0x3979, 0x397a, 0x397b, 0x397c, 0x397d, 0x397e,
- 0x397f, 0x3980, 0x3981, 0x3982, 0x3983, 0x3984, 0x3985, 0x3986, 0x3987,
- 0x3988, 0x3989, 0x398a, 0x398b, 0x398c, 0x398d, 0x398e, 0x398f, 0x3990,
- 0x3991, 0x3992, 0x3993, 0x3994, 0x3995, 0x3996, 0x3997, 0x3998, 0x3999,
- 0x399a, 0x399b, 0x399c, 0x399d, 0x399e, 0x399f, 0x39a0, 0x39a1, 0x39a2,
- 0x39a3, 0x39a4, 0x39a5, 0x39a6, 0x39a7, 0x39a8, 0x39a9, 0x39aa, 0x39ab,
- 0x39ac, 0x39ad, 0x39ae, 0x39af, 0x39b0, 0x39b1, 0x39b2, 0x39b3, 0x39b4,
- 0x39b5, 0x39b6, 0x39b7, 0x39b8, 0x39b9, 0x39ba, 0x39bb, 0x39bc, 0x39bd,
- 0x39be, 0x39bf, 0x39c0, 0x39c1, 0x39c2, 0x39c3, 0x39c4, 0x39c5, 0x39c6,
- 0x39c7, 0x39c8, 0x39c9, 0x39ca, 0x39cb, 0x39cc, 0x39cd, 0x39ce, 0x39cf,
- 0x39d0, 0x39d1, 0x39d2, 0x39d3, 0x39d4, 0x39d5, 0x39d6, 0x39d7, 0x39d8,
- 0x39d9, 0x39da, 0x39db, 0x39dc, 0x39dd, 0x39de, 0x39df, 0x39e0, 0x39e1,
- 0x39e2, 0x39e3, 0x39e4, 0x39e5, 0x39e6, 0x39e7, 0x39e8, 0x39e9, 0x39ea,
- 0x39eb, 0x39ec, 0x39ed, 0x39ee, 0x39ef, 0x39f0, 0x39f1, 0x39f2, 0x39f3,
- 0x39f4, 0x39f5, 0x39f6, 0x39f7, 0x39f8, 0x39f9, 0x39fa, 0x39fb, 0x39fc,
- 0x39fd, 0x39fe, 0x39ff, 0x3a00, 0x3a01, 0x3a02, 0x3a03, 0x3a04, 0x3a05,
- 0x3a06, 0x3a07, 0x3a08, 0x3a09, 0x3a0a, 0x3a0b, 0x3a0c, 0x3a0d, 0x3a0e,
- 0x3a0f, 0x3a10, 0x3a11, 0x3a12, 0x3a13, 0x3a14, 0x3a15, 0x3a16, 0x3a17,
- 0x3a18, 0x3a19, 0x3a1a, 0x3a1b, 0x3a1c, 0x3a1d, 0x3a1e, 0x3a1f, 0x3a20,
- 0x3a21, 0x3a22, 0x3a23, 0x3a24, 0x3a25, 0x3a26, 0x3a27, 0x3a28, 0x3a29,
- 0x3a2a, 0x3a2b, 0x3a2c, 0x3a2d, 0x3a2e, 0x3a2f, 0x3a30, 0x3a31, 0x3a32,
- 0x3a33, 0x3a34, 0x3a35, 0x3a36, 0x3a37, 0x3a38, 0x3a39, 0x3a3a, 0x3a3b,
- 0x3a3c, 0x3a3d, 0x3a3e, 0x3a3f, 0x3a40, 0x3a41, 0x3a42, 0x3a43, 0x3a44,
- 0x3a45, 0x3a46, 0x3a47, 0x3a48, 0x3a49, 0x3a4a, 0x3a4b, 0x3a4c, 0x3a4d,
- 0x3a4e, 0x3a4f, 0x3a50, 0x3a51, 0x3a52, 0x3a53, 0x3a54, 0x3a55, 0x3a56,
- 0x3a57, 0x3a58, 0x3a59, 0x3a5a, 0x3a5b, 0x3a5c, 0x3a5d, 0x3a5e, 0x3a5f,
- 0x3a60, 0x3a61, 0x3a62, 0x3a63, 0x3a64, 0x3a65, 0x3a66, 0x3a67, 0x3a68,
- 0x3a69, 0x3a6a, 0x3a6b, 0x3a6c, 0x3a6d, 0x3a6e, 0x3a6f, 0x3a70, 0x3a71,
- 0x3a72, 0x3a73, 0x3a74, 0x3a75, 0x3a76, 0x3a77, 0x3a78, 0x3a79, 0x3a7a,
- 0x3a7b, 0x3a7c, 0x3a7d, 0x3a7e, 0x3a7f, 0x3a80, 0x3a81, 0x3a82, 0x3a83,
- 0x3a84, 0x3a85, 0x3a86, 0x3a87, 0x3a88, 0x3a89, 0x3a8a, 0x3a8b, 0x3a8c,
- 0x3a8d, 0x3a8e, 0x3a8f, 0x3a90, 0x3a91, 0x3a92, 0x3a93, 0x3a94, 0x3a95,
- 0x3a96, 0x3a97, 0x3a98, 0x3a99, 0x3a9a, 0x3a9b, 0x3a9c, 0x3a9d, 0x3a9e,
- 0x3a9f, 0x3aa0, 0x3aa1, 0x3aa2, 0x3aa3, 0x3aa4, 0x3aa5, 0x3aa6, 0x3aa7,
- 0x3aa8, 0x3aa9, 0x3aaa, 0x3aab, 0x3aac, 0x3aad, 0x3aae, 0x3aaf, 0x3ab0,
- 0x3ab1, 0x3ab2, 0x3ab3, 0x3ab4, 0x3ab5, 0x3ab6, 0x3ab7, 0x3ab8, 0x3ab9,
- 0x3aba, 0x3abb, 0x3abc, 0x3abd, 0x3abe, 0x3abf, 0x3ac0, 0x3ac1, 0x3ac2,
- 0x3ac3, 0x3ac4, 0x3ac5, 0x3ac6, 0x3ac7, 0x3ac8, 0x3ac9, 0x3aca, 0x3acb,
- 0x3acc, 0x3acd, 0x3ace, 0x3acf, 0x3ad0, 0x3ad1, 0x3ad2, 0x3ad3, 0x3ad4,
- 0x3ad5, 0x3ad6, 0x3ad7, 0x3ad8, 0x3ad9, 0x3ada, 0x3adb, 0x3adc, 0x3add,
- 0x3ade, 0x3adf, 0x3ae0, 0x3ae1, 0x3ae2, 0x3ae3, 0x3ae4, 0x3ae5, 0x3ae6,
- 0x3ae7, 0x3ae8, 0x3ae9, 0x3aea, 0x3aeb, 0x3aec, 0x3aed, 0x3aee, 0x3aef,
- 0x3af0, 0x3af1, 0x3af2, 0x3af3, 0x3af4, 0x3af5, 0x3af6, 0x3af7, 0x3af8,
- 0x3af9, 0x3afa, 0x3afb, 0x3afc, 0x3afd, 0x3afe, 0x3aff, 0x3b00, 0x3b01,
- 0x3b02, 0x3b03, 0x3b04, 0x3b05, 0x3b06, 0x3b07, 0x3b08, 0x3b09, 0x3b0a,
- 0x3b0b, 0x3b0c, 0x3b0d, 0x3b0e, 0x3b0f, 0x3b10, 0x3b11, 0x3b12, 0x3b13,
- 0x3b14, 0x3b15, 0x3b16, 0x3b17, 0x3b18, 0x3b19, 0x3b1a, 0x3b1b, 0x3b1c,
- 0x3b1d, 0x3b1e, 0x3b1f, 0x3b20, 0x3b21, 0x3b22, 0x3b23, 0x3b24, 0x3b25,
- 0x3b26, 0x3b27, 0x3b28, 0x3b29, 0x3b2a, 0x3b2b, 0x3b2c, 0x3b2d, 0x3b2e,
- 0x3b2f, 0x3b30, 0x3b31, 0x3b32, 0x3b33, 0x3b34, 0x3b35, 0x3b36, 0x3b37,
- 0x3b38, 0x3b39, 0x3b3a, 0x3b3b, 0x3b3c, 0x3b3d, 0x3b3e, 0x3b3f, 0x3b40,
- 0x3b41, 0x3b42, 0x3b43, 0x3b44, 0x3b45, 0x3b46, 0x3b47, 0x3b48, 0x3b49,
- 0x3b4a, 0x3b4b, 0x3b4c, 0x3b4d, 0x3b4e, 0x3b4f, 0x3b50, 0x3b51, 0x3b52,
- 0x3b53, 0x3b54, 0x3b55, 0x3b56, 0x3b57, 0x3b58, 0x3b59, 0x3b5a, 0x3b5b,
- 0x3b5c, 0x3b5d, 0x3b5e, 0x3b5f, 0x3b60, 0x3b61, 0x3b62, 0x3b63, 0x3b64,
- 0x3b65, 0x3b66, 0x3b67, 0x3b68, 0x3b69, 0x3b6a, 0x3b6b, 0x3b6c, 0x3b6d,
- 0x3b6e, 0x3b6f, 0x3b70, 0x3b71, 0x3b72, 0x3b73, 0x3b74, 0x3b75, 0x3b76,
- 0x3b77, 0x3b78, 0x3b79, 0x3b7a, 0x3b7b, 0x3b7c, 0x3b7d, 0x3b7e, 0x3b7f,
- 0x3b80, 0x3b81, 0x3b82, 0x3b83, 0x3b84, 0x3b85, 0x3b86, 0x3b87, 0x3b88,
- 0x3b89, 0x3b8a, 0x3b8b, 0x3b8c, 0x3b8d, 0x3b8e, 0x3b8f, 0x3b90, 0x3b91,
- 0x3b92, 0x3b93, 0x3b94, 0x3b95, 0x3b96, 0x3b97, 0x3b98, 0x3b99, 0x3b9a,
- 0x3b9b, 0x3b9c, 0x3b9d, 0x3b9e, 0x3b9f, 0x3ba0, 0x3ba1, 0x3ba2, 0x3ba3,
- 0x3ba4, 0x3ba5, 0x3ba6, 0x3ba7, 0x3ba8, 0x3ba9, 0x3baa, 0x3bab, 0x3bac,
- 0x3bad, 0x3bae, 0x3baf, 0x3bb0, 0x3bb1, 0x3bb2, 0x3bb3, 0x3bb4, 0x3bb5,
- 0x3bb6, 0x3bb7, 0x3bb8, 0x3bb9, 0x3bba, 0x3bbb, 0x3bbc, 0x3bbd, 0x3bbe,
- 0x3bbf, 0x3bc0, 0x3bc1, 0x3bc2, 0x3bc3, 0x3bc4, 0x3bc5, 0x3bc6, 0x3bc7,
- 0x3bc8, 0x3bc9, 0x3bca, 0x3bcb, 0x3bcc, 0x3bcd, 0x3bce, 0x3bcf, 0x3bd0,
- 0x3bd1, 0x3bd2, 0x3bd3, 0x3bd4, 0x3bd5, 0x3bd6, 0x3bd7, 0x3bd8, 0x3bd9,
- 0x3bda, 0x3bdb, 0x3bdc, 0x3bdd, 0x3bde, 0x3bdf, 0x3be0, 0x3be1, 0x3be2,
- 0x3be3, 0x3be4, 0x3be5, 0x3be6, 0x3be7, 0x3be8, 0x3be9, 0x3bea, 0x3beb,
- 0x3bec, 0x3bed, 0x3bee, 0x3bef, 0x3bf0, 0x3bf1, 0x3bf2, 0x3bf3, 0x3bf4,
- 0x3bf5, 0x3bf6, 0x3bf7, 0x3bf8, 0x3bf9, 0x3bfa, 0x3bfb, 0x3bfc, 0x3bfd,
- 0x3bfe, 0x3bff, 0x3c00, 0x3c01, 0x3c02, 0x3c03, 0x3c04, 0x3c05, 0x3c06,
- 0x3c07, 0x3c08, 0x3c09, 0x3c0a, 0x3c0b, 0x3c0c, 0x3c0d, 0x3c0e, 0x3c0f,
- 0x3c10, 0x3c11, 0x3c12, 0x3c13, 0x3c14, 0x3c15, 0x3c16, 0x3c17, 0x3c18,
- 0x3c19, 0x3c1a, 0x3c1b, 0x3c1c, 0x3c1d, 0x3c1e, 0x3c1f, 0x3c20, 0x3c21,
- 0x3c22, 0x3c23, 0x3c24, 0x3c25, 0x3c26, 0x3c27, 0x3c28, 0x3c29, 0x3c2a,
- 0x3c2b, 0x3c2c, 0x3c2d, 0x3c2e, 0x3c2f, 0x3c30, 0x3c31, 0x3c32, 0x3c33,
- 0x3c34, 0x3c35, 0x3c36, 0x3c37, 0x3c38, 0x3c39, 0x3c3a, 0x3c3b, 0x3c3c,
- 0x3c3d, 0x3c3e, 0x3c3f, 0x3c40, 0x3c41, 0x3c42, 0x3c43, 0x3c44, 0x3c45,
- 0x3c46, 0x3c47, 0x3c48, 0x3c49, 0x3c4a, 0x3c4b, 0x3c4c, 0x3c4d, 0x3c4e,
- 0x3c4f, 0x3c50, 0x3c51, 0x3c52, 0x3c53, 0x3c54, 0x3c55, 0x3c56, 0x3c57,
- 0x3c58, 0x3c59, 0x3c5a, 0x3c5b, 0x3c5c, 0x3c5d, 0x3c5e, 0x3c5f, 0x3c60,
- 0x3c61, 0x3c62, 0x3c63, 0x3c64, 0x3c65, 0x3c66, 0x3c67, 0x3c68, 0x3c69,
- 0x3c6a, 0x3c6b, 0x3c6c, 0x3c6d, 0x3c6e, 0x3c6f, 0x3c70, 0x3c71, 0x3c72,
- 0x3c73, 0x3c74, 0x3c75, 0x3c76, 0x3c77, 0x3c78, 0x3c79, 0x3c7a, 0x3c7b,
- 0x3c7c, 0x3c7d, 0x3c7e, 0x3c7f, 0x3c80, 0x3c81, 0x3c82, 0x3c83, 0x3c84,
- 0x3c85, 0x3c86, 0x3c87, 0x3c88, 0x3c89, 0x3c8a, 0x3c8b, 0x3c8c, 0x3c8d,
- 0x3c8e, 0x3c8f, 0x3c90, 0x3c91, 0x3c92, 0x3c93, 0x3c94, 0x3c95, 0x3c96,
- 0x3c97, 0x3c98, 0x3c99, 0x3c9a, 0x3c9b, 0x3c9c, 0x3c9d, 0x3c9e, 0x3c9f,
- 0x3ca0, 0x3ca1, 0x3ca2, 0x3ca3, 0x3ca4, 0x3ca5, 0x3ca6, 0x3ca7, 0x3ca8,
- 0x3ca9, 0x3caa, 0x3cab, 0x3cac, 0x3cad, 0x3cae, 0x3caf, 0x3cb0, 0x3cb1,
- 0x3cb2, 0x3cb3, 0x3cb4, 0x3cb5, 0x3cb6, 0x3cb7, 0x3cb8, 0x3cb9, 0x3cba,
- 0x3cbb, 0x3cbc, 0x3cbd, 0x3cbe, 0x3cbf, 0x3cc0, 0x3cc1, 0x3cc2, 0x3cc3,
- 0x3cc4, 0x3cc5, 0x3cc6, 0x3cc7, 0x3cc8, 0x3cc9, 0x3cca, 0x3ccb, 0x3ccc,
- 0x3ccd, 0x3cce, 0x3ccf, 0x3cd0, 0x3cd1, 0x3cd2, 0x3cd3, 0x3cd4, 0x3cd5,
- 0x3cd6, 0x3cd7, 0x3cd8, 0x3cd9, 0x3cda, 0x3cdb, 0x3cdc, 0x3cdd, 0x3cde,
- 0x3cdf, 0x3ce0, 0x3ce1, 0x3ce2, 0x3ce3, 0x3ce4, 0x3ce5, 0x3ce6, 0x3ce7,
- 0x3ce8, 0x3ce9, 0x3cea, 0x3ceb, 0x3cec, 0x3ced, 0x3cee, 0x3cef, 0x3cf0,
- 0x3cf1, 0x3cf2, 0x3cf3, 0x3cf4, 0x3cf5, 0x3cf6, 0x3cf7, 0x3cf8, 0x3cf9,
- 0x3cfa, 0x3cfb, 0x3cfc, 0x3cfd, 0x3cfe, 0x3cff, 0x3d00, 0x3d01, 0x3d02,
- 0x3d03, 0x3d04, 0x3d05, 0x3d06, 0x3d07, 0x3d08, 0x3d09, 0x3d0a, 0x3d0b,
- 0x3d0c, 0x3d0d, 0x3d0e, 0x3d0f, 0x3d10, 0x3d11, 0x3d12, 0x3d13, 0x3d14,
- 0x3d15, 0x3d16, 0x3d17, 0x3d18, 0x3d19, 0x3d1a, 0x3d1b, 0x3d1c, 0x3d1d,
- 0x3d1e, 0x3d1f, 0x3d20, 0x3d21, 0x3d22, 0x3d23, 0x3d24, 0x3d25, 0x3d26,
- 0x3d27, 0x3d28, 0x3d29, 0x3d2a, 0x3d2b, 0x3d2c, 0x3d2d, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, -1, -1, -1, -1, -1, -1, -1,
- -1, -1, 0x4f3d, 0x4f73, 0x5047, 0x50f9, 0x52a0, 0x53ef, 0x5475,
- 0x54e5, 0x5609, 0x5ac1, 0x5bb6, 0x6687, 0x67b6, 0x67b7, 0x67ef, 0x6b4c,
- 0x73c2, 0x75c2, 0x7a3c, 0x82db, 0x8304, 0x8857, 0x8888, 0x8a36, 0x8cc8,
- 0x8dcf, 0x8efb, 0x8fe6, 0x99d5, 0x523b, 0x5374, 0x5404, 0x606a, 0x6164,
- 0x6bbc, 0x73cf, 0x811a, 0x89ba, 0x89d2, 0x95a3, 0x4f83, 0x520a, 0x58be,
- 0x5978, 0x59e6, 0x5e72, 0x5e79, 0x61c7, 0x63c0, 0x6746, 0x67ec, 0x687f,
- 0x6f97, 0x764e, 0x770b, 0x78f5, 0x7a08, 0x7aff, 0x7c21, 0x809d, 0x826e,
- 0x8271, 0x8aeb, 0x9593, 0x4e6b, 0x559d, 0x66f7, 0x6e34, 0x78a3, 0x7aed,
- 0x845b, 0x8910, 0x874e, 0x97a8, 0x52d8, 0x574e, 0x582a, 0x5d4c, 0x611f,
- 0x61be, 0x6221, 0x6562, 0x67d1, 0x6a44, 0x6e1b, 0x7518, 0x75b3, 0x76e3,
- 0x77b0, 0x7d3a, 0x90af, 0x9451, 0x9452, 0x9f95, 0x5323, 0x5cac, 0x7532,
- 0x80db, 0x9240, 0x9598, 0x525b, 0x5808, 0x59dc, 0x5ca1, 0x5d17, 0x5eb7,
- 0x5f3a, 0x5f4a, 0x6177, 0x6c5f, 0x757a, 0x7586, 0x7ce0, 0x7d73, 0x7db1,
- 0x7f8c, 0x8154, 0x8221, 0x8591, 0x8941, 0x8b1b, 0x92fc, 0x964d, 0x9c47,
- 0x4ecb, 0x4ef7, 0x500b, 0x51f1, 0x584f, 0x6137, 0x613e, 0x6168, 0x6539,
- 0x69ea, 0x6f11, 0x75a5, 0x7686, 0x76d6, 0x7b87, 0x82a5, 0x84cb, 0xf900,
- 0x93a7, 0x958b, 0x5580, 0x5ba2, 0x5751, 0xf901, 0x7cb3, 0x7fb9, 0x91b5,
- 0x5028, 0x53bb, 0x5c45, 0x5de8, 0x62d2, 0x636e, 0x64da, 0x64e7, 0x6e20,
- 0x70ac, 0x795b, 0x8ddd, 0x8e1e, 0xf902, 0x907d, 0x9245, 0x92f8, 0x4e7e,
- 0x4ef6, 0x5065, 0x5dfe, 0x5efa, 0x6106, 0x6957, 0x8171, 0x8654, 0x8e47,
- 0x9375, 0x9a2b, 0x4e5e, 0x5091, 0x6770, 0x6840, 0x5109, 0x528d, 0x5292,
- 0x6aa2, 0x77bc, 0x9210, 0x9ed4, 0x52ab, 0x602f, 0x8ff2, 0x5048, 0x61a9,
- 0x63ed, 0x64ca, 0x683c, 0x6a84, 0x6fc0, 0x8188, 0x89a1, 0x9694, 0x5805,
- 0x727d, 0x72ac, 0x7504, 0x7d79, 0x7e6d, 0x80a9, 0x898b, 0x8b74, 0x9063,
- 0x9d51, 0x6289, 0x6c7a, 0x6f54, 0x7d50, 0x7f3a, 0x8a23, 0x517c, 0x614a,
- 0x7b9d, 0x8b19, 0x9257, 0x938c, 0x4eac, 0x4fd3, 0x501e, 0x50be, 0x5106,
- 0x52c1, 0x52cd, 0x537f, 0x5770, 0x5883, 0x5e9a, 0x5f91, 0x6176, 0x61ac,
- 0x64ce, 0x656c, 0x666f, 0x66bb, 0x66f4, 0x6897, 0x6d87, 0x7085, 0x70f1,
- 0x749f, 0x74a5, 0x74ca, 0x75d9, 0x786c, 0x78ec, 0x7adf, 0x7af6, 0x7d45,
- 0x7d93, 0x8015, 0x803f, 0x811b, 0x8396, 0x8b66, 0x8f15, 0x9015, 0x93e1,
- 0x9803, 0x9838, 0x9a5a, 0x9be8, 0x4fc2, 0x5553, 0x583a, 0x5951, 0x5b63,
- 0x5c46, 0x60b8, 0x6212, 0x6842, 0x68b0, 0x68e8, 0x6eaa, 0x754c, 0x7678,
- 0x78ce, 0x7a3d, 0x7cfb, 0x7e6b, 0x7e7c, 0x8a08, 0x8aa1, 0x8c3f, 0x968e,
- 0x9dc4, 0x53e4, 0x53e9, 0x544a, 0x5471, 0x56fa, 0x59d1, 0x5b64, 0x5c3b,
- 0x5eab, 0x62f7, 0x6537, 0x6545, 0x6572, 0x66a0, 0x67af, 0x69c1, 0x6cbd,
- 0x75fc, 0x7690, 0x777e, 0x7a3f, 0x7f94, 0x8003, 0x80a1, 0x818f, 0x82e6,
- 0x82fd, 0x83f0, 0x85c1, 0x8831, 0x88b4, 0x8aa5, 0xf903, 0x8f9c, 0x932e,
- 0x96c7, 0x9867, 0x9ad8, 0x9f13, 0x54ed, 0x659b, 0x66f2, 0x688f, 0x7a40,
- 0x8c37, 0x9d60, 0x56f0, 0x5764, 0x5d11, 0x6606, 0x68b1, 0x68cd, 0x6efe,
- 0x7428, 0x889e, 0x9be4, 0x6c68, 0xf904, 0x9aa8, 0x4f9b, 0x516c, 0x5171,
- 0x529f, 0x5b54, 0x5de5, 0x6050, 0x606d, 0x62f1, 0x63a7, 0x653b, 0x73d9,
- 0x7a7a, 0x86a3, 0x8ca2, 0x978f, 0x4e32, 0x5be1, 0x6208, 0x679c, 0x74dc,
- 0x79d1, 0x83d3, 0x8a87, 0x8ab2, 0x8de8, 0x904e, 0x934b, 0x9846, 0x5ed3,
- 0x69e8, 0x85ff, 0x90ed, 0xf905, 0x51a0, 0x5b98, 0x5bec, 0x6163, 0x68fa,
- 0x6b3e, 0x704c, 0x742f, 0x74d8, 0x7ba1, 0x7f50, 0x83c5, 0x89c0, 0x8cab,
- 0x95dc, 0x9928, 0x522e, 0x605d, 0x62ec, 0x9002, 0x4f8a, 0x5149, 0x5321,
- 0x58d9, 0x5ee3, 0x66e0, 0x6d38, 0x709a, 0x72c2, 0x73d6, 0x7b50, 0x80f1,
- 0x945b, 0x5366, 0x639b, 0x7f6b, 0x4e56, 0x5080, 0x584a, 0x58de, 0x602a,
- 0x6127, 0x62d0, 0x69d0, 0x9b41, 0x5b8f, 0x7d18, 0x80b1, 0x8f5f, 0x4ea4,
- 0x50d1, 0x54ac, 0x55ac, 0x5b0c, 0x5da0, 0x5de7, 0x652a, 0x654e, 0x6821,
- 0x6a4b, 0x72e1, 0x768e, 0x77ef, 0x7d5e, 0x7ff9, 0x81a0, 0x854e, 0x86df,
- 0x8f03, 0x8f4e, 0x90ca, 0x9903, 0x9a55, 0x9bab, 0x4e18, 0x4e45, 0x4e5d,
- 0x4ec7, 0x4ff1, 0x5177, 0x52fe, 0x5340, 0x53e3, 0x53e5, 0x548e, 0x5614,
- 0x5775, 0x57a2, 0x5bc7, 0x5d87, 0x5ed0, 0x61fc, 0x62d8, 0x6551, 0x67b8,
- 0x67e9, 0x69cb, 0x6b50, 0x6bc6, 0x6bec, 0x6c42, 0x6e9d, 0x7078, 0x72d7,
- 0x7396, 0x7403, 0x77bf, 0x77e9, 0x7a76, 0x7d7f, 0x8009, 0x81fc, 0x8205,
- 0x820a, 0x82df, 0x8862, 0x8b33, 0x8cfc, 0x8ec0, 0x9011, 0x90b1, 0x9264,
- 0x92b6, 0x99d2, 0x9a45, 0x9ce9, 0x9dd7, 0x9f9c, 0x570b, 0x5c40, 0x83ca,
- 0x97a0, 0x97ab, 0x9eb4, 0x541b, 0x7a98, 0x7fa4, 0x88d9, 0x8ecd, 0x90e1,
- 0x5800, 0x5c48, 0x6398, 0x7a9f, 0x5bae, 0x5f13, 0x7a79, 0x7aae, 0x828e,
- 0x8eac, 0x5026, 0x5238, 0x52f8, 0x5377, 0x5708, 0x62f3, 0x6372, 0x6b0a,
- 0x6dc3, 0x7737, 0x53a5, 0x7357, 0x8568, 0x8e76, 0x95d5, 0x673a, 0x6ac3,
- 0x6f70, 0x8a6d, 0x8ecc, 0x994b, 0xf906, 0x6677, 0x6b78, 0x8cb4, 0x9b3c,
- 0xf907, 0x53eb, 0x572d, 0x594e, 0x63c6, 0x69fb, 0x73ea, 0x7845, 0x7aba,
- 0x7ac5, 0x7cfe, 0x8475, 0x898f, 0x8d73, 0x9035, 0x95a8, 0x52fb, 0x5747,
- 0x7547, 0x7b60, 0x83cc, 0x921e, 0xf908, 0x6a58, 0x514b, 0x524b, 0x5287,
- 0x621f, 0x68d8, 0x6975, 0x9699, 0x50c5, 0x52a4, 0x52e4, 0x61c3, 0x65a4,
- 0x6839, 0x69ff, 0x747e, 0x7b4b, 0x82b9, 0x83eb, 0x89b2, 0x8b39, 0x8fd1,
- 0x9949, 0xf909, 0x4eca, 0x5997, 0x64d2, 0x6611, 0x6a8e, 0x7434, 0x7981,
- 0x79bd, 0x82a9, 0x887e, 0x887f, 0x895f, 0xf90a, 0x9326, 0x4f0b, 0x53ca,
- 0x6025, 0x6271, 0x6c72, 0x7d1a, 0x7d66, 0x4e98, 0x5162, 0x77dc, 0x80af,
- 0x4f01, 0x4f0e, 0x5176, 0x5180, 0x55dc, 0x5668, 0x573b, 0x57fa, 0x57fc,
- 0x5914, 0x5947, 0x5993, 0x5bc4, 0x5c90, 0x5d0e, 0x5df1, 0x5e7e, 0x5fcc,
- 0x6280, 0x65d7, 0x65e3, 0x671e, 0x671f, 0x675e, 0x68cb, 0x68c4, 0x6a5f,
- 0x6b3a, 0x6c23, 0x6c7d, 0x6c82, 0x6dc7, 0x7398, 0x7426, 0x742a, 0x7482,
- 0x74a3, 0x7578, 0x757f, 0x7881, 0x78ef, 0x7941, 0x7947, 0x7948, 0x797a,
- 0x7b95, 0x7d00, 0x7dba, 0x7f88, 0x8006, 0x802d, 0x808c, 0x8a18, 0x8b4f,
- 0x8c48, 0x8d77, 0x9321, 0x9324, 0x98e2, 0x9951, 0x9a0e, 0x9a0f, 0x9a65,
- 0x9e92, 0x7dca, 0x4f76, 0x5409, 0x62ee, 0x6854, 0x91d1, 0x55ab, 0x513a,
- 0xf90b, 0xf90c, 0x5a1c, 0x61e6, 0xf90d, 0x62cf, 0x62ff, 0xf90e, 0xf90f,
- 0xf910, 0xf911, 0xf912, 0xf913, 0x90a3, 0xf914, 0xf915, 0xf916, 0xf917,
- 0xf918, 0x8afe, 0xf919, 0xf91a, 0xf91b, 0xf91c, 0x6696, 0xf91d, 0x7156,
- 0xf91e, 0xf91f, 0x96e3, 0xf920, 0x634f, 0x637a, 0x5357, 0xf921, 0x678f,
- 0x6960, 0x6e73, 0xf922, 0x7537, 0xf923, 0xf924, 0xf925, 0x7d0d, 0xf926,
- 0xf927, 0x8872, 0x56ca, 0x5a18, 0xf928, 0xf929, 0xf92a, 0xf92b, 0xf92c,
- 0x4e43, 0xf92d, 0x5167, 0x5948, 0x67f0, 0x8010, 0xf92e, 0x5973, 0x5e74,
- 0x649a, 0x79ca, 0x5ff5, 0x606c, 0x62c8, 0x637b, 0x5be7, 0x5bd7, 0x52aa,
- 0xf92f, 0x5974, 0x5f29, 0x6012, 0xf930, 0xf931, 0xf932, 0x7459, 0xf933,
- 0xf934, 0xf935, 0xf936, 0xf937, 0xf938, 0x99d1, 0xf939, 0xf93a, 0xf93b,
- 0xf93c, 0xf93d, 0xf93e, 0xf93f, 0xf940, 0xf941, 0xf942, 0xf943, 0x6fc3,
- 0xf944, 0xf945, 0x81bf, 0x8fb2, 0x60f1, 0xf946, 0xf947, 0x8166, 0xf948,
- 0xf949, 0x5c3f, 0xf94a, 0xf94b, 0xf94c, 0xf94d, 0xf94e, 0xf94f, 0xf950,
- 0xf951, 0x5ae9, 0x8a25, 0x677b, 0x7d10, 0xf952, 0xf953, 0xf954, 0xf955,
- 0xf956, 0xf957, 0x80fd, 0xf958, 0xf959, 0x5c3c, 0x6ce5, 0x533f, 0x6eba,
- 0x591a, 0x8336, 0x4e39, 0x4eb6, 0x4f46, 0x55ae, 0x5718, 0x58c7, 0x5f56,
- 0x65b7, 0x65e6, 0x6a80, 0x6bb5, 0x6e4d, 0x77ed, 0x7aef, 0x7c1e, 0x7dde,
- 0x86cb, 0x8892, 0x9132, 0x935b, 0x64bb, 0x6fbe, 0x737a, 0x75b8, 0x9054,
- 0x5556, 0x574d, 0x61ba, 0x64d4, 0x66c7, 0x6de1, 0x6e5b, 0x6f6d, 0x6fb9,
- 0x75f0, 0x8043, 0x81bd, 0x8541, 0x8983, 0x8ac7, 0x8b5a, 0x931f, 0x6c93,
- 0x7553, 0x7b54, 0x8e0f, 0x905d, 0x5510, 0x5802, 0x5858, 0x5e62, 0x6207,
- 0x649e, 0x68e0, 0x7576, 0x7cd6, 0x87b3, 0x9ee8, 0x4ee3, 0x5788, 0x576e,
- 0x5927, 0x5c0d, 0x5cb1, 0x5e36, 0x5f85, 0x6234, 0x64e1, 0x73b3, 0x81fa,
- 0x888b, 0x8cb8, 0x968a, 0x9edb, 0x5b85, 0x5fb7, 0x60b3, 0x5012, 0x5200,
- 0x5230, 0x5716, 0x5835, 0x5857, 0x5c0e, 0x5c60, 0x5cf6, 0x5d8b, 0x5ea6,
- 0x5f92, 0x60bc, 0x6311, 0x6389, 0x6417, 0x6843, 0x68f9, 0x6ac2, 0x6dd8,
- 0x6e21, 0x6ed4, 0x6fe4, 0x71fe, 0x76dc, 0x7779, 0x79b1, 0x7a3b, 0x8404,
- 0x89a9, 0x8ced, 0x8df3, 0x8e48, 0x9003, 0x9014, 0x9053, 0x90fd, 0x934d,
- 0x9676, 0x97dc, 0x6bd2, 0x7006, 0x7258, 0x72a2, 0x7368, 0x7763, 0x79bf,
- 0x7be4, 0x7e9b, 0x8b80, 0x58a9, 0x60c7, 0x6566, 0x65fd, 0x66be, 0x6c8c,
- 0x711e, 0x71c9, 0x8c5a, 0x9813, 0x4e6d, 0x7a81, 0x4edd, 0x51ac, 0x51cd,
- 0x52d5, 0x540c, 0x61a7, 0x6771, 0x6850, 0x68df, 0x6d1e, 0x6f7c, 0x75bc,
- 0x77b3, 0x7ae5, 0x80f4, 0x8463, 0x9285, 0x515c, 0x6597, 0x675c, 0x6793,
- 0x75d8, 0x7ac7, 0x8373, 0xf95a, 0x8c46, 0x9017, 0x982d, 0x5c6f, 0x81c0,
- 0x829a, 0x9041, 0x906f, 0x920d, 0x5f97, 0x5d9d, 0x6a59, 0x71c8, 0x767b,
- 0x7b49, 0x85e4, 0x8b04, 0x9127, 0x9a30, 0x5587, 0x61f6, 0xf95b, 0x7669,
- 0x7f85, 0x863f, 0x87ba, 0x88f8, 0x908f, 0xf95c, 0x6d1b, 0x70d9, 0x73de,
- 0x7d61, 0x843d, 0xf95d, 0x916a, 0x99f1, 0xf95e, 0x4e82, 0x5375, 0x6b04,
- 0x6b12, 0x703e, 0x721b, 0x862d, 0x9e1e, 0x524c, 0x8fa3, 0x5d50, 0x64e5,
- 0x652c, 0x6b16, 0x6feb, 0x7c43, 0x7e9c, 0x85cd, 0x8964, 0x89bd, 0x62c9,
- 0x81d8, 0x881f, 0x5eca, 0x6717, 0x6d6a, 0x72fc, 0x7405, 0x746f, 0x8782,
- 0x90de, 0x4f86, 0x5d0d, 0x5fa0, 0x840a, 0x51b7, 0x63a0, 0x7565, 0x4eae,
- 0x5006, 0x5169, 0x51c9, 0x6881, 0x6a11, 0x7cae, 0x7cb1, 0x7ce7, 0x826f,
- 0x8ad2, 0x8f1b, 0x91cf, 0x4fb6, 0x5137, 0x52f5, 0x5442, 0x5eec, 0x616e,
- 0x623e, 0x65c5, 0x6ada, 0x6ffe, 0x792a, 0x85dc, 0x8823, 0x95ad, 0x9a62,
- 0x9a6a, 0x9e97, 0x9ece, 0x529b, 0x66c6, 0x6b77, 0x701d, 0x792b, 0x8f62,
- 0x9742, 0x6190, 0x6200, 0x6523, 0x6f23, 0x7149, 0x7489, 0x7df4, 0x806f,
- 0x84ee, 0x8f26, 0x9023, 0x934a, 0x51bd, 0x5217, 0x52a3, 0x6d0c, 0x70c8,
- 0x88c2, 0x5ec9, 0x6582, 0x6bae, 0x6fc2, 0x7c3e, 0x7375, 0x4ee4, 0x4f36,
- 0x56f9, 0xf95f, 0x5cba, 0x5dba, 0x601c, 0x73b2, 0x7b2d, 0x7f9a, 0x7fce,
- 0x8046, 0x901e, 0x9234, 0x96f6, 0x9748, 0x9818, 0x9f61, 0x4f8b, 0x6fa7,
- 0x79ae, 0x91b4, 0x96b7, 0x52de, 0xf960, 0x6488, 0x64c4, 0x6ad3, 0x6f5e,
- 0x7018, 0x7210, 0x76e7, 0x8001, 0x8606, 0x865c, 0x8def, 0x8f05, 0x9732,
- 0x9b6f, 0x9dfa, 0x9e75, 0x788c, 0x797f, 0x7da0, 0x83c9, 0x9304, 0x9e7f,
- 0x9e93, 0x8ad6, 0x58df, 0x5f04, 0x6727, 0x7027, 0x74cf, 0x7c60, 0x807e,
- 0x5121, 0x7028, 0x7262, 0x78ca, 0x8cc2, 0x8cda, 0x8cf4, 0x96f7, 0x4e86,
- 0x50da, 0x5bee, 0x5ed6, 0x6599, 0x71ce, 0x7642, 0x77ad, 0x804a, 0x84fc,
- 0x907c, 0x9b27, 0x9f8d, 0x58d8, 0x5a41, 0x5c62, 0x6a13, 0x6dda, 0x6f0f,
- 0x763b, 0x7d2f, 0x7e37, 0x851e, 0x8938, 0x93e4, 0x964b, 0x5289, 0x65d2,
- 0x67f3, 0x69b4, 0x6d41, 0x6e9c, 0x700f, 0x7409, 0x7460, 0x7559, 0x7624,
- 0x786b, 0x8b2c, 0x985e, 0x516d, 0x622e, 0x9678, 0x4f96, 0x502b, 0x5d19,
- 0x6dea, 0x7db8, 0x8f2a, 0x5f8b, 0x6144, 0x6817, 0xf961, 0x9686, 0x52d2,
- 0x808b, 0x51dc, 0x51cc, 0x695e, 0x7a1c, 0x7dbe, 0x83f1, 0x9675, 0x4fda,
- 0x5229, 0x5398, 0x540f, 0x550e, 0x5c65, 0x60a7, 0x674e, 0x68a8, 0x6d6c,
- 0x7281, 0x72f8, 0x7406, 0x7483, 0xf962, 0x75e2, 0x7c6c, 0x7f79, 0x7fb8,
- 0x8389, 0x88cf, 0x88e1, 0x91cc, 0x91d0, 0x96e2, 0x9bc9, 0x541d, 0x6f7e,
- 0x71d0, 0x7498, 0x85fa, 0x8eaa, 0x96a3, 0x9c57, 0x9e9f, 0x6797, 0x6dcb,
- 0x7433, 0x81e8, 0x9716, 0x782c, 0x7acb, 0x7b20, 0x7c92, 0x6469, 0x746a,
- 0x75f2, 0x78bc, 0x78e8, 0x99ac, 0x9b54, 0x9ebb, 0x5bde, 0x5e55, 0x6f20,
- 0x819c, 0x83ab, 0x9088, 0x4e07, 0x534d, 0x5a29, 0x5dd2, 0x5f4e, 0x6162,
- 0x633d, 0x6669, 0x66fc, 0x6eff, 0x6f2b, 0x7063, 0x779e, 0x842c, 0x8513,
- 0x883b, 0x8f13, 0x9945, 0x9c3b, 0x551c, 0x62b9, 0x672b, 0x6cab, 0x8309,
- 0x896a, 0x977a, 0x4ea1, 0x5984, 0x5fd8, 0x5fd9, 0x671b, 0x7db2, 0x7f54,
- 0x8292, 0x832b, 0x83bd, 0x8f1e, 0x9099, 0x57cb, 0x59b9, 0x5a92, 0x5bd0,
- 0x6627, 0x679a, 0x6885, 0x6bcf, 0x7164, 0x7f75, 0x8cb7, 0x8ce3, 0x9081,
- 0x9b45, 0x8108, 0x8c8a, 0x964c, 0x9a40, 0x9ea5, 0x5b5f, 0x6c13, 0x731b,
- 0x76f2, 0x76df, 0x840c, 0x51aa, 0x8993, 0x514d, 0x5195, 0x52c9, 0x68c9,
- 0x6c94, 0x7704, 0x7720, 0x7dbf, 0x7dec, 0x9762, 0x9eb5, 0x6ec5, 0x8511,
- 0x51a5, 0x540d, 0x547d, 0x660e, 0x669d, 0x6927, 0x6e9f, 0x76bf, 0x7791,
- 0x8317, 0x84c2, 0x879f, 0x9169, 0x9298, 0x9cf4, 0x8882, 0x4fae, 0x5192,
- 0x52df, 0x59c6, 0x5e3d, 0x6155, 0x6478, 0x6479, 0x66ae, 0x67d0, 0x6a21,
- 0x6bcd, 0x6bdb, 0x725f, 0x7261, 0x7441, 0x7738, 0x77db, 0x8017, 0x82bc,
- 0x8305, 0x8b00, 0x8b28, 0x8c8c, 0x6728, 0x6c90, 0x7267, 0x76ee, 0x7766,
- 0x7a46, 0x9da9, 0x6b7f, 0x6c92, 0x5922, 0x6726, 0x8499, 0x536f, 0x5893,
- 0x5999, 0x5edf, 0x63cf, 0x6634, 0x6773, 0x6e3a, 0x732b, 0x7ad7, 0x82d7,
- 0x9328, 0x52d9, 0x5deb, 0x61ae, 0x61cb, 0x620a, 0x62c7, 0x64ab, 0x65e0,
- 0x6959, 0x6b66, 0x6bcb, 0x7121, 0x73f7, 0x755d, 0x7e46, 0x821e, 0x8302,
- 0x856a, 0x8aa3, 0x8cbf, 0x9727, 0x9d61, 0x58a8, 0x9ed8, 0x5011, 0x520e,
- 0x543b, 0x554f, 0x6587, 0x6c76, 0x7d0a, 0x7d0b, 0x805e, 0x868a, 0x9580,
- 0x96ef, 0x52ff, 0x6c95, 0x7269, 0x5473, 0x5a9a, 0x5c3e, 0x5d4b, 0x5f4c,
- 0x5fae, 0x672a, 0x68b6, 0x6963, 0x6e3c, 0x6e44, 0x7709, 0x7c73, 0x7f8e,
- 0x8587, 0x8b0e, 0x8ff7, 0x9761, 0x9ef4, 0x5cb7, 0x60b6, 0x610d, 0x61ab,
- 0x654f, 0x65fb, 0x65fc, 0x6c11, 0x6cef, 0x739f, 0x73c9, 0x7de1, 0x9594,
- 0x5bc6, 0x871c, 0x8b10, 0x525d, 0x535a, 0x62cd, 0x640f, 0x64b2, 0x6734,
- 0x6a38, 0x6cca, 0x73c0, 0x749e, 0x7b94, 0x7c95, 0x7e1b, 0x818a, 0x8236,
- 0x8584, 0x8feb, 0x96f9, 0x99c1, 0x4f34, 0x534a, 0x53cd, 0x53db, 0x62cc,
- 0x642c, 0x6500, 0x6591, 0x69c3, 0x6cee, 0x6f58, 0x73ed, 0x7554, 0x7622,
- 0x76e4, 0x76fc, 0x78d0, 0x78fb, 0x792c, 0x7d46, 0x822c, 0x87e0, 0x8fd4,
- 0x9812, 0x98ef, 0x52c3, 0x62d4, 0x64a5, 0x6e24, 0x6f51, 0x767c, 0x8dcb,
- 0x91b1, 0x9262, 0x9aee, 0x9b43, 0x5023, 0x508d, 0x574a, 0x59a8, 0x5c28,
- 0x5e47, 0x5f77, 0x623f, 0x653e, 0x65b9, 0x65c1, 0x6609, 0x678b, 0x699c,
- 0x6ec2, 0x78c5, 0x7d21, 0x80aa, 0x8180, 0x822b, 0x82b3, 0x84a1, 0x868c,
- 0x8a2a, 0x8b17, 0x90a6, 0x9632, 0x9f90, 0x500d, 0x4ff3, 0xf963, 0x57f9,
- 0x5f98, 0x62dc, 0x6392, 0x676f, 0x6e43, 0x7119, 0x76c3, 0x80cc, 0x80da,
- 0x88f4, 0x88f5, 0x8919, 0x8ce0, 0x8f29, 0x914d, 0x966a, 0x4f2f, 0x4f70,
- 0x5e1b, 0x67cf, 0x6822, 0x767d, 0x767e, 0x9b44, 0x5e61, 0x6a0a, 0x7169,
- 0x71d4, 0x756a, 0xf964, 0x7e41, 0x8543, 0x85e9, 0x98dc, 0x4f10, 0x7b4f,
- 0x7f70, 0x95a5, 0x51e1, 0x5e06, 0x68b5, 0x6c3e, 0x6c4e, 0x6cdb, 0x72af,
- 0x7bc4, 0x8303, 0x6cd5, 0x743a, 0x50fb, 0x5288, 0x58c1, 0x64d8, 0x6a97,
- 0x74a7, 0x7656, 0x78a7, 0x8617, 0x95e2, 0x9739, 0xf965, 0x535e, 0x5f01,
- 0x8b8a, 0x8fa8, 0x8faf, 0x908a, 0x5225, 0x77a5, 0x9c49, 0x9f08, 0x4e19,
- 0x5002, 0x5175, 0x5c5b, 0x5e77, 0x661e, 0x663a, 0x67c4, 0x68c5, 0x70b3,
- 0x7501, 0x75c5, 0x79c9, 0x7add, 0x8f27, 0x9920, 0x9a08, 0x4fdd, 0x5821,
- 0x5831, 0x5bf6, 0x666e, 0x6b65, 0x6d11, 0x6e7a, 0x6f7d, 0x73e4, 0x752b,
- 0x83e9, 0x88dc, 0x8913, 0x8b5c, 0x8f14, 0x4f0f, 0x50d5, 0x5310, 0x535c,
- 0x5b93, 0x5fa9, 0x670d, 0x798f, 0x8179, 0x832f, 0x8514, 0x8907, 0x8986,
- 0x8f39, 0x8f3b, 0x99a5, 0x9c12, 0x672c, 0x4e76, 0x4ff8, 0x5949, 0x5c01,
- 0x5cef, 0x5cf0, 0x6367, 0x68d2, 0x70fd, 0x71a2, 0x742b, 0x7e2b, 0x84ec,
- 0x8702, 0x9022, 0x92d2, 0x9cf3, 0x4e0d, 0x4ed8, 0x4fef, 0x5085, 0x5256,
- 0x526f, 0x5426, 0x5490, 0x57e0, 0x592b, 0x5a66, 0x5b5a, 0x5b75, 0x5bcc,
- 0x5e9c, 0xf966, 0x6276, 0x6577, 0x65a7, 0x6d6e, 0x6ea5, 0x7236, 0x7b26,
- 0x7c3f, 0x7f36, 0x8150, 0x8151, 0x819a, 0x8240, 0x8299, 0x83a9, 0x8a03,
- 0x8ca0, 0x8ce6, 0x8cfb, 0x8d74, 0x8dba, 0x90e8, 0x91dc, 0x961c, 0x9644,
- 0x99d9, 0x9ce7, 0x5317, 0x5206, 0x5429, 0x5674, 0x58b3, 0x5954, 0x596e,
- 0x5fff, 0x61a4, 0x626e, 0x6610, 0x6c7e, 0x711a, 0x76c6, 0x7c89, 0x7cde,
- 0x7d1b, 0x82ac, 0x8cc1, 0x96f0, 0xf967, 0x4f5b, 0x5f17, 0x5f7f, 0x62c2,
- 0x5d29, 0x670b, 0x68da, 0x787c, 0x7e43, 0x9d6c, 0x4e15, 0x5099, 0x5315,
- 0x532a, 0x5351, 0x5983, 0x5a62, 0x5e87, 0x60b2, 0x618a, 0x6249, 0x6279,
- 0x6590, 0x6787, 0x69a7, 0x6bd4, 0x6bd6, 0x6bd7, 0x6bd8, 0x6cb8, 0xf968,
- 0x7435, 0x75fa, 0x7812, 0x7891, 0x79d5, 0x79d8, 0x7c83, 0x7dcb, 0x7fe1,
- 0x80a5, 0x813e, 0x81c2, 0x83f2, 0x871a, 0x88e8, 0x8ab9, 0x8b6c, 0x8cbb,
- 0x9119, 0x975e, 0x98db, 0x9f3b, 0x56ac, 0x5b2a, 0x5f6c, 0x658c, 0x6ab3,
- 0x6baf, 0x6d5c, 0x6ff1, 0x7015, 0x725d, 0x73ad, 0x8ca7, 0x8cd3, 0x983b,
- 0x6191, 0x6c37, 0x8058, 0x9a01, 0x4e4d, 0x4e8b, 0x4e9b, 0x4ed5, 0x4f3a,
- 0x4f3c, 0x4f7f, 0x4fdf, 0x50ff, 0x53f2, 0x53f8, 0x5506, 0x55e3, 0x56db,
- 0x58eb, 0x5962, 0x5a11, 0x5beb, 0x5bfa, 0x5c04, 0x5df3, 0x5e2b, 0x5f99,
- 0x601d, 0x6368, 0x659c, 0x65af, 0x67f6, 0x67fb, 0x68ad, 0x6b7b, 0x6c99,
- 0x6cd7, 0x6e23, 0x7009, 0x7345, 0x7802, 0x793e, 0x7940, 0x7960, 0x79c1,
- 0x7be9, 0x7d17, 0x7d72, 0x8086, 0x820d, 0x838e, 0x84d1, 0x86c7, 0x88df,
- 0x8a50, 0x8a5e, 0x8b1d, 0x8cdc, 0x8d66, 0x8fad, 0x90aa, 0x98fc, 0x99df,
- 0x9e9d, 0x524a, 0xf969, 0x6714, 0xf96a, 0x5098, 0x522a, 0x5c71, 0x6563,
- 0x6c55, 0x73ca, 0x7523, 0x759d, 0x7b97, 0x849c, 0x9178, 0x9730, 0x4e77,
- 0x6492, 0x6bba, 0x715e, 0x85a9, 0x4e09, 0xf96b, 0x6749, 0x68ee, 0x6e17,
- 0x829f, 0x8518, 0x886b, 0x63f7, 0x6f81, 0x9212, 0x98af, 0x4e0a, 0x50b7,
- 0x50cf, 0x511f, 0x5546, 0x55aa, 0x5617, 0x5b40, 0x5c19, 0x5ce0, 0x5e38,
- 0x5e8a, 0x5ea0, 0x5ec2, 0x60f3, 0x6851, 0x6a61, 0x6e58, 0x723d, 0x7240,
- 0x72c0, 0x76f8, 0x7965, 0x7bb1, 0x7fd4, 0x88f3, 0x89f4, 0x8a73, 0x8c61,
- 0x8cde, 0x971c, 0x585e, 0x74bd, 0x8cfd, 0x55c7, 0xf96c, 0x7a61, 0x7d22,
- 0x8272, 0x7272, 0x751f, 0x7525, 0xf96d, 0x7b19, 0x5885, 0x58fb, 0x5dbc,
- 0x5e8f, 0x5eb6, 0x5f90, 0x6055, 0x6292, 0x637f, 0x654d, 0x6691, 0x66d9,
- 0x66f8, 0x6816, 0x68f2, 0x7280, 0x745e, 0x7b6e, 0x7d6e, 0x7dd6, 0x7f72,
- 0x80e5, 0x8212, 0x85af, 0x897f, 0x8a93, 0x901d, 0x92e4, 0x9ecd, 0x9f20,
- 0x5915, 0x596d, 0x5e2d, 0x60dc, 0x6614, 0x6673, 0x6790, 0x6c50, 0x6dc5,
- 0x6f5f, 0x77f3, 0x78a9, 0x84c6, 0x91cb, 0x932b, 0x4ed9, 0x50ca, 0x5148,
- 0x5584, 0x5b0b, 0x5ba3, 0x6247, 0x657e, 0x65cb, 0x6e32, 0x717d, 0x7401,
- 0x7444, 0x7487, 0x74bf, 0x766c, 0x79aa, 0x7dda, 0x7e55, 0x7fa8, 0x817a,
- 0x81b3, 0x8239, 0x861a, 0x87ec, 0x8a75, 0x8de3, 0x9078, 0x9291, 0x9425,
- 0x994d, 0x9bae, 0x5368, 0x5c51, 0x6954, 0x6cc4, 0x6d29, 0x6e2b, 0x820c,
- 0x859b, 0x893b, 0x8a2d, 0x8aaa, 0x96ea, 0x9f67, 0x5261, 0x66b9, 0x6bb2,
- 0x7e96, 0x87fe, 0x8d0d, 0x9583, 0x965d, 0x651d, 0x6d89, 0x71ee, 0xf96e,
- 0x57ce, 0x59d3, 0x5bac, 0x6027, 0x60fa, 0x6210, 0x661f, 0x665f, 0x7329,
- 0x73f9, 0x76db, 0x7701, 0x7b6c, 0x8056, 0x8072, 0x8165, 0x8aa0, 0x9192,
- 0x4e16, 0x52e2, 0x6b72, 0x6d17, 0x7a05, 0x7b39, 0x7d30, 0xf96f, 0x8cb0,
- 0x53ec, 0x562f, 0x5851, 0x5bb5, 0x5c0f, 0x5c11, 0x5de2, 0x6240, 0x6383,
- 0x6414, 0x662d, 0x68b3, 0x6cbc, 0x6d88, 0x6eaf, 0x701f, 0x70a4, 0x71d2,
- 0x7526, 0x758f, 0x758e, 0x7619, 0x7b11, 0x7be0, 0x7c2b, 0x7d20, 0x7d39,
- 0x852c, 0x856d, 0x8607, 0x8a34, 0x900d, 0x9061, 0x90b5, 0x92b7, 0x97f6,
- 0x9a37, 0x4fd7, 0x5c6c, 0x675f, 0x6d91, 0x7c9f, 0x7e8c, 0x8b16, 0x8d16,
- 0x901f, 0x5b6b, 0x5dfd, 0x640d, 0x84c0, 0x905c, 0x98e1, 0x7387, 0x5b8b,
- 0x609a, 0x677e, 0x6dde, 0x8a1f, 0x8aa6, 0x9001, 0x980c, 0x5237, 0xf970,
- 0x7051, 0x788e, 0x9396, 0x8870, 0x91d7, 0x4fee, 0x53d7, 0x55fd, 0x56da,
- 0x5782, 0x58fd, 0x5ac2, 0x5b88, 0x5cab, 0x5cc0, 0x5e25, 0x6101, 0x620d,
- 0x624b, 0x6388, 0x641c, 0x6536, 0x6578, 0x6a39, 0x6b8a, 0x6c34, 0x6d19,
- 0x6f31, 0x71e7, 0x72e9, 0x7378, 0x7407, 0x74b2, 0x7626, 0x7761, 0x79c0,
- 0x7a57, 0x7aea, 0x7cb9, 0x7d8f, 0x7dac, 0x7e61, 0x7f9e, 0x8129, 0x8331,
- 0x8490, 0x84da, 0x85ea, 0x8896, 0x8ab0, 0x8b90, 0x8f38, 0x9042, 0x9083,
- 0x916c, 0x9296, 0x92b9, 0x968b, 0x96a7, 0x96a8, 0x96d6, 0x9700, 0x9808,
- 0x9996, 0x9ad3, 0x9b1a, 0x53d4, 0x587e, 0x5919, 0x5b70, 0x5bbf, 0x6dd1,
- 0x6f5a, 0x719f, 0x7421, 0x74b9, 0x8085, 0x83fd, 0x5de1, 0x5f87, 0x5faa,
- 0x6042, 0x65ec, 0x6812, 0x696f, 0x6a53, 0x6b89, 0x6d35, 0x6df3, 0x73e3,
- 0x76fe, 0x77ac, 0x7b4d, 0x7d14, 0x8123, 0x821c, 0x8340, 0x84f4, 0x8563,
- 0x8a62, 0x8ac4, 0x9187, 0x931e, 0x9806, 0x99b4, 0x620c, 0x8853, 0x8ff0,
- 0x9265, 0x5d07, 0x5d27, 0x5d69, 0x745f, 0x819d, 0x8768, 0x6fd5, 0x62fe,
- 0x7fd2, 0x8936, 0x8972, 0x4e1e, 0x4e58, 0x50e7, 0x52dd, 0x5347, 0x627f,
- 0x6607, 0x7e69, 0x8805, 0x965e, 0x4f8d, 0x5319, 0x5636, 0x59cb, 0x5aa4,
- 0x5c38, 0x5c4e, 0x5c4d, 0x5e02, 0x5f11, 0x6043, 0x65bd, 0x662f, 0x6642,
- 0x67be, 0x67f4, 0x731c, 0x77e2, 0x793a, 0x7fc5, 0x8494, 0x84cd, 0x8996,
- 0x8a66, 0x8a69, 0x8ae1, 0x8c55, 0x8c7a, 0x57f4, 0x5bd4, 0x5f0f, 0x606f,
- 0x62ed, 0x690d, 0x6b96, 0x6e5c, 0x7184, 0x7bd2, 0x8755, 0x8b58, 0x8efe,
- 0x98df, 0x98fe, 0x4f38, 0x4f81, 0x4fe1, 0x547b, 0x5a20, 0x5bb8, 0x613c,
- 0x65b0, 0x6668, 0x71fc, 0x7533, 0x795e, 0x7d33, 0x814e, 0x81e3, 0x8398,
- 0x85aa, 0x85ce, 0x8703, 0x8a0a, 0x8eab, 0x8f9b, 0xf971, 0x8fc5, 0x5931,
- 0x5ba4, 0x5be6, 0x6089, 0x5be9, 0x5c0b, 0x5fc3, 0x6c81, 0xf972, 0x6df1,
- 0x700b, 0x751a, 0x82af, 0x8af6, 0x4ec0, 0x5341, 0xf973, 0x96d9, 0x6c0f,
- 0x4e9e, 0x4fc4, 0x5152, 0x555e, 0x5a25, 0x5ce8, 0x6211, 0x7259, 0x82bd,
- 0x83aa, 0x86fe, 0x8859, 0x8a1d, 0x963f, 0x96c5, 0x9913, 0x9d09, 0x9d5d,
- 0x580a, 0x5cb3, 0x5dbd, 0x5e44, 0x60e1, 0x6115, 0x63e1, 0x6a02, 0x6e25,
- 0x9102, 0x9354, 0x984e, 0x9c10, 0x9f77, 0x5b89, 0x5cb8, 0x6309, 0x664f,
- 0x6848, 0x773c, 0x96c1, 0x978d, 0x9854, 0x9b9f, 0x65a1, 0x8b01, 0x8ecb,
- 0x95bc, 0x5535, 0x5ca9, 0x5dd6, 0x5eb5, 0x6697, 0x764c, 0x83f4, 0x95c7,
- 0x58d3, 0x62bc, 0x72ce, 0x9d28, 0x4ef0, 0x592e, 0x600f, 0x663b, 0x6b83,
- 0x79e7, 0x9d26, 0x5393, 0x54c0, 0x57c3, 0x5d16, 0x611b, 0x66d6, 0x6daf,
- 0x788d, 0x827e, 0x9698, 0x9744, 0x5384, 0x627c, 0x6396, 0x6db2, 0x7e0a,
- 0x814b, 0x984d, 0x6afb, 0x7f4c, 0x9daf, 0x9e1a, 0x4e5f, 0x503b, 0x51b6,
- 0x591c, 0x60f9, 0x63f6, 0x6930, 0x723a, 0x8036, 0xf974, 0x91ce, 0x5f31,
- 0xf975, 0xf976, 0x7d04, 0x82e5, 0x846f, 0x84bb, 0x85e5, 0x8e8d, 0xf977,
- 0x4f6f, 0xf978, 0xf979, 0x58e4, 0x5b43, 0x6059, 0x63da, 0x6518, 0x656d,
- 0x6698, 0xf97a, 0x694a, 0x6a23, 0x6d0b, 0x7001, 0x716c, 0x75d2, 0x760d,
- 0x79b3, 0x7a70, 0xf97b, 0x7f8a, 0xf97c, 0x8944, 0xf97d, 0x8b93, 0x91c0,
- 0x967d, 0xf97e, 0x990a, 0x5704, 0x5fa1, 0x65bc, 0x6f01, 0x7600, 0x79a6,
- 0x8a9e, 0x99ad, 0x9b5a, 0x9f6c, 0x5104, 0x61b6, 0x6291, 0x6a8d, 0x81c6,
- 0x5043, 0x5830, 0x5f66, 0x7109, 0x8a00, 0x8afa, 0x5b7c, 0x8616, 0x4ffa,
- 0x513c, 0x56b4, 0x5944, 0x63a9, 0x6df9, 0x5daa, 0x696d, 0x5186, 0x4e88,
- 0x4f59, 0xf97f, 0xf980, 0xf981, 0x5982, 0xf982, 0xf983, 0x6b5f, 0x6c5d,
- 0xf984, 0x74b5, 0x7916, 0xf985, 0x8207, 0x8245, 0x8339, 0x8f3f, 0x8f5d,
- 0xf986, 0x9918, 0xf987, 0xf988, 0xf989, 0x4ea6, 0xf98a, 0x57df, 0x5f79,
- 0x6613, 0xf98b, 0xf98c, 0x75ab, 0x7e79, 0x8b6f, 0xf98d, 0x9006, 0x9a5b,
- 0x56a5, 0x5827, 0x59f8, 0x5a1f, 0x5bb4, 0xf98e, 0x5ef6, 0xf98f, 0xf990,
- 0x6350, 0x633b, 0xf991, 0x693d, 0x6c87, 0x6cbf, 0x6d8e, 0x6d93, 0x6df5,
- 0x6f14, 0xf992, 0x70df, 0x7136, 0x7159, 0xf993, 0x71c3, 0x71d5, 0xf994,
- 0x784f, 0x786f, 0xf995, 0x7b75, 0x7de3, 0xf996, 0x7e2f, 0xf997, 0x884d,
- 0x8edf, 0xf998, 0xf999, 0xf99a, 0x925b, 0xf99b, 0x9cf6, 0xf99c, 0xf99d,
- 0xf99e, 0x6085, 0x6d85, 0xf99f, 0x71b1, 0xf9a0, 0xf9a1, 0x95b1, 0x53ad,
- 0xf9a2, 0xf9a3, 0xf9a4, 0x67d3, 0xf9a5, 0x708e, 0x7130, 0x7430, 0x8276,
- 0x82d2, 0xf9a6, 0x95bb, 0x9ae5, 0x9e7d, 0x66c4, 0xf9a7, 0x71c1, 0x8449,
- 0xf9a8, 0xf9a9, 0x584b, 0xf9aa, 0xf9ab, 0x5db8, 0x5f71, 0xf9ac, 0x6620,
- 0x668e, 0x6979, 0x69ae, 0x6c38, 0x6cf3, 0x6e36, 0x6f41, 0x6fda, 0x701b,
- 0x702f, 0x7150, 0x71df, 0x7370, 0xf9ad, 0x745b, 0xf9ae, 0x74d4, 0x76c8,
- 0x7a4e, 0x7e93, 0xf9af, 0xf9b0, 0x82f1, 0x8a60, 0x8fce, 0xf9b1, 0x9348,
- 0xf9b2, 0x9719, 0xf9b3, 0xf9b4, 0x4e42, 0x502a, 0xf9b5, 0x5208, 0x53e1,
- 0x66f3, 0x6c6d, 0x6fca, 0x730a, 0x777f, 0x7a62, 0x82ae, 0x85dd, 0x8602,
- 0xf9b6, 0x88d4, 0x8a63, 0x8b7d, 0x8c6b, 0xf9b7, 0x92b3, 0xf9b8, 0x9713,
- 0x9810, 0x4e94, 0x4f0d, 0x4fc9, 0x50b2, 0x5348, 0x543e, 0x5433, 0x55da,
- 0x5862, 0x58ba, 0x5967, 0x5a1b, 0x5be4, 0x609f, 0xf9b9, 0x61ca, 0x6556,
- 0x65ff, 0x6664, 0x68a7, 0x6c5a, 0x6fb3, 0x70cf, 0x71ac, 0x7352, 0x7b7d,
- 0x8708, 0x8aa4, 0x9c32, 0x9f07, 0x5c4b, 0x6c83, 0x7344, 0x7389, 0x923a,
- 0x6eab, 0x7465, 0x761f, 0x7a69, 0x7e15, 0x860a, 0x5140, 0x58c5, 0x64c1,
- 0x74ee, 0x7515, 0x7670, 0x7fc1, 0x9095, 0x96cd, 0x9954, 0x6e26, 0x74e6,
- 0x7aa9, 0x7aaa, 0x81e5, 0x86d9, 0x8778, 0x8a1b, 0x5a49, 0x5b8c, 0x5b9b,
- 0x68a1, 0x6900, 0x6d63, 0x73a9, 0x7413, 0x742c, 0x7897, 0x7de9, 0x7feb,
- 0x8118, 0x8155, 0x839e, 0x8c4c, 0x962e, 0x9811, 0x66f0, 0x5f80, 0x65fa,
- 0x6789, 0x6c6a, 0x738b, 0x502d, 0x5a03, 0x6b6a, 0x77ee, 0x5916, 0x5d6c,
- 0x5dcd, 0x7325, 0x754f, 0xf9ba, 0xf9bb, 0x50e5, 0x51f9, 0x582f, 0x592d,
- 0x5996, 0x59da, 0x5be5, 0xf9bc, 0xf9bd, 0x5da2, 0x62d7, 0x6416, 0x6493,
- 0x64fe, 0xf9be, 0x66dc, 0xf9bf, 0x6a48, 0xf9c0, 0x71ff, 0x7464, 0xf9c1,
- 0x7a88, 0x7aaf, 0x7e47, 0x7e5e, 0x8000, 0x8170, 0xf9c2, 0x87ef, 0x8981,
- 0x8b20, 0x9059, 0xf9c3, 0x9080, 0x9952, 0x617e, 0x6b32, 0x6d74, 0x7e1f,
- 0x8925, 0x8fb1, 0x4fd1, 0x50ad, 0x5197, 0x52c7, 0x57c7, 0x5889, 0x5bb9,
- 0x5eb8, 0x6142, 0x6995, 0x6d8c, 0x6e67, 0x6eb6, 0x7194, 0x7462, 0x7528,
- 0x752c, 0x8073, 0x8338, 0x84c9, 0x8e0a, 0x9394, 0x93de, 0xf9c4, 0x4e8e,
- 0x4f51, 0x5076, 0x512a, 0x53c8, 0x53cb, 0x53f3, 0x5b87, 0x5bd3, 0x5c24,
- 0x611a, 0x6182, 0x65f4, 0x725b, 0x7397, 0x7440, 0x76c2, 0x7950, 0x7991,
- 0x79b9, 0x7d06, 0x7fbd, 0x828b, 0x85d5, 0x865e, 0x8fc2, 0x9047, 0x90f5,
- 0x91ea, 0x9685, 0x96e8, 0x96e9, 0x52d6, 0x5f67, 0x65ed, 0x6631, 0x682f,
- 0x715c, 0x7a36, 0x90c1, 0x980a, 0x4e91, 0xf9c5, 0x6a52, 0x6b9e, 0x6f90,
- 0x7189, 0x8018, 0x82b8, 0x8553, 0x904b, 0x9695, 0x96f2, 0x97fb, 0x851a,
- 0x9b31, 0x4e90, 0x718a, 0x96c4, 0x5143, 0x539f, 0x54e1, 0x5713, 0x5712,
- 0x57a3, 0x5a9b, 0x5ac4, 0x5bc3, 0x6028, 0x613f, 0x63f4, 0x6c85, 0x6d39,
- 0x6e72, 0x6e90, 0x7230, 0x733f, 0x7457, 0x82d1, 0x8881, 0x8f45, 0x9060,
- 0xf9c6, 0x9662, 0x9858, 0x9d1b, 0x6708, 0x8d8a, 0x925e, 0x4f4d, 0x5049,
- 0x50de, 0x5371, 0x570d, 0x59d4, 0x5a01, 0x5c09, 0x6170, 0x6690, 0x6e2d,
- 0x7232, 0x744b, 0x7def, 0x80c3, 0x840e, 0x8466, 0x853f, 0x875f, 0x885b,
- 0x8918, 0x8b02, 0x9055, 0x97cb, 0x9b4f, 0x4e73, 0x4f91, 0x5112, 0x516a,
- 0xf9c7, 0x552f, 0x55a9, 0x5b7a, 0x5ba5, 0x5e7c, 0x5e7d, 0x5ebe, 0x60a0,
- 0x60df, 0x6108, 0x6109, 0x63c4, 0x6538, 0x6709, 0xf9c8, 0x67d4, 0x67da,
- 0xf9c9, 0x6961, 0x6962, 0x6cb9, 0x6d27, 0xf9ca, 0x6e38, 0xf9cb, 0x6fe1,
- 0x7336, 0x7337, 0xf9cc, 0x745c, 0x7531, 0xf9cd, 0x7652, 0xf9ce, 0xf9cf,
- 0x7dad, 0x81fe, 0x8438, 0x88d5, 0x8a98, 0x8adb, 0x8aed, 0x8e30, 0x8e42,
- 0x904a, 0x903e, 0x907a, 0x9149, 0x91c9, 0x936e, 0xf9d0, 0xf9d1, 0x5809,
- 0xf9d2, 0x6bd3, 0x8089, 0x80b2, 0xf9d3, 0xf9d4, 0x5141, 0x596b, 0x5c39,
- 0xf9d5, 0xf9d6, 0x6f64, 0x73a7, 0x80e4, 0x8d07, 0xf9d7, 0x9217, 0x958f,
- 0xf9d8, 0xf9d9, 0xf9da, 0xf9db, 0x807f, 0x620e, 0x701c, 0x7d68, 0x878d,
- 0xf9dc, 0x57a0, 0x6069, 0x6147, 0x6bb7, 0x8abe, 0x9280, 0x96b1, 0x4e59,
- 0x541f, 0x6deb, 0x852d, 0x9670, 0x97f3, 0x98ee, 0x63d6, 0x6ce3, 0x9091,
- 0x51dd, 0x61c9, 0x81ba, 0x9df9, 0x4f9d, 0x501a, 0x5100, 0x5b9c, 0x610f,
- 0x61ff, 0x64ec, 0x6905, 0x6bc5, 0x7591, 0x77e3, 0x7fa9, 0x8264, 0x858f,
- 0x87fb, 0x8863, 0x8abc, 0x8b70, 0x91ab, 0x4e8c, 0x4ee5, 0x4f0a, 0xf9dd,
- 0xf9de, 0x5937, 0x59e8, 0xf9df, 0x5df2, 0x5f1b, 0x5f5b, 0x6021, 0xf9e0,
- 0xf9e1, 0xf9e2, 0xf9e3, 0x723e, 0x73e5, 0xf9e4, 0x7570, 0x75cd, 0xf9e5,
- 0x79fb, 0xf9e6, 0x800c, 0x8033, 0x8084, 0x82e1, 0x8351, 0xf9e7, 0xf9e8,
- 0x8cbd, 0x8cb3, 0x9087, 0xf9e9, 0xf9ea, 0x98f4, 0x990c, 0xf9eb, 0xf9ec,
- 0x7037, 0x76ca, 0x7fca, 0x7fcc, 0x7ffc, 0x8b1a, 0x4eba, 0x4ec1, 0x5203,
- 0x5370, 0xf9ed, 0x54bd, 0x56e0, 0x59fb, 0x5bc5, 0x5f15, 0x5fcd, 0x6e6e,
- 0xf9ee, 0xf9ef, 0x7d6a, 0x8335, 0xf9f0, 0x8693, 0x8a8d, 0xf9f1, 0x976d,
- 0x9777, 0xf9f2, 0xf9f3, 0x4e00, 0x4f5a, 0x4f7e, 0x58f9, 0x65e5, 0x6ea2,
- 0x9038, 0x93b0, 0x99b9, 0x4efb, 0x58ec, 0x598a, 0x59d9, 0x6041, 0xf9f4,
- 0xf9f5, 0x7a14, 0xf9f6, 0x834f, 0x8cc3, 0x5165, 0x5344, 0xf9f7, 0xf9f8,
- 0xf9f9, 0x4ecd, 0x5269, 0x5b55, 0x82bf, 0x4ed4, 0x523a, 0x54a8, 0x59c9,
- 0x59ff, 0x5b50, 0x5b57, 0x5b5c, 0x6063, 0x6148, 0x6ecb, 0x7099, 0x716e,
- 0x7386, 0x74f7, 0x75b5, 0x78c1, 0x7d2b, 0x8005, 0x81ea, 0x8328, 0x8517,
- 0x85c9, 0x8aee, 0x8cc7, 0x96cc, 0x4f5c, 0x52fa, 0x56bc, 0x65ab, 0x6628,
- 0x707c, 0x70b8, 0x7235, 0x7dbd, 0x828d, 0x914c, 0x96c0, 0x9d72, 0x5b71,
- 0x68e7, 0x6b98, 0x6f7a, 0x76de, 0x5c91, 0x66ab, 0x6f5b, 0x7bb4, 0x7c2a,
- 0x8836, 0x96dc, 0x4e08, 0x4ed7, 0x5320, 0x5834, 0x58bb, 0x58ef, 0x596c,
- 0x5c07, 0x5e33, 0x5e84, 0x5f35, 0x638c, 0x66b2, 0x6756, 0x6a1f, 0x6aa3,
- 0x6b0c, 0x6f3f, 0x7246, 0xf9fa, 0x7350, 0x748b, 0x7ae0, 0x7ca7, 0x8178,
- 0x81df, 0x81e7, 0x838a, 0x846c, 0x8523, 0x8594, 0x85cf, 0x88dd, 0x8d13,
- 0x91ac, 0x9577, 0x969c, 0x518d, 0x54c9, 0x5728, 0x5bb0, 0x624d, 0x6750,
- 0x683d, 0x6893, 0x6e3d, 0x6ed3, 0x707d, 0x7e21, 0x88c1, 0x8ca1, 0x8f09,
- 0x9f4b, 0x9f4e, 0x722d, 0x7b8f, 0x8acd, 0x931a, 0x4f47, 0x4f4e, 0x5132,
- 0x5480, 0x59d0, 0x5e95, 0x62b5, 0x6775, 0x696e, 0x6a17, 0x6cae, 0x6e1a,
- 0x72d9, 0x732a, 0x75bd, 0x7bb8, 0x7d35, 0x82e7, 0x83f9, 0x8457, 0x85f7,
- 0x8a5b, 0x8caf, 0x8e87, 0x9019, 0x90b8, 0x96ce, 0x9f5f, 0x52e3, 0x540a,
- 0x5ae1, 0x5bc2, 0x6458, 0x6575, 0x6ef4, 0x72c4, 0xf9fb, 0x7684, 0x7a4d,
- 0x7b1b, 0x7c4d, 0x7e3e, 0x7fdf, 0x837b, 0x8b2b, 0x8cca, 0x8d64, 0x8de1,
- 0x8e5f, 0x8fea, 0x8ff9, 0x9069, 0x93d1, 0x4f43, 0x4f7a, 0x50b3, 0x5168,
- 0x5178, 0x524d, 0x526a, 0x5861, 0x587c, 0x5960, 0x5c08, 0x5c55, 0x5edb,
- 0x609b, 0x6230, 0x6813, 0x6bbf, 0x6c08, 0x6fb1, 0x714e, 0x7420, 0x7530,
- 0x7538, 0x7551, 0x7672, 0x7b4c, 0x7b8b, 0x7bad, 0x7bc6, 0x7e8f, 0x8a6e,
- 0x8f3e, 0x8f49, 0x923f, 0x9293, 0x9322, 0x942b, 0x96fb, 0x985a, 0x986b,
- 0x991e, 0x5207, 0x622a, 0x6298, 0x6d59, 0x7664, 0x7aca, 0x7bc0, 0x7d76,
- 0x5360, 0x5cbe, 0x5e97, 0x6f38, 0x70b9, 0x7c98, 0x9711, 0x9b8e, 0x9ede,
- 0x63a5, 0x647a, 0x8776, 0x4e01, 0x4e95, 0x4ead, 0x505c, 0x5075, 0x5448,
- 0x59c3, 0x5b9a, 0x5e40, 0x5ead, 0x5ef7, 0x5f81, 0x60c5, 0x633a, 0x653f,
- 0x6574, 0x65cc, 0x6676, 0x6678, 0x67fe, 0x6968, 0x6a89, 0x6b63, 0x6c40,
- 0x6dc0, 0x6de8, 0x6e1f, 0x6e5e, 0x701e, 0x70a1, 0x738e, 0x73fd, 0x753a,
- 0x775b, 0x7887, 0x798e, 0x7a0b, 0x7a7d, 0x7cbe, 0x7d8e, 0x8247, 0x8a02,
- 0x8aea, 0x8c9e, 0x912d, 0x914a, 0x91d8, 0x9266, 0x92cc, 0x9320, 0x9706,
- 0x9756, 0x975c, 0x9802, 0x9f0e, 0x5236, 0x5291, 0x557c, 0x5824, 0x5e1d,
- 0x5f1f, 0x608c, 0x63d0, 0x68af, 0x6fdf, 0x796d, 0x7b2c, 0x81cd, 0x85ba,
- 0x88fd, 0x8af8, 0x8e44, 0x918d, 0x9664, 0x969b, 0x973d, 0x984c, 0x9f4a,
- 0x4fce, 0x5146, 0x51cb, 0x52a9, 0x5632, 0x5f14, 0x5f6b, 0x63aa, 0x64cd,
- 0x65e9, 0x6641, 0x66fa, 0x66f9, 0x671d, 0x689d, 0x68d7, 0x69fd, 0x6f15,
- 0x6f6e, 0x7167, 0x71e5, 0x722a, 0x74aa, 0x773a, 0x7956, 0x795a, 0x79df,
- 0x7a20, 0x7a95, 0x7c97, 0x7cdf, 0x7d44, 0x7e70, 0x8087, 0x85fb, 0x86a4,
- 0x8a54, 0x8abf, 0x8d99, 0x8e81, 0x9020, 0x906d, 0x91e3, 0x963b, 0x96d5,
- 0x9ce5, 0x65cf, 0x7c07, 0x8db3, 0x93c3, 0x5b58, 0x5c0a, 0x5352, 0x62d9,
- 0x731d, 0x5027, 0x5b97, 0x5f9e, 0x60b0, 0x616b, 0x68d5, 0x6dd9, 0x742e,
- 0x7a2e, 0x7d42, 0x7d9c, 0x7e31, 0x816b, 0x8e2a, 0x8e35, 0x937e, 0x9418,
- 0x4f50, 0x5750, 0x5de6, 0x5ea7, 0x632b, 0x7f6a, 0x4e3b, 0x4f4f, 0x4f8f,
- 0x505a, 0x59dd, 0x80c4, 0x546a, 0x5468, 0x55fe, 0x594f, 0x5b99, 0x5dde,
- 0x5eda, 0x665d, 0x6731, 0x67f1, 0x682a, 0x6ce8, 0x6d32, 0x6e4a, 0x6f8d,
- 0x70b7, 0x73e0, 0x7587, 0x7c4c, 0x7d02, 0x7d2c, 0x7da2, 0x821f, 0x86db,
- 0x8a3b, 0x8a85, 0x8d70, 0x8e8a, 0x8f33, 0x9031, 0x914e, 0x9152, 0x9444,
- 0x99d0, 0x7af9, 0x7ca5, 0x4fca, 0x5101, 0x51c6, 0x57c8, 0x5bef, 0x5cfb,
- 0x6659, 0x6a3d, 0x6d5a, 0x6e96, 0x6fec, 0x710c, 0x756f, 0x7ae3, 0x8822,
- 0x9021, 0x9075, 0x96cb, 0x99ff, 0x8301, 0x4e2d, 0x4ef2, 0x8846, 0x91cd,
- 0x537d, 0x6adb, 0x696b, 0x6c41, 0x847a, 0x589e, 0x618e, 0x66fe, 0x62ef,
- 0x70dd, 0x7511, 0x75c7, 0x7e52, 0x84b8, 0x8b49, 0x8d08, 0x4e4b, 0x53ea,
- 0x54ab, 0x5730, 0x5740, 0x5fd7, 0x6301, 0x6307, 0x646f, 0x652f, 0x65e8,
- 0x667a, 0x679d, 0x67b3, 0x6b62, 0x6c60, 0x6c9a, 0x6f2c, 0x77e5, 0x7825,
- 0x7949, 0x7957, 0x7d19, 0x80a2, 0x8102, 0x81f3, 0x829d, 0x82b7, 0x8718,
- 0x8a8c, 0xf9fc, 0x8d04, 0x8dbe, 0x9072, 0x76f4, 0x7a19, 0x7a37, 0x7e54,
- 0x8077, 0x5507, 0x55d4, 0x5875, 0x632f, 0x6422, 0x6649, 0x664b, 0x686d,
- 0x699b, 0x6b84, 0x6d25, 0x6eb1, 0x73cd, 0x7468, 0x74a1, 0x755b, 0x75b9,
- 0x76e1, 0x771e, 0x778b, 0x79e6, 0x7e09, 0x7e1d, 0x81fb, 0x852f, 0x8897,
- 0x8a3a, 0x8cd1, 0x8eeb, 0x8fb0, 0x9032, 0x93ad, 0x9663, 0x9673, 0x9707,
- 0x4f84, 0x53f1, 0x59ea, 0x5ac9, 0x5e19, 0x684e, 0x74c6, 0x75be, 0x79e9,
- 0x7a92, 0x81a3, 0x86ed, 0x8cea, 0x8dcc, 0x8fed, 0x659f, 0x6715, 0xf9fd,
- 0x57f7, 0x6f57, 0x7ddd, 0x8f2f, 0x93f6, 0x96c6, 0x5fb5, 0x61f2, 0x6f84,
- 0x4e14, 0x4f98, 0x501f, 0x53c9, 0x55df, 0x5d6f, 0x5dee, 0x6b21, 0x6b64,
- 0x78cb, 0x7b9a, 0xf9fe, 0x8e49, 0x8eca, 0x906e, 0x6349, 0x643e, 0x7740,
- 0x7a84, 0x932f, 0x947f, 0x9f6a, 0x64b0, 0x6faf, 0x71e6, 0x74a8, 0x74da,
- 0x7ac4, 0x7c12, 0x7e82, 0x7cb2, 0x7e98, 0x8b9a, 0x8d0a, 0x947d, 0x9910,
- 0x994c, 0x5239, 0x5bdf, 0x64e6, 0x672d, 0x7d2e, 0x50ed, 0x53c3, 0x5879,
- 0x6158, 0x6159, 0x61fa, 0x65ac, 0x7ad9, 0x8b92, 0x8b96, 0x5009, 0x5021,
- 0x5275, 0x5531, 0x5a3c, 0x5ee0, 0x5f70, 0x6134, 0x655e, 0x660c, 0x6636,
- 0x66a2, 0x69cd, 0x6ec4, 0x6f32, 0x7316, 0x7621, 0x7a93, 0x8139, 0x8259,
- 0x83d6, 0x84bc, 0x50b5, 0x57f0, 0x5bc0, 0x5be8, 0x5f69, 0x63a1, 0x7826,
- 0x7db5, 0x83dc, 0x8521, 0x91c7, 0x91f5, 0x518a, 0x67f5, 0x7b56, 0x8cac,
- 0x51c4, 0x59bb, 0x60bd, 0x8655, 0x501c, 0xf9ff, 0x5254, 0x5c3a, 0x617d,
- 0x621a, 0x62d3, 0x64f2, 0x65a5, 0x6ecc, 0x7620, 0x810a, 0x8e60, 0x965f,
- 0x96bb, 0x4edf, 0x5343, 0x5598, 0x5929, 0x5ddd, 0x64c5, 0x6cc9, 0x6dfa,
- 0x7394, 0x7a7f, 0x821b, 0x85a6, 0x8ce4, 0x8e10, 0x9077, 0x91e7, 0x95e1,
- 0x9621, 0x97c6, 0x51f8, 0x54f2, 0x5586, 0x5fb9, 0x64a4, 0x6f88, 0x7db4,
- 0x8f1f, 0x8f4d, 0x9435, 0x50c9, 0x5c16, 0x6cbe, 0x6dfb, 0x751b, 0x77bb,
- 0x7c3d, 0x7c64, 0x8a79, 0x8ac2, 0x581e, 0x59be, 0x5e16, 0x6377, 0x7252,
- 0x758a, 0x776b, 0x8adc, 0x8cbc, 0x8f12, 0x5ef3, 0x6674, 0x6df8, 0x807d,
- 0x83c1, 0x8acb, 0x9751, 0x9bd6, 0xfa00, 0x5243, 0x66ff, 0x6d95, 0x6eef,
- 0x7de0, 0x8ae6, 0x902e, 0x905e, 0x9ad4, 0x521d, 0x527f, 0x54e8, 0x6194,
- 0x6284, 0x62db, 0x68a2, 0x6912, 0x695a, 0x6a35, 0x7092, 0x7126, 0x785d,
- 0x7901, 0x790e, 0x79d2, 0x7a0d, 0x8096, 0x8278, 0x82d5, 0x8349, 0x8549,
- 0x8c82, 0x8d85, 0x9162, 0x918b, 0x91ae, 0x4fc3, 0x56d1, 0x71ed, 0x77d7,
- 0x8700, 0x89f8, 0x5bf8, 0x5fd6, 0x6751, 0x90a8, 0x53e2, 0x585a, 0x5bf5,
- 0x60a4, 0x6181, 0x6460, 0x7e3d, 0x8070, 0x8525, 0x9283, 0x64ae, 0x50ac,
- 0x5d14, 0x6700, 0x589c, 0x62bd, 0x63a8, 0x690e, 0x6978, 0x6a1e, 0x6e6b,
- 0x76ba, 0x79cb, 0x82bb, 0x8429, 0x8acf, 0x8da8, 0x8ffd, 0x9112, 0x914b,
- 0x919c, 0x9310, 0x9318, 0x939a, 0x96db, 0x9a36, 0x9c0d, 0x4e11, 0x755c,
- 0x795d, 0x7afa, 0x7b51, 0x7bc9, 0x7e2e, 0x84c4, 0x8e59, 0x8e74, 0x8ef8,
- 0x9010, 0x6625, 0x693f, 0x7443, 0x51fa, 0x672e, 0x9edc, 0x5145, 0x5fe0,
- 0x6c96, 0x87f2, 0x885d, 0x8877, 0x60b4, 0x81b5, 0x8403, 0x8d05, 0x53d6,
- 0x5439, 0x5634, 0x5a36, 0x5c31, 0x708a, 0x7fe0, 0x805a, 0x8106, 0x81ed,
- 0x8da3, 0x9189, 0x9a5f, 0x9df2, 0x5074, 0x4ec4, 0x53a0, 0x60fb, 0x6e2c,
- 0x5c64, 0x4f88, 0x5024, 0x55e4, 0x5cd9, 0x5e5f, 0x6065, 0x6894, 0x6cbb,
- 0x6dc4, 0x71be, 0x75d4, 0x75f4, 0x7661, 0x7a1a, 0x7a49, 0x7dc7, 0x7dfb,
- 0x7f6e, 0x81f4, 0x86a9, 0x8f1c, 0x96c9, 0x99b3, 0x9f52, 0x5247, 0x52c5,
- 0x98ed, 0x89aa, 0x4e03, 0x67d2, 0x6f06, 0x4fb5, 0x5be2, 0x6795, 0x6c88,
- 0x6d78, 0x741b, 0x7827, 0x91dd, 0x937c, 0x87c4, 0x79e4, 0x7a31, 0x5feb,
- 0x4ed6, 0x54a4, 0x553e, 0x58ae, 0x59a5, 0x60f0, 0x6253, 0x62d6, 0x6736,
- 0x6955, 0x8235, 0x9640, 0x99b1, 0x99dd, 0x502c, 0x5353, 0x5544, 0x577c,
- 0xfa01, 0x6258, 0xfa02, 0x64e2, 0x666b, 0x67dd, 0x6fc1, 0x6fef, 0x7422,
- 0x7438, 0x8a17, 0x9438, 0x5451, 0x5606, 0x5766, 0x5f48, 0x619a, 0x6b4e,
- 0x7058, 0x70ad, 0x7dbb, 0x8a95, 0x596a, 0x812b, 0x63a2, 0x7708, 0x803d,
- 0x8caa, 0x5854, 0x642d, 0x69bb, 0x5b95, 0x5e11, 0x6e6f, 0xfa03, 0x8569,
- 0x514c, 0x53f0, 0x592a, 0x6020, 0x614b, 0x6b86, 0x6c70, 0x6cf0, 0x7b1e,
- 0x80ce, 0x82d4, 0x8dc6, 0x90b0, 0x98b1, 0xfa04, 0x64c7, 0x6fa4, 0x6491,
- 0x6504, 0x514e, 0x5410, 0x571f, 0x8a0e, 0x615f, 0x6876, 0xfa05, 0x75db,
- 0x7b52, 0x7d71, 0x901a, 0x5806, 0x69cc, 0x817f, 0x892a, 0x9000, 0x9839,
- 0x5078, 0x5957, 0x59ac, 0x6295, 0x900f, 0x9b2a, 0x615d, 0x7279, 0x95d6,
- 0x5761, 0x5a46, 0x5df4, 0x628a, 0x64ad, 0x64fa, 0x6777, 0x6ce2, 0x6d3e,
- 0x722c, 0x7436, 0x7834, 0x7f77, 0x82ad, 0x8ddb, 0x9817, 0x5224, 0x5742,
- 0x677f, 0x7248, 0x74e3, 0x8ca9, 0x8fa6, 0x9211, 0x962a, 0x516b, 0x53ed,
- 0x634c, 0x4f69, 0x5504, 0x6096, 0x6557, 0x6c9b, 0x6d7f, 0x724c, 0x72fd,
- 0x7a17, 0x8987, 0x8c9d, 0x5f6d, 0x6f8e, 0x70f9, 0x81a8, 0x610e, 0x4fbf,
- 0x504f, 0x6241, 0x7247, 0x7bc7, 0x7de8, 0x7fe9, 0x904d, 0x97ad, 0x9a19,
- 0x8cb6, 0x576a, 0x5e73, 0x67b0, 0x840d, 0x8a55, 0x5420, 0x5b16, 0x5e63,
- 0x5ee2, 0x5f0a, 0x6583, 0x80ba, 0x853d, 0x9589, 0x965b, 0x4f48, 0x5305,
- 0x530d, 0x530f, 0x5486, 0x54fa, 0x5703, 0x5e03, 0x6016, 0x629b, 0x62b1,
- 0x6355, 0xfa06, 0x6ce1, 0x6d66, 0x75b1, 0x7832, 0x80de, 0x812f, 0x82de,
- 0x8461, 0x84b2, 0x888d, 0x8912, 0x900b, 0x92ea, 0x98fd, 0x9b91, 0x5e45,
- 0x66b4, 0x66dd, 0x7011, 0x7206, 0xfa07, 0x4ff5, 0x527d, 0x5f6a, 0x6153,
- 0x6753, 0x6a19, 0x6f02, 0x74e2, 0x7968, 0x8868, 0x8c79, 0x98c7, 0x98c4,
- 0x9a43, 0x54c1, 0x7a1f, 0x6953, 0x8af7, 0x8c4a, 0x98a8, 0x99ae, 0x5f7c,
- 0x62ab, 0x75b2, 0x76ae, 0x88ab, 0x907f, 0x9642, 0x5339, 0x5f3c, 0x5fc5,
- 0x6ccc, 0x73cc, 0x7562, 0x758b, 0x7b46, 0x82fe, 0x999d, 0x4e4f, 0x903c,
- 0x4e0b, 0x4f55, 0x53a6, 0x590f, 0x5ec8, 0x6630, 0x6cb3, 0x7455, 0x8377,
- 0x8766, 0x8cc0, 0x9050, 0x971e, 0x9c15, 0x58d1, 0x5b78, 0x8650, 0x8b14,
- 0x9db4, 0x5bd2, 0x6068, 0x608d, 0x65f1, 0x6c57, 0x6f22, 0x6fa3, 0x701a,
- 0x7f55, 0x7ff0, 0x9591, 0x9592, 0x9650, 0x97d3, 0x5272, 0x8f44, 0x51fd,
- 0x542b, 0x54b8, 0x5563, 0x558a, 0x6abb, 0x6db5, 0x7dd8, 0x8266, 0x929c,
- 0x9677, 0x9e79, 0x5408, 0x54c8, 0x76d2, 0x86e4, 0x95a4, 0x95d4, 0x965c,
- 0x4ea2, 0x4f09, 0x59ee, 0x5ae6, 0x5df7, 0x6052, 0x6297, 0x676d, 0x6841,
- 0x6c86, 0x6e2f, 0x7f38, 0x809b, 0x822a, 0xfa08, 0xfa09, 0x9805, 0x4ea5,
- 0x5055, 0x54b3, 0x5793, 0x595a, 0x5b69, 0x5bb3, 0x61c8, 0x6977, 0x6d77,
- 0x7023, 0x87f9, 0x89e3, 0x8a72, 0x8ae7, 0x9082, 0x99ed, 0x9ab8, 0x52be,
- 0x6838, 0x5016, 0x5e78, 0x674f, 0x8347, 0x884c, 0x4eab, 0x5411, 0x56ae,
- 0x73e6, 0x9115, 0x97ff, 0x9909, 0x9957, 0x9999, 0x5653, 0x589f, 0x865b,
- 0x8a31, 0x61b2, 0x6af6, 0x737b, 0x8ed2, 0x6b47, 0x96aa, 0x9a57, 0x5955,
- 0x7200, 0x8d6b, 0x9769, 0x4fd4, 0x5cf4, 0x5f26, 0x61f8, 0x665b, 0x6ceb,
- 0x70ab, 0x7384, 0x73b9, 0x73fe, 0x7729, 0x774d, 0x7d43, 0x7d62, 0x7e23,
- 0x8237, 0x8852, 0xfa0a, 0x8ce2, 0x9249, 0x986f, 0x5b51, 0x7a74, 0x8840,
- 0x9801, 0x5acc, 0x4fe0, 0x5354, 0x593e, 0x5cfd, 0x633e, 0x6d79, 0x72f9,
- 0x8105, 0x8107, 0x83a2, 0x92cf, 0x9830, 0x4ea8, 0x5144, 0x5211, 0x578b,
- 0x5f62, 0x6cc2, 0x6ece, 0x7005, 0x7050, 0x70af, 0x7192, 0x73e9, 0x7469,
- 0x834a, 0x87a2, 0x8861, 0x9008, 0x90a2, 0x93a3, 0x99a8, 0x516e, 0x5f57,
- 0x60e0, 0x6167, 0x66b3, 0x8559, 0x8e4a, 0x91af, 0x978b, 0x4e4e, 0x4e92,
- 0x547c, 0x58d5, 0x58fa, 0x597d, 0x5cb5, 0x5f27, 0x6236, 0x6248, 0x660a,
- 0x6667, 0x6beb, 0x6d69, 0x6dcf, 0x6e56, 0x6ef8, 0x6f94, 0x6fe0, 0x6fe9,
- 0x705d, 0x72d0, 0x7425, 0x745a, 0x74e0, 0x7693, 0x795c, 0x7cca, 0x7e1e,
- 0x80e1, 0x82a6, 0x846b, 0x84bf, 0x864e, 0x865f, 0x8774, 0x8b77, 0x8c6a,
- 0x93ac, 0x9800, 0x9865, 0x60d1, 0x6216, 0x9177, 0x5a5a, 0x660f, 0x6df7,
- 0x6e3e, 0x743f, 0x9b42, 0x5ffd, 0x60da, 0x7b0f, 0x54c4, 0x5f18, 0x6c5e,
- 0x6cd3, 0x6d2a, 0x70d8, 0x7d05, 0x8679, 0x8a0c, 0x9d3b, 0x5316, 0x548c,
- 0x5b05, 0x6a3a, 0x706b, 0x7575, 0x798d, 0x79be, 0x82b1, 0x83ef, 0x8a71,
- 0x8b41, 0x8ca8, 0x9774, 0xfa0b, 0x64f4, 0x652b, 0x78ba, 0x78bb, 0x7a6b,
- 0x4e38, 0x559a, 0x5950, 0x5ba6, 0x5e7b, 0x60a3, 0x63db, 0x6b61, 0x6665,
- 0x6853, 0x6e19, 0x7165, 0x74b0, 0x7d08, 0x9084, 0x9a69, 0x9c25, 0x6d3b,
- 0x6ed1, 0x733e, 0x8c41, 0x95ca, 0x51f0, 0x5e4c, 0x5fa8, 0x604d, 0x60f6,
- 0x6130, 0x614c, 0x6643, 0x6644, 0x69a5, 0x6cc1, 0x6e5f, 0x6ec9, 0x6f62,
- 0x714c, 0x749c, 0x7687, 0x7bc1, 0x7c27, 0x8352, 0x8757, 0x9051, 0x968d,
- 0x9ec3, 0x532f, 0x56de, 0x5efb, 0x5f8a, 0x6062, 0x6094, 0x61f7, 0x6666,
- 0x6703, 0x6a9c, 0x6dee, 0x6fae, 0x7070, 0x736a, 0x7e6a, 0x81be, 0x8334,
- 0x86d4, 0x8aa8, 0x8cc4, 0x5283, 0x7372, 0x5b96, 0x6a6b, 0x9404, 0x54ee,
- 0x5686, 0x5b5d, 0x6548, 0x6585, 0x66c9, 0x689f, 0x6d8d, 0x6dc6, 0x723b,
- 0x80b4, 0x9175, 0x9a4d, 0x4faf, 0x5019, 0x539a, 0x540e, 0x543c, 0x5589,
- 0x55c5, 0x5e3f, 0x5f8c, 0x673d, 0x7166, 0x73dd, 0x9005, 0x52db, 0x52f3,
- 0x5864, 0x58ce, 0x7104, 0x718f, 0x71fb, 0x85b0, 0x8a13, 0x6688, 0x85a8,
- 0x55a7, 0x6684, 0x714a, 0x8431, 0x5349, 0x5599, 0x6bc1, 0x5f59, 0x5fbd,
- 0x63ee, 0x6689, 0x7147, 0x8af1, 0x8f1d, 0x9ebe, 0x4f11, 0x643a, 0x70cb,
- 0x7566, 0x8667, 0x6064, 0x8b4e, 0x9df8, 0x5147, 0x51f6, 0x5308, 0x6d36,
- 0x80f8, 0x9ed1, 0x6615, 0x6b23, 0x7098, 0x75d5, 0x5403, 0x5c79, 0x7d07,
- 0x8a16, 0x6b20, 0x6b3d, 0x6b46, 0x5438, 0x6070, 0x6d3d, 0x7fd5, 0x8208,
- 0x50d6, 0x51de, 0x559c, 0x566b, 0x56cd, 0x59ec, 0x5b09, 0x5e0c, 0x6199,
- 0x6198, 0x6231, 0x665e, 0x66e6, 0x7199, 0x71b9, 0x71ba, 0x72a7, 0x79a7,
- 0x7a00, 0x7fb2, 0x8a70,
+ 0x3000, 0x3001, 0x3002, 0x00b7, 0x2025, 0x2026, 0x00a8, 0x3003, 0x00ad,
+ 0x2015, 0x2225, 0xff3c, 0x223c, 0x2018, 0x2019, 0x201c, 0x201d, 0x3014,
+ 0x3015, 0x3008, 0x3009, 0x300a, 0x300b, 0x300c, 0x300d, 0x300e, 0x300f,
+ 0x3010, 0x3011, 0x00b1, 0x00d7, 0x00f7, 0x2260, 0x2264, 0x2265, 0x221e,
+ 0x2234, 0x00b0, 0x2032, 0x2033, 0x2103, 0x212b, 0xffe0, 0xffe1, 0xffe5,
+ 0x2642, 0x2640, 0x2220, 0x22a5, 0x2312, 0x2202, 0x2207, 0x2261, 0x2252,
+ 0x00a7, 0x203b, 0x2606, 0x2605, 0x25cb, 0x25cf, 0x25ce, 0x25c7, 0x25c6,
+ 0x25a1, 0x25a0, 0x25b3, 0x25b2, 0x25bd, 0x25bc, 0x2192, 0x2190, 0x2191,
+ 0x2193, 0x2194, 0x3013, 0x226a, 0x226b, 0x221a, 0x223d, 0x221d, 0x2235,
+ 0x222b, 0x222c, 0x2208, 0x220b, 0x2286, 0x2287, 0x2282, 0x2283, 0x222a,
+ 0x2229, 0x2227, 0x2228, 0xffe2, 0x21d2, 0x21d4, 0x2200, 0x2203, 0x00b4,
+ 0xff5e, 0x02c7, 0x02d8, 0x02dd, 0x02da, 0x02d9, 0x00b8, 0x02db, 0x00a1,
+ 0x00bf, 0x02d0, 0x222e, 0x2211, 0x220f, 0x00a4, 0x2109, 0x2030, 0x25c1,
+ 0x25c0, 0x25b7, 0x25b6, 0x2664, 0x2660, 0x2661, 0x2665, 0x2667, 0x2663,
+ 0x25c9, 0x25c8, 0x25a3, 0x25d0, 0x25d1, 0x2592, 0x25a4, 0x25a5, 0x25a8,
+ 0x25a7, 0x25a6, 0x25a9, 0x2668, 0x260f, 0x260e, 0x261c, 0x261e, 0x00b6,
+ 0x2020, 0x2021, 0x2195, 0x2197, 0x2199, 0x2196, 0x2198, 0x266d, 0x2669,
+ 0x266a, 0x266c, 0x327f, 0x321c, 0x2116, 0x33c7, 0x2122, 0x33c2, 0x33d8,
+ 0x2121, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, 0xff01,
+ 0xff02, 0xff03, 0xff04, 0xff05, 0xff06, 0xff07, 0xff08, 0xff09, 0xff0a,
+ 0xff0b, 0xff0c, 0xff0d, 0xff0e, 0xff0f, 0xff10, 0xff11, 0xff12, 0xff13,
+ 0xff14, 0xff15, 0xff16, 0xff17, 0xff18, 0xff19, 0xff1a, 0xff1b, 0xff1c,
+ 0xff1d, 0xff1e, 0xff1f, 0xff20, 0xff21, 0xff22, 0xff23, 0xff24, 0xff25,
+ 0xff26, 0xff27, 0xff28, 0xff29, 0xff2a, 0xff2b, 0xff2c, 0xff2d, 0xff2e,
+ 0xff2f, 0xff30, 0xff31, 0xff32, 0xff33, 0xff34, 0xff35, 0xff36, 0xff37,
+ 0xff38, 0xff39, 0xff3a, 0xff3b, 0xffe6, 0xff3d, 0xff3e, 0xff3f, 0xff40,
+ 0xff41, 0xff42, 0xff43, 0xff44, 0xff45, 0xff46, 0xff47, 0xff48, 0xff49,
+ 0xff4a, 0xff4b, 0xff4c, 0xff4d, 0xff4e, 0xff4f, 0xff50, 0xff51, 0xff52,
+ 0xff53, 0xff54, 0xff55, 0xff56, 0xff57, 0xff58, 0xff59, 0xff5a, 0xff5b,
+ 0xff5c, 0xff5d, 0xffe3, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136,
+ 0x3137, 0x3138, 0x3139, 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
+ 0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147, 0x3148,
+ 0x3149, 0x314a, 0x314b, 0x314c, 0x314d, 0x314e, 0x314f, 0x3150, 0x3151,
+ 0x3152, 0x3153, 0x3154, 0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315a,
+ 0x315b, 0x315c, 0x315d, 0x315e, 0x315f, 0x3160, 0x3161, 0x3162, 0x3163,
+ 0x3164, 0x3165, 0x3166, 0x3167, 0x3168, 0x3169, 0x316a, 0x316b, 0x316c,
+ 0x316d, 0x316e, 0x316f, 0x3170, 0x3171, 0x3172, 0x3173, 0x3174, 0x3175,
+ 0x3176, 0x3177, 0x3178, 0x3179, 0x317a, 0x317b, 0x317c, 0x317d, 0x317e,
+ 0x317f, 0x3180, 0x3181, 0x3182, 0x3183, 0x3184, 0x3185, 0x3186, 0x3187,
+ 0x3188, 0x3189, 0x318a, 0x318b, 0x318c, 0x318d, 0x318e, 0x2170, 0x2171,
+ 0x2172, 0x2173, 0x2174, 0x2175, 0x2176, 0x2177, 0x2178, 0x2179, -1,
+ -1, -1, -1, -1, 0x2160, 0x2161, 0x2162, 0x2163, 0x2164,
+ 0x2165, 0x2166, 0x2167, 0x2168, 0x2169, -1, -1, -1, -1,
+ -1, -1, -1, 0x0391, 0x0392, 0x0393, 0x0394, 0x0395, 0x0396,
+ 0x0397, 0x0398, 0x0399, 0x039a, 0x039b, 0x039c, 0x039d, 0x039e, 0x039f,
+ 0x03a0, 0x03a1, 0x03a3, 0x03a4, 0x03a5, 0x03a6, 0x03a7, 0x03a8, 0x03a9,
+ -1, -1, -1, -1, -1, -1, -1, -1, 0x03b1,
+ 0x03b2, 0x03b3, 0x03b4, 0x03b5, 0x03b6, 0x03b7, 0x03b8, 0x03b9, 0x03ba,
+ 0x03bb, 0x03bc, 0x03bd, 0x03be, 0x03bf, 0x03c0, 0x03c1, 0x03c3, 0x03c4,
+ 0x03c5, 0x03c6, 0x03c7, 0x03c8, 0x03c9, -1, -1, -1, -1,
+ -1, -1, 0x2500, 0x2502, 0x250c, 0x2510, 0x2518, 0x2514, 0x251c,
+ 0x252c, 0x2524, 0x2534, 0x253c, 0x2501, 0x2503, 0x250f, 0x2513, 0x251b,
+ 0x2517, 0x2523, 0x2533, 0x252b, 0x253b, 0x254b, 0x2520, 0x252f, 0x2528,
+ 0x2537, 0x253f, 0x251d, 0x2530, 0x2525, 0x2538, 0x2542, 0x2512, 0x2511,
+ 0x251a, 0x2519, 0x2516, 0x2515, 0x250e, 0x250d, 0x251e, 0x251f, 0x2521,
+ 0x2522, 0x2526, 0x2527, 0x2529, 0x252a, 0x252d, 0x252e, 0x2531, 0x2532,
+ 0x2535, 0x2536, 0x2539, 0x253a, 0x253d, 0x253e, 0x2540, 0x2541, 0x2543,
+ 0x2544, 0x2545, 0x2546, 0x2547, 0x2548, 0x2549, 0x254a, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 0x3395, 0x3396, 0x3397,
+ 0x2113, 0x3398, 0x33c4, 0x33a3, 0x33a4, 0x33a5, 0x33a6, 0x3399, 0x339a,
+ 0x339b, 0x339c, 0x339d, 0x339e, 0x339f, 0x33a0, 0x33a1, 0x33a2, 0x33ca,
+ 0x338d, 0x338e, 0x338f, 0x33cf, 0x3388, 0x3389, 0x33c8, 0x33a7, 0x33a8,
+ 0x33b0, 0x33b1, 0x33b2, 0x33b3, 0x33b4, 0x33b5, 0x33b6, 0x33b7, 0x33b8,
+ 0x33b9, 0x3380, 0x3381, 0x3382, 0x3383, 0x3384, 0x33ba, 0x33bb, 0x33bc,
+ 0x33bd, 0x33be, 0x33bf, 0x3390, 0x3391, 0x3392, 0x3393, 0x3394, 0x2126,
+ 0x33c0, 0x33c1, 0x338a, 0x338b, 0x338c, 0x33d6, 0x33c5, 0x33ad, 0x33ae,
+ 0x33af, 0x33db, 0x33a9, 0x33aa, 0x33ab, 0x33ac, 0x33dd, 0x33d0, 0x33d3,
+ 0x33c3, 0x33c9, 0x33dc, 0x33c6, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, 0x00c6, 0x00d0, 0x00aa, 0x0126, -1, 0x0132, -1, 0x013f,
+ 0x0141, 0x00d8, 0x0152, 0x00ba, 0x00de, 0x0166, 0x014a, -1, 0x3260,
+ 0x3261, 0x3262, 0x3263, 0x3264, 0x3265, 0x3266, 0x3267, 0x3268, 0x3269,
+ 0x326a, 0x326b, 0x326c, 0x326d, 0x326e, 0x326f, 0x3270, 0x3271, 0x3272,
+ 0x3273, 0x3274, 0x3275, 0x3276, 0x3277, 0x3278, 0x3279, 0x327a, 0x327b,
+ 0x24d0, 0x24d1, 0x24d2, 0x24d3, 0x24d4, 0x24d5, 0x24d6, 0x24d7, 0x24d8,
+ 0x24d9, 0x24da, 0x24db, 0x24dc, 0x24dd, 0x24de, 0x24df, 0x24e0, 0x24e1,
+ 0x24e2, 0x24e3, 0x24e4, 0x24e5, 0x24e6, 0x24e7, 0x24e8, 0x24e9, 0x2460,
+ 0x2461, 0x2462, 0x2463, 0x2464, 0x2465, 0x2466, 0x2467, 0x2468, 0x2469,
+ 0x246a, 0x246b, 0x246c, 0x246d, 0x246e, 0x00bd, 0x2153, 0x2154, 0x00bc,
+ 0x00be, 0x215b, 0x215c, 0x215d, 0x215e, 0x00e6, 0x0111, 0x00f0, 0x0127,
+ 0x0131, 0x0133, 0x0138, 0x0140, 0x0142, 0x00f8, 0x0153, 0x00df, 0x00fe,
+ 0x0167, 0x014b, 0x0149, 0x3200, 0x3201, 0x3202, 0x3203, 0x3204, 0x3205,
+ 0x3206, 0x3207, 0x3208, 0x3209, 0x320a, 0x320b, 0x320c, 0x320d, 0x320e,
+ 0x320f, 0x3210, 0x3211, 0x3212, 0x3213, 0x3214, 0x3215, 0x3216, 0x3217,
+ 0x3218, 0x3219, 0x321a, 0x321b, 0x249c, 0x249d, 0x249e, 0x249f, 0x24a0,
+ 0x24a1, 0x24a2, 0x24a3, 0x24a4, 0x24a5, 0x24a6, 0x24a7, 0x24a8, 0x24a9,
+ 0x24aa, 0x24ab, 0x24ac, 0x24ad, 0x24ae, 0x24af, 0x24b0, 0x24b1, 0x24b2,
+ 0x24b3, 0x24b4, 0x24b5, 0x2474, 0x2475, 0x2476, 0x2477, 0x2478, 0x2479,
+ 0x247a, 0x247b, 0x247c, 0x247d, 0x247e, 0x247f, 0x2480, 0x2481, 0x2482,
+ 0x00b9, 0x00b2, 0x00b3, 0x2074, 0x207f, 0x2081, 0x2082, 0x2083, 0x2084,
+ 0x3041, 0x3042, 0x3043, 0x3044, 0x3045, 0x3046, 0x3047, 0x3048, 0x3049,
+ 0x304a, 0x304b, 0x304c, 0x304d, 0x304e, 0x304f, 0x3050, 0x3051, 0x3052,
+ 0x3053, 0x3054, 0x3055, 0x3056, 0x3057, 0x3058, 0x3059, 0x305a, 0x305b,
+ 0x305c, 0x305d, 0x305e, 0x305f, 0x3060, 0x3061, 0x3062, 0x3063, 0x3064,
+ 0x3065, 0x3066, 0x3067, 0x3068, 0x3069, 0x306a, 0x306b, 0x306c, 0x306d,
+ 0x306e, 0x306f, 0x3070, 0x3071, 0x3072, 0x3073, 0x3074, 0x3075, 0x3076,
+ 0x3077, 0x3078, 0x3079, 0x307a, 0x307b, 0x307c, 0x307d, 0x307e, 0x307f,
+ 0x3080, 0x3081, 0x3082, 0x3083, 0x3084, 0x3085, 0x3086, 0x3087, 0x3088,
+ 0x3089, 0x308a, 0x308b, 0x308c, 0x308d, 0x308e, 0x308f, 0x3090, 0x3091,
+ 0x3092, 0x3093, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, 0x30a1, 0x30a2, 0x30a3, 0x30a4, 0x30a5,
+ 0x30a6, 0x30a7, 0x30a8, 0x30a9, 0x30aa, 0x30ab, 0x30ac, 0x30ad, 0x30ae,
+ 0x30af, 0x30b0, 0x30b1, 0x30b2, 0x30b3, 0x30b4, 0x30b5, 0x30b6, 0x30b7,
+ 0x30b8, 0x30b9, 0x30ba, 0x30bb, 0x30bc, 0x30bd, 0x30be, 0x30bf, 0x30c0,
+ 0x30c1, 0x30c2, 0x30c3, 0x30c4, 0x30c5, 0x30c6, 0x30c7, 0x30c8, 0x30c9,
+ 0x30ca, 0x30cb, 0x30cc, 0x30cd, 0x30ce, 0x30cf, 0x30d0, 0x30d1, 0x30d2,
+ 0x30d3, 0x30d4, 0x30d5, 0x30d6, 0x30d7, 0x30d8, 0x30d9, 0x30da, 0x30db,
+ 0x30dc, 0x30dd, 0x30de, 0x30df, 0x30e0, 0x30e1, 0x30e2, 0x30e3, 0x30e4,
+ 0x30e5, 0x30e6, 0x30e7, 0x30e8, 0x30e9, 0x30ea, 0x30eb, 0x30ec, 0x30ed,
+ 0x30ee, 0x30ef, 0x30f0, 0x30f1, 0x30f2, 0x30f3, 0x30f4, 0x30f5, 0x30f6,
+ -1, -1, -1, -1, -1, -1, -1, -1, 0x0410,
+ 0x0411, 0x0412, 0x0413, 0x0414, 0x0415, 0x0401, 0x0416, 0x0417, 0x0418,
+ 0x0419, 0x041a, 0x041b, 0x041c, 0x041d, 0x041e, 0x041f, 0x0420, 0x0421,
+ 0x0422, 0x0423, 0x0424, 0x0425, 0x0426, 0x0427, 0x0428, 0x0429, 0x042a,
+ 0x042b, 0x042c, 0x042d, 0x042e, 0x042f, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 0x0430, 0x0431, 0x0432, 0x0433, 0x0434, 0x0435, 0x0451,
+ 0x0436, 0x0437, 0x0438, 0x0439, 0x043a, 0x043b, 0x043c, 0x043d, 0x043e,
+ 0x043f, 0x0440, 0x0441, 0x0442, 0x0443, 0x0444, 0x0445, 0x0446, 0x0447,
+ 0x0448, 0x0449, 0x044a, 0x044b, 0x044c, 0x044d, 0x044e, 0x044f, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, 0x3400, 0x3401, 0x3402,
+ 0x3403, 0x3404, 0x3405, 0x3406, 0x3407, 0x3408, 0x3409, 0x340a, 0x340b,
+ 0x340c, 0x340d, 0x340e, 0x340f, 0x3410, 0x3411, 0x3412, 0x3413, 0x3414,
+ 0x3415, 0x3416, 0x3417, 0x3418, 0x3419, 0x341a, 0x341b, 0x341c, 0x341d,
+ 0x341e, 0x341f, 0x3420, 0x3421, 0x3422, 0x3423, 0x3424, 0x3425, 0x3426,
+ 0x3427, 0x3428, 0x3429, 0x342a, 0x342b, 0x342c, 0x342d, 0x342e, 0x342f,
+ 0x3430, 0x3431, 0x3432, 0x3433, 0x3434, 0x3435, 0x3436, 0x3437, 0x3438,
+ 0x3439, 0x343a, 0x343b, 0x343c, 0x343d, 0x343e, 0x343f, 0x3440, 0x3441,
+ 0x3442, 0x3443, 0x3444, 0x3445, 0x3446, 0x3447, 0x3448, 0x3449, 0x344a,
+ 0x344b, 0x344c, 0x344d, 0x344e, 0x344f, 0x3450, 0x3451, 0x3452, 0x3453,
+ 0x3454, 0x3455, 0x3456, 0x3457, 0x3458, 0x3459, 0x345a, 0x345b, 0x345c,
+ 0x345d, 0x345e, 0x345f, 0x3460, 0x3461, 0x3462, 0x3463, 0x3464, 0x3465,
+ 0x3466, 0x3467, 0x3468, 0x3469, 0x346a, 0x346b, 0x346c, 0x346d, 0x346e,
+ 0x346f, 0x3470, 0x3471, 0x3472, 0x3473, 0x3474, 0x3475, 0x3476, 0x3477,
+ 0x3478, 0x3479, 0x347a, 0x347b, 0x347c, 0x347d, 0x347e, 0x347f, 0x3480,
+ 0x3481, 0x3482, 0x3483, 0x3484, 0x3485, 0x3486, 0x3487, 0x3488, 0x3489,
+ 0x348a, 0x348b, 0x348c, 0x348d, 0x348e, 0x348f, 0x3490, 0x3491, 0x3492,
+ 0x3493, 0x3494, 0x3495, 0x3496, 0x3497, 0x3498, 0x3499, 0x349a, 0x349b,
+ 0x349c, 0x349d, 0x349e, 0x349f, 0x34a0, 0x34a1, 0x34a2, 0x34a3, 0x34a4,
+ 0x34a5, 0x34a6, 0x34a7, 0x34a8, 0x34a9, 0x34aa, 0x34ab, 0x34ac, 0x34ad,
+ 0x34ae, 0x34af, 0x34b0, 0x34b1, 0x34b2, 0x34b3, 0x34b4, 0x34b5, 0x34b6,
+ 0x34b7, 0x34b8, 0x34b9, 0x34ba, 0x34bb, 0x34bc, 0x34bd, 0x34be, 0x34bf,
+ 0x34c0, 0x34c1, 0x34c2, 0x34c3, 0x34c4, 0x34c5, 0x34c6, 0x34c7, 0x34c8,
+ 0x34c9, 0x34ca, 0x34cb, 0x34cc, 0x34cd, 0x34ce, 0x34cf, 0x34d0, 0x34d1,
+ 0x34d2, 0x34d3, 0x34d4, 0x34d5, 0x34d6, 0x34d7, 0x34d8, 0x34d9, 0x34da,
+ 0x34db, 0x34dc, 0x34dd, 0x34de, 0x34df, 0x34e0, 0x34e1, 0x34e2, 0x34e3,
+ 0x34e4, 0x34e5, 0x34e6, 0x34e7, 0x34e8, 0x34e9, 0x34ea, 0x34eb, 0x34ec,
+ 0x34ed, 0x34ee, 0x34ef, 0x34f0, 0x34f1, 0x34f2, 0x34f3, 0x34f4, 0x34f5,
+ 0x34f6, 0x34f7, 0x34f8, 0x34f9, 0x34fa, 0x34fb, 0x34fc, 0x34fd, 0x34fe,
+ 0x34ff, 0x3500, 0x3501, 0x3502, 0x3503, 0x3504, 0x3505, 0x3506, 0x3507,
+ 0x3508, 0x3509, 0x350a, 0x350b, 0x350c, 0x350d, 0x350e, 0x350f, 0x3510,
+ 0x3511, 0x3512, 0x3513, 0x3514, 0x3515, 0x3516, 0x3517, 0x3518, 0x3519,
+ 0x351a, 0x351b, 0x351c, 0x351d, 0x351e, 0x351f, 0x3520, 0x3521, 0x3522,
+ 0x3523, 0x3524, 0x3525, 0x3526, 0x3527, 0x3528, 0x3529, 0x352a, 0x352b,
+ 0x352c, 0x352d, 0x352e, 0x352f, 0x3530, 0x3531, 0x3532, 0x3533, 0x3534,
+ 0x3535, 0x3536, 0x3537, 0x3538, 0x3539, 0x353a, 0x353b, 0x353c, 0x353d,
+ 0x353e, 0x353f, 0x3540, 0x3541, 0x3542, 0x3543, 0x3544, 0x3545, 0x3546,
+ 0x3547, 0x3548, 0x3549, 0x354a, 0x354b, 0x354c, 0x354d, 0x354e, 0x354f,
+ 0x3550, 0x3551, 0x3552, 0x3553, 0x3554, 0x3555, 0x3556, 0x3557, 0x3558,
+ 0x3559, 0x355a, 0x355b, 0x355c, 0x355d, 0x355e, 0x355f, 0x3560, 0x3561,
+ 0x3562, 0x3563, 0x3564, 0x3565, 0x3566, 0x3567, 0x3568, 0x3569, 0x356a,
+ 0x356b, 0x356c, 0x356d, 0x356e, 0x356f, 0x3570, 0x3571, 0x3572, 0x3573,
+ 0x3574, 0x3575, 0x3576, 0x3577, 0x3578, 0x3579, 0x357a, 0x357b, 0x357c,
+ 0x357d, 0x357e, 0x357f, 0x3580, 0x3581, 0x3582, 0x3583, 0x3584, 0x3585,
+ 0x3586, 0x3587, 0x3588, 0x3589, 0x358a, 0x358b, 0x358c, 0x358d, 0x358e,
+ 0x358f, 0x3590, 0x3591, 0x3592, 0x3593, 0x3594, 0x3595, 0x3596, 0x3597,
+ 0x3598, 0x3599, 0x359a, 0x359b, 0x359c, 0x359d, 0x359e, 0x359f, 0x35a0,
+ 0x35a1, 0x35a2, 0x35a3, 0x35a4, 0x35a5, 0x35a6, 0x35a7, 0x35a8, 0x35a9,
+ 0x35aa, 0x35ab, 0x35ac, 0x35ad, 0x35ae, 0x35af, 0x35b0, 0x35b1, 0x35b2,
+ 0x35b3, 0x35b4, 0x35b5, 0x35b6, 0x35b7, 0x35b8, 0x35b9, 0x35ba, 0x35bb,
+ 0x35bc, 0x35bd, 0x35be, 0x35bf, 0x35c0, 0x35c1, 0x35c2, 0x35c3, 0x35c4,
+ 0x35c5, 0x35c6, 0x35c7, 0x35c8, 0x35c9, 0x35ca, 0x35cb, 0x35cc, 0x35cd,
+ 0x35ce, 0x35cf, 0x35d0, 0x35d1, 0x35d2, 0x35d3, 0x35d4, 0x35d5, 0x35d6,
+ 0x35d7, 0x35d8, 0x35d9, 0x35da, 0x35db, 0x35dc, 0x35dd, 0x35de, 0x35df,
+ 0x35e0, 0x35e1, 0x35e2, 0x35e3, 0x35e4, 0x35e5, 0x35e6, 0x35e7, 0x35e8,
+ 0x35e9, 0x35ea, 0x35eb, 0x35ec, 0x35ed, 0x35ee, 0x35ef, 0x35f0, 0x35f1,
+ 0x35f2, 0x35f3, 0x35f4, 0x35f5, 0x35f6, 0x35f7, 0x35f8, 0x35f9, 0x35fa,
+ 0x35fb, 0x35fc, 0x35fd, 0x35fe, 0x35ff, 0x3600, 0x3601, 0x3602, 0x3603,
+ 0x3604, 0x3605, 0x3606, 0x3607, 0x3608, 0x3609, 0x360a, 0x360b, 0x360c,
+ 0x360d, 0x360e, 0x360f, 0x3610, 0x3611, 0x3612, 0x3613, 0x3614, 0x3615,
+ 0x3616, 0x3617, 0x3618, 0x3619, 0x361a, 0x361b, 0x361c, 0x361d, 0x361e,
+ 0x361f, 0x3620, 0x3621, 0x3622, 0x3623, 0x3624, 0x3625, 0x3626, 0x3627,
+ 0x3628, 0x3629, 0x362a, 0x362b, 0x362c, 0x362d, 0x362e, 0x362f, 0x3630,
+ 0x3631, 0x3632, 0x3633, 0x3634, 0x3635, 0x3636, 0x3637, 0x3638, 0x3639,
+ 0x363a, 0x363b, 0x363c, 0x363d, 0x363e, 0x363f, 0x3640, 0x3641, 0x3642,
+ 0x3643, 0x3644, 0x3645, 0x3646, 0x3647, 0x3648, 0x3649, 0x364a, 0x364b,
+ 0x364c, 0x364d, 0x364e, 0x364f, 0x3650, 0x3651, 0x3652, 0x3653, 0x3654,
+ 0x3655, 0x3656, 0x3657, 0x3658, 0x3659, 0x365a, 0x365b, 0x365c, 0x365d,
+ 0x365e, 0x365f, 0x3660, 0x3661, 0x3662, 0x3663, 0x3664, 0x3665, 0x3666,
+ 0x3667, 0x3668, 0x3669, 0x366a, 0x366b, 0x366c, 0x366d, 0x366e, 0x366f,
+ 0x3670, 0x3671, 0x3672, 0x3673, 0x3674, 0x3675, 0x3676, 0x3677, 0x3678,
+ 0x3679, 0x367a, 0x367b, 0x367c, 0x367d, 0x367e, 0x367f, 0x3680, 0x3681,
+ 0x3682, 0x3683, 0x3684, 0x3685, 0x3686, 0x3687, 0x3688, 0x3689, 0x368a,
+ 0x368b, 0x368c, 0x368d, 0x368e, 0x368f, 0x3690, 0x3691, 0x3692, 0x3693,
+ 0x3694, 0x3695, 0x3696, 0x3697, 0x3698, 0x3699, 0x369a, 0x369b, 0x369c,
+ 0x369d, 0x369e, 0x369f, 0x36a0, 0x36a1, 0x36a2, 0x36a3, 0x36a4, 0x36a5,
+ 0x36a6, 0x36a7, 0x36a8, 0x36a9, 0x36aa, 0x36ab, 0x36ac, 0x36ad, 0x36ae,
+ 0x36af, 0x36b0, 0x36b1, 0x36b2, 0x36b3, 0x36b4, 0x36b5, 0x36b6, 0x36b7,
+ 0x36b8, 0x36b9, 0x36ba, 0x36bb, 0x36bc, 0x36bd, 0x36be, 0x36bf, 0x36c0,
+ 0x36c1, 0x36c2, 0x36c3, 0x36c4, 0x36c5, 0x36c6, 0x36c7, 0x36c8, 0x36c9,
+ 0x36ca, 0x36cb, 0x36cc, 0x36cd, 0x36ce, 0x36cf, 0x36d0, 0x36d1, 0x36d2,
+ 0x36d3, 0x36d4, 0x36d5, 0x36d6, 0x36d7, 0x36d8, 0x36d9, 0x36da, 0x36db,
+ 0x36dc, 0x36dd, 0x36de, 0x36df, 0x36e0, 0x36e1, 0x36e2, 0x36e3, 0x36e4,
+ 0x36e5, 0x36e6, 0x36e7, 0x36e8, 0x36e9, 0x36ea, 0x36eb, 0x36ec, 0x36ed,
+ 0x36ee, 0x36ef, 0x36f0, 0x36f1, 0x36f2, 0x36f3, 0x36f4, 0x36f5, 0x36f6,
+ 0x36f7, 0x36f8, 0x36f9, 0x36fa, 0x36fb, 0x36fc, 0x36fd, 0x36fe, 0x36ff,
+ 0x3700, 0x3701, 0x3702, 0x3703, 0x3704, 0x3705, 0x3706, 0x3707, 0x3708,
+ 0x3709, 0x370a, 0x370b, 0x370c, 0x370d, 0x370e, 0x370f, 0x3710, 0x3711,
+ 0x3712, 0x3713, 0x3714, 0x3715, 0x3716, 0x3717, 0x3718, 0x3719, 0x371a,
+ 0x371b, 0x371c, 0x371d, 0x371e, 0x371f, 0x3720, 0x3721, 0x3722, 0x3723,
+ 0x3724, 0x3725, 0x3726, 0x3727, 0x3728, 0x3729, 0x372a, 0x372b, 0x372c,
+ 0x372d, 0x372e, 0x372f, 0x3730, 0x3731, 0x3732, 0x3733, 0x3734, 0x3735,
+ 0x3736, 0x3737, 0x3738, 0x3739, 0x373a, 0x373b, 0x373c, 0x373d, 0x373e,
+ 0x373f, 0x3740, 0x3741, 0x3742, 0x3743, 0x3744, 0x3745, 0x3746, 0x3747,
+ 0x3748, 0x3749, 0x374a, 0x374b, 0x374c, 0x374d, 0x374e, 0x374f, 0x3750,
+ 0x3751, 0x3752, 0x3753, 0x3754, 0x3755, 0x3756, 0x3757, 0x3758, 0x3759,
+ 0x375a, 0x375b, 0x375c, 0x375d, 0x375e, 0x375f, 0x3760, 0x3761, 0x3762,
+ 0x3763, 0x3764, 0x3765, 0x3766, 0x3767, 0x3768, 0x3769, 0x376a, 0x376b,
+ 0x376c, 0x376d, 0x376e, 0x376f, 0x3770, 0x3771, 0x3772, 0x3773, 0x3774,
+ 0x3775, 0x3776, 0x3777, 0x3778, 0x3779, 0x377a, 0x377b, 0x377c, 0x377d,
+ 0x377e, 0x377f, 0x3780, 0x3781, 0x3782, 0x3783, 0x3784, 0x3785, 0x3786,
+ 0x3787, 0x3788, 0x3789, 0x378a, 0x378b, 0x378c, 0x378d, 0x378e, 0x378f,
+ 0x3790, 0x3791, 0x3792, 0x3793, 0x3794, 0x3795, 0x3796, 0x3797, 0x3798,
+ 0x3799, 0x379a, 0x379b, 0x379c, 0x379d, 0x379e, 0x379f, 0x37a0, 0x37a1,
+ 0x37a2, 0x37a3, 0x37a4, 0x37a5, 0x37a6, 0x37a7, 0x37a8, 0x37a9, 0x37aa,
+ 0x37ab, 0x37ac, 0x37ad, 0x37ae, 0x37af, 0x37b0, 0x37b1, 0x37b2, 0x37b3,
+ 0x37b4, 0x37b5, 0x37b6, 0x37b7, 0x37b8, 0x37b9, 0x37ba, 0x37bb, 0x37bc,
+ 0x37bd, 0x37be, 0x37bf, 0x37c0, 0x37c1, 0x37c2, 0x37c3, 0x37c4, 0x37c5,
+ 0x37c6, 0x37c7, 0x37c8, 0x37c9, 0x37ca, 0x37cb, 0x37cc, 0x37cd, 0x37ce,
+ 0x37cf, 0x37d0, 0x37d1, 0x37d2, 0x37d3, 0x37d4, 0x37d5, 0x37d6, 0x37d7,
+ 0x37d8, 0x37d9, 0x37da, 0x37db, 0x37dc, 0x37dd, 0x37de, 0x37df, 0x37e0,
+ 0x37e1, 0x37e2, 0x37e3, 0x37e4, 0x37e5, 0x37e6, 0x37e7, 0x37e8, 0x37e9,
+ 0x37ea, 0x37eb, 0x37ec, 0x37ed, 0x37ee, 0x37ef, 0x37f0, 0x37f1, 0x37f2,
+ 0x37f3, 0x37f4, 0x37f5, 0x37f6, 0x37f7, 0x37f8, 0x37f9, 0x37fa, 0x37fb,
+ 0x37fc, 0x37fd, 0x37fe, 0x37ff, 0x3800, 0x3801, 0x3802, 0x3803, 0x3804,
+ 0x3805, 0x3806, 0x3807, 0x3808, 0x3809, 0x380a, 0x380b, 0x380c, 0x380d,
+ 0x380e, 0x380f, 0x3810, 0x3811, 0x3812, 0x3813, 0x3814, 0x3815, 0x3816,
+ 0x3817, 0x3818, 0x3819, 0x381a, 0x381b, 0x381c, 0x381d, 0x381e, 0x381f,
+ 0x3820, 0x3821, 0x3822, 0x3823, 0x3824, 0x3825, 0x3826, 0x3827, 0x3828,
+ 0x3829, 0x382a, 0x382b, 0x382c, 0x382d, 0x382e, 0x382f, 0x3830, 0x3831,
+ 0x3832, 0x3833, 0x3834, 0x3835, 0x3836, 0x3837, 0x3838, 0x3839, 0x383a,
+ 0x383b, 0x383c, 0x383d, 0x383e, 0x383f, 0x3840, 0x3841, 0x3842, 0x3843,
+ 0x3844, 0x3845, 0x3846, 0x3847, 0x3848, 0x3849, 0x384a, 0x384b, 0x384c,
+ 0x384d, 0x384e, 0x384f, 0x3850, 0x3851, 0x3852, 0x3853, 0x3854, 0x3855,
+ 0x3856, 0x3857, 0x3858, 0x3859, 0x385a, 0x385b, 0x385c, 0x385d, 0x385e,
+ 0x385f, 0x3860, 0x3861, 0x3862, 0x3863, 0x3864, 0x3865, 0x3866, 0x3867,
+ 0x3868, 0x3869, 0x386a, 0x386b, 0x386c, 0x386d, 0x386e, 0x386f, 0x3870,
+ 0x3871, 0x3872, 0x3873, 0x3874, 0x3875, 0x3876, 0x3877, 0x3878, 0x3879,
+ 0x387a, 0x387b, 0x387c, 0x387d, 0x387e, 0x387f, 0x3880, 0x3881, 0x3882,
+ 0x3883, 0x3884, 0x3885, 0x3886, 0x3887, 0x3888, 0x3889, 0x388a, 0x388b,
+ 0x388c, 0x388d, 0x388e, 0x388f, 0x3890, 0x3891, 0x3892, 0x3893, 0x3894,
+ 0x3895, 0x3896, 0x3897, 0x3898, 0x3899, 0x389a, 0x389b, 0x389c, 0x389d,
+ 0x389e, 0x389f, 0x38a0, 0x38a1, 0x38a2, 0x38a3, 0x38a4, 0x38a5, 0x38a6,
+ 0x38a7, 0x38a8, 0x38a9, 0x38aa, 0x38ab, 0x38ac, 0x38ad, 0x38ae, 0x38af,
+ 0x38b0, 0x38b1, 0x38b2, 0x38b3, 0x38b4, 0x38b5, 0x38b6, 0x38b7, 0x38b8,
+ 0x38b9, 0x38ba, 0x38bb, 0x38bc, 0x38bd, 0x38be, 0x38bf, 0x38c0, 0x38c1,
+ 0x38c2, 0x38c3, 0x38c4, 0x38c5, 0x38c6, 0x38c7, 0x38c8, 0x38c9, 0x38ca,
+ 0x38cb, 0x38cc, 0x38cd, 0x38ce, 0x38cf, 0x38d0, 0x38d1, 0x38d2, 0x38d3,
+ 0x38d4, 0x38d5, 0x38d6, 0x38d7, 0x38d8, 0x38d9, 0x38da, 0x38db, 0x38dc,
+ 0x38dd, 0x38de, 0x38df, 0x38e0, 0x38e1, 0x38e2, 0x38e3, 0x38e4, 0x38e5,
+ 0x38e6, 0x38e7, 0x38e8, 0x38e9, 0x38ea, 0x38eb, 0x38ec, 0x38ed, 0x38ee,
+ 0x38ef, 0x38f0, 0x38f1, 0x38f2, 0x38f3, 0x38f4, 0x38f5, 0x38f6, 0x38f7,
+ 0x38f8, 0x38f9, 0x38fa, 0x38fb, 0x38fc, 0x38fd, 0x38fe, 0x38ff, 0x3900,
+ 0x3901, 0x3902, 0x3903, 0x3904, 0x3905, 0x3906, 0x3907, 0x3908, 0x3909,
+ 0x390a, 0x390b, 0x390c, 0x390d, 0x390e, 0x390f, 0x3910, 0x3911, 0x3912,
+ 0x3913, 0x3914, 0x3915, 0x3916, 0x3917, 0x3918, 0x3919, 0x391a, 0x391b,
+ 0x391c, 0x391d, 0x391e, 0x391f, 0x3920, 0x3921, 0x3922, 0x3923, 0x3924,
+ 0x3925, 0x3926, 0x3927, 0x3928, 0x3929, 0x392a, 0x392b, 0x392c, 0x392d,
+ 0x392e, 0x392f, 0x3930, 0x3931, 0x3932, 0x3933, 0x3934, 0x3935, 0x3936,
+ 0x3937, 0x3938, 0x3939, 0x393a, 0x393b, 0x393c, 0x393d, 0x393e, 0x393f,
+ 0x3940, 0x3941, 0x3942, 0x3943, 0x3944, 0x3945, 0x3946, 0x3947, 0x3948,
+ 0x3949, 0x394a, 0x394b, 0x394c, 0x394d, 0x394e, 0x394f, 0x3950, 0x3951,
+ 0x3952, 0x3953, 0x3954, 0x3955, 0x3956, 0x3957, 0x3958, 0x3959, 0x395a,
+ 0x395b, 0x395c, 0x395d, 0x395e, 0x395f, 0x3960, 0x3961, 0x3962, 0x3963,
+ 0x3964, 0x3965, 0x3966, 0x3967, 0x3968, 0x3969, 0x396a, 0x396b, 0x396c,
+ 0x396d, 0x396e, 0x396f, 0x3970, 0x3971, 0x3972, 0x3973, 0x3974, 0x3975,
+ 0x3976, 0x3977, 0x3978, 0x3979, 0x397a, 0x397b, 0x397c, 0x397d, 0x397e,
+ 0x397f, 0x3980, 0x3981, 0x3982, 0x3983, 0x3984, 0x3985, 0x3986, 0x3987,
+ 0x3988, 0x3989, 0x398a, 0x398b, 0x398c, 0x398d, 0x398e, 0x398f, 0x3990,
+ 0x3991, 0x3992, 0x3993, 0x3994, 0x3995, 0x3996, 0x3997, 0x3998, 0x3999,
+ 0x399a, 0x399b, 0x399c, 0x399d, 0x399e, 0x399f, 0x39a0, 0x39a1, 0x39a2,
+ 0x39a3, 0x39a4, 0x39a5, 0x39a6, 0x39a7, 0x39a8, 0x39a9, 0x39aa, 0x39ab,
+ 0x39ac, 0x39ad, 0x39ae, 0x39af, 0x39b0, 0x39b1, 0x39b2, 0x39b3, 0x39b4,
+ 0x39b5, 0x39b6, 0x39b7, 0x39b8, 0x39b9, 0x39ba, 0x39bb, 0x39bc, 0x39bd,
+ 0x39be, 0x39bf, 0x39c0, 0x39c1, 0x39c2, 0x39c3, 0x39c4, 0x39c5, 0x39c6,
+ 0x39c7, 0x39c8, 0x39c9, 0x39ca, 0x39cb, 0x39cc, 0x39cd, 0x39ce, 0x39cf,
+ 0x39d0, 0x39d1, 0x39d2, 0x39d3, 0x39d4, 0x39d5, 0x39d6, 0x39d7, 0x39d8,
+ 0x39d9, 0x39da, 0x39db, 0x39dc, 0x39dd, 0x39de, 0x39df, 0x39e0, 0x39e1,
+ 0x39e2, 0x39e3, 0x39e4, 0x39e5, 0x39e6, 0x39e7, 0x39e8, 0x39e9, 0x39ea,
+ 0x39eb, 0x39ec, 0x39ed, 0x39ee, 0x39ef, 0x39f0, 0x39f1, 0x39f2, 0x39f3,
+ 0x39f4, 0x39f5, 0x39f6, 0x39f7, 0x39f8, 0x39f9, 0x39fa, 0x39fb, 0x39fc,
+ 0x39fd, 0x39fe, 0x39ff, 0x3a00, 0x3a01, 0x3a02, 0x3a03, 0x3a04, 0x3a05,
+ 0x3a06, 0x3a07, 0x3a08, 0x3a09, 0x3a0a, 0x3a0b, 0x3a0c, 0x3a0d, 0x3a0e,
+ 0x3a0f, 0x3a10, 0x3a11, 0x3a12, 0x3a13, 0x3a14, 0x3a15, 0x3a16, 0x3a17,
+ 0x3a18, 0x3a19, 0x3a1a, 0x3a1b, 0x3a1c, 0x3a1d, 0x3a1e, 0x3a1f, 0x3a20,
+ 0x3a21, 0x3a22, 0x3a23, 0x3a24, 0x3a25, 0x3a26, 0x3a27, 0x3a28, 0x3a29,
+ 0x3a2a, 0x3a2b, 0x3a2c, 0x3a2d, 0x3a2e, 0x3a2f, 0x3a30, 0x3a31, 0x3a32,
+ 0x3a33, 0x3a34, 0x3a35, 0x3a36, 0x3a37, 0x3a38, 0x3a39, 0x3a3a, 0x3a3b,
+ 0x3a3c, 0x3a3d, 0x3a3e, 0x3a3f, 0x3a40, 0x3a41, 0x3a42, 0x3a43, 0x3a44,
+ 0x3a45, 0x3a46, 0x3a47, 0x3a48, 0x3a49, 0x3a4a, 0x3a4b, 0x3a4c, 0x3a4d,
+ 0x3a4e, 0x3a4f, 0x3a50, 0x3a51, 0x3a52, 0x3a53, 0x3a54, 0x3a55, 0x3a56,
+ 0x3a57, 0x3a58, 0x3a59, 0x3a5a, 0x3a5b, 0x3a5c, 0x3a5d, 0x3a5e, 0x3a5f,
+ 0x3a60, 0x3a61, 0x3a62, 0x3a63, 0x3a64, 0x3a65, 0x3a66, 0x3a67, 0x3a68,
+ 0x3a69, 0x3a6a, 0x3a6b, 0x3a6c, 0x3a6d, 0x3a6e, 0x3a6f, 0x3a70, 0x3a71,
+ 0x3a72, 0x3a73, 0x3a74, 0x3a75, 0x3a76, 0x3a77, 0x3a78, 0x3a79, 0x3a7a,
+ 0x3a7b, 0x3a7c, 0x3a7d, 0x3a7e, 0x3a7f, 0x3a80, 0x3a81, 0x3a82, 0x3a83,
+ 0x3a84, 0x3a85, 0x3a86, 0x3a87, 0x3a88, 0x3a89, 0x3a8a, 0x3a8b, 0x3a8c,
+ 0x3a8d, 0x3a8e, 0x3a8f, 0x3a90, 0x3a91, 0x3a92, 0x3a93, 0x3a94, 0x3a95,
+ 0x3a96, 0x3a97, 0x3a98, 0x3a99, 0x3a9a, 0x3a9b, 0x3a9c, 0x3a9d, 0x3a9e,
+ 0x3a9f, 0x3aa0, 0x3aa1, 0x3aa2, 0x3aa3, 0x3aa4, 0x3aa5, 0x3aa6, 0x3aa7,
+ 0x3aa8, 0x3aa9, 0x3aaa, 0x3aab, 0x3aac, 0x3aad, 0x3aae, 0x3aaf, 0x3ab0,
+ 0x3ab1, 0x3ab2, 0x3ab3, 0x3ab4, 0x3ab5, 0x3ab6, 0x3ab7, 0x3ab8, 0x3ab9,
+ 0x3aba, 0x3abb, 0x3abc, 0x3abd, 0x3abe, 0x3abf, 0x3ac0, 0x3ac1, 0x3ac2,
+ 0x3ac3, 0x3ac4, 0x3ac5, 0x3ac6, 0x3ac7, 0x3ac8, 0x3ac9, 0x3aca, 0x3acb,
+ 0x3acc, 0x3acd, 0x3ace, 0x3acf, 0x3ad0, 0x3ad1, 0x3ad2, 0x3ad3, 0x3ad4,
+ 0x3ad5, 0x3ad6, 0x3ad7, 0x3ad8, 0x3ad9, 0x3ada, 0x3adb, 0x3adc, 0x3add,
+ 0x3ade, 0x3adf, 0x3ae0, 0x3ae1, 0x3ae2, 0x3ae3, 0x3ae4, 0x3ae5, 0x3ae6,
+ 0x3ae7, 0x3ae8, 0x3ae9, 0x3aea, 0x3aeb, 0x3aec, 0x3aed, 0x3aee, 0x3aef,
+ 0x3af0, 0x3af1, 0x3af2, 0x3af3, 0x3af4, 0x3af5, 0x3af6, 0x3af7, 0x3af8,
+ 0x3af9, 0x3afa, 0x3afb, 0x3afc, 0x3afd, 0x3afe, 0x3aff, 0x3b00, 0x3b01,
+ 0x3b02, 0x3b03, 0x3b04, 0x3b05, 0x3b06, 0x3b07, 0x3b08, 0x3b09, 0x3b0a,
+ 0x3b0b, 0x3b0c, 0x3b0d, 0x3b0e, 0x3b0f, 0x3b10, 0x3b11, 0x3b12, 0x3b13,
+ 0x3b14, 0x3b15, 0x3b16, 0x3b17, 0x3b18, 0x3b19, 0x3b1a, 0x3b1b, 0x3b1c,
+ 0x3b1d, 0x3b1e, 0x3b1f, 0x3b20, 0x3b21, 0x3b22, 0x3b23, 0x3b24, 0x3b25,
+ 0x3b26, 0x3b27, 0x3b28, 0x3b29, 0x3b2a, 0x3b2b, 0x3b2c, 0x3b2d, 0x3b2e,
+ 0x3b2f, 0x3b30, 0x3b31, 0x3b32, 0x3b33, 0x3b34, 0x3b35, 0x3b36, 0x3b37,
+ 0x3b38, 0x3b39, 0x3b3a, 0x3b3b, 0x3b3c, 0x3b3d, 0x3b3e, 0x3b3f, 0x3b40,
+ 0x3b41, 0x3b42, 0x3b43, 0x3b44, 0x3b45, 0x3b46, 0x3b47, 0x3b48, 0x3b49,
+ 0x3b4a, 0x3b4b, 0x3b4c, 0x3b4d, 0x3b4e, 0x3b4f, 0x3b50, 0x3b51, 0x3b52,
+ 0x3b53, 0x3b54, 0x3b55, 0x3b56, 0x3b57, 0x3b58, 0x3b59, 0x3b5a, 0x3b5b,
+ 0x3b5c, 0x3b5d, 0x3b5e, 0x3b5f, 0x3b60, 0x3b61, 0x3b62, 0x3b63, 0x3b64,
+ 0x3b65, 0x3b66, 0x3b67, 0x3b68, 0x3b69, 0x3b6a, 0x3b6b, 0x3b6c, 0x3b6d,
+ 0x3b6e, 0x3b6f, 0x3b70, 0x3b71, 0x3b72, 0x3b73, 0x3b74, 0x3b75, 0x3b76,
+ 0x3b77, 0x3b78, 0x3b79, 0x3b7a, 0x3b7b, 0x3b7c, 0x3b7d, 0x3b7e, 0x3b7f,
+ 0x3b80, 0x3b81, 0x3b82, 0x3b83, 0x3b84, 0x3b85, 0x3b86, 0x3b87, 0x3b88,
+ 0x3b89, 0x3b8a, 0x3b8b, 0x3b8c, 0x3b8d, 0x3b8e, 0x3b8f, 0x3b90, 0x3b91,
+ 0x3b92, 0x3b93, 0x3b94, 0x3b95, 0x3b96, 0x3b97, 0x3b98, 0x3b99, 0x3b9a,
+ 0x3b9b, 0x3b9c, 0x3b9d, 0x3b9e, 0x3b9f, 0x3ba0, 0x3ba1, 0x3ba2, 0x3ba3,
+ 0x3ba4, 0x3ba5, 0x3ba6, 0x3ba7, 0x3ba8, 0x3ba9, 0x3baa, 0x3bab, 0x3bac,
+ 0x3bad, 0x3bae, 0x3baf, 0x3bb0, 0x3bb1, 0x3bb2, 0x3bb3, 0x3bb4, 0x3bb5,
+ 0x3bb6, 0x3bb7, 0x3bb8, 0x3bb9, 0x3bba, 0x3bbb, 0x3bbc, 0x3bbd, 0x3bbe,
+ 0x3bbf, 0x3bc0, 0x3bc1, 0x3bc2, 0x3bc3, 0x3bc4, 0x3bc5, 0x3bc6, 0x3bc7,
+ 0x3bc8, 0x3bc9, 0x3bca, 0x3bcb, 0x3bcc, 0x3bcd, 0x3bce, 0x3bcf, 0x3bd0,
+ 0x3bd1, 0x3bd2, 0x3bd3, 0x3bd4, 0x3bd5, 0x3bd6, 0x3bd7, 0x3bd8, 0x3bd9,
+ 0x3bda, 0x3bdb, 0x3bdc, 0x3bdd, 0x3bde, 0x3bdf, 0x3be0, 0x3be1, 0x3be2,
+ 0x3be3, 0x3be4, 0x3be5, 0x3be6, 0x3be7, 0x3be8, 0x3be9, 0x3bea, 0x3beb,
+ 0x3bec, 0x3bed, 0x3bee, 0x3bef, 0x3bf0, 0x3bf1, 0x3bf2, 0x3bf3, 0x3bf4,
+ 0x3bf5, 0x3bf6, 0x3bf7, 0x3bf8, 0x3bf9, 0x3bfa, 0x3bfb, 0x3bfc, 0x3bfd,
+ 0x3bfe, 0x3bff, 0x3c00, 0x3c01, 0x3c02, 0x3c03, 0x3c04, 0x3c05, 0x3c06,
+ 0x3c07, 0x3c08, 0x3c09, 0x3c0a, 0x3c0b, 0x3c0c, 0x3c0d, 0x3c0e, 0x3c0f,
+ 0x3c10, 0x3c11, 0x3c12, 0x3c13, 0x3c14, 0x3c15, 0x3c16, 0x3c17, 0x3c18,
+ 0x3c19, 0x3c1a, 0x3c1b, 0x3c1c, 0x3c1d, 0x3c1e, 0x3c1f, 0x3c20, 0x3c21,
+ 0x3c22, 0x3c23, 0x3c24, 0x3c25, 0x3c26, 0x3c27, 0x3c28, 0x3c29, 0x3c2a,
+ 0x3c2b, 0x3c2c, 0x3c2d, 0x3c2e, 0x3c2f, 0x3c30, 0x3c31, 0x3c32, 0x3c33,
+ 0x3c34, 0x3c35, 0x3c36, 0x3c37, 0x3c38, 0x3c39, 0x3c3a, 0x3c3b, 0x3c3c,
+ 0x3c3d, 0x3c3e, 0x3c3f, 0x3c40, 0x3c41, 0x3c42, 0x3c43, 0x3c44, 0x3c45,
+ 0x3c46, 0x3c47, 0x3c48, 0x3c49, 0x3c4a, 0x3c4b, 0x3c4c, 0x3c4d, 0x3c4e,
+ 0x3c4f, 0x3c50, 0x3c51, 0x3c52, 0x3c53, 0x3c54, 0x3c55, 0x3c56, 0x3c57,
+ 0x3c58, 0x3c59, 0x3c5a, 0x3c5b, 0x3c5c, 0x3c5d, 0x3c5e, 0x3c5f, 0x3c60,
+ 0x3c61, 0x3c62, 0x3c63, 0x3c64, 0x3c65, 0x3c66, 0x3c67, 0x3c68, 0x3c69,
+ 0x3c6a, 0x3c6b, 0x3c6c, 0x3c6d, 0x3c6e, 0x3c6f, 0x3c70, 0x3c71, 0x3c72,
+ 0x3c73, 0x3c74, 0x3c75, 0x3c76, 0x3c77, 0x3c78, 0x3c79, 0x3c7a, 0x3c7b,
+ 0x3c7c, 0x3c7d, 0x3c7e, 0x3c7f, 0x3c80, 0x3c81, 0x3c82, 0x3c83, 0x3c84,
+ 0x3c85, 0x3c86, 0x3c87, 0x3c88, 0x3c89, 0x3c8a, 0x3c8b, 0x3c8c, 0x3c8d,
+ 0x3c8e, 0x3c8f, 0x3c90, 0x3c91, 0x3c92, 0x3c93, 0x3c94, 0x3c95, 0x3c96,
+ 0x3c97, 0x3c98, 0x3c99, 0x3c9a, 0x3c9b, 0x3c9c, 0x3c9d, 0x3c9e, 0x3c9f,
+ 0x3ca0, 0x3ca1, 0x3ca2, 0x3ca3, 0x3ca4, 0x3ca5, 0x3ca6, 0x3ca7, 0x3ca8,
+ 0x3ca9, 0x3caa, 0x3cab, 0x3cac, 0x3cad, 0x3cae, 0x3caf, 0x3cb0, 0x3cb1,
+ 0x3cb2, 0x3cb3, 0x3cb4, 0x3cb5, 0x3cb6, 0x3cb7, 0x3cb8, 0x3cb9, 0x3cba,
+ 0x3cbb, 0x3cbc, 0x3cbd, 0x3cbe, 0x3cbf, 0x3cc0, 0x3cc1, 0x3cc2, 0x3cc3,
+ 0x3cc4, 0x3cc5, 0x3cc6, 0x3cc7, 0x3cc8, 0x3cc9, 0x3cca, 0x3ccb, 0x3ccc,
+ 0x3ccd, 0x3cce, 0x3ccf, 0x3cd0, 0x3cd1, 0x3cd2, 0x3cd3, 0x3cd4, 0x3cd5,
+ 0x3cd6, 0x3cd7, 0x3cd8, 0x3cd9, 0x3cda, 0x3cdb, 0x3cdc, 0x3cdd, 0x3cde,
+ 0x3cdf, 0x3ce0, 0x3ce1, 0x3ce2, 0x3ce3, 0x3ce4, 0x3ce5, 0x3ce6, 0x3ce7,
+ 0x3ce8, 0x3ce9, 0x3cea, 0x3ceb, 0x3cec, 0x3ced, 0x3cee, 0x3cef, 0x3cf0,
+ 0x3cf1, 0x3cf2, 0x3cf3, 0x3cf4, 0x3cf5, 0x3cf6, 0x3cf7, 0x3cf8, 0x3cf9,
+ 0x3cfa, 0x3cfb, 0x3cfc, 0x3cfd, 0x3cfe, 0x3cff, 0x3d00, 0x3d01, 0x3d02,
+ 0x3d03, 0x3d04, 0x3d05, 0x3d06, 0x3d07, 0x3d08, 0x3d09, 0x3d0a, 0x3d0b,
+ 0x3d0c, 0x3d0d, 0x3d0e, 0x3d0f, 0x3d10, 0x3d11, 0x3d12, 0x3d13, 0x3d14,
+ 0x3d15, 0x3d16, 0x3d17, 0x3d18, 0x3d19, 0x3d1a, 0x3d1b, 0x3d1c, 0x3d1d,
+ 0x3d1e, 0x3d1f, 0x3d20, 0x3d21, 0x3d22, 0x3d23, 0x3d24, 0x3d25, 0x3d26,
+ 0x3d27, 0x3d28, 0x3d29, 0x3d2a, 0x3d2b, 0x3d2c, 0x3d2d, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, -1, -1, -1, -1, -1, -1, -1,
+ -1, -1, 0x4f3d, 0x4f73, 0x5047, 0x50f9, 0x52a0, 0x53ef, 0x5475,
+ 0x54e5, 0x5609, 0x5ac1, 0x5bb6, 0x6687, 0x67b6, 0x67b7, 0x67ef, 0x6b4c,
+ 0x73c2, 0x75c2, 0x7a3c, 0x82db, 0x8304, 0x8857, 0x8888, 0x8a36, 0x8cc8,
+ 0x8dcf, 0x8efb, 0x8fe6, 0x99d5, 0x523b, 0x5374, 0x5404, 0x606a, 0x6164,
+ 0x6bbc, 0x73cf, 0x811a, 0x89ba, 0x89d2, 0x95a3, 0x4f83, 0x520a, 0x58be,
+ 0x5978, 0x59e6, 0x5e72, 0x5e79, 0x61c7, 0x63c0, 0x6746, 0x67ec, 0x687f,
+ 0x6f97, 0x764e, 0x770b, 0x78f5, 0x7a08, 0x7aff, 0x7c21, 0x809d, 0x826e,
+ 0x8271, 0x8aeb, 0x9593, 0x4e6b, 0x559d, 0x66f7, 0x6e34, 0x78a3, 0x7aed,
+ 0x845b, 0x8910, 0x874e, 0x97a8, 0x52d8, 0x574e, 0x582a, 0x5d4c, 0x611f,
+ 0x61be, 0x6221, 0x6562, 0x67d1, 0x6a44, 0x6e1b, 0x7518, 0x75b3, 0x76e3,
+ 0x77b0, 0x7d3a, 0x90af, 0x9451, 0x9452, 0x9f95, 0x5323, 0x5cac, 0x7532,
+ 0x80db, 0x9240, 0x9598, 0x525b, 0x5808, 0x59dc, 0x5ca1, 0x5d17, 0x5eb7,
+ 0x5f3a, 0x5f4a, 0x6177, 0x6c5f, 0x757a, 0x7586, 0x7ce0, 0x7d73, 0x7db1,
+ 0x7f8c, 0x8154, 0x8221, 0x8591, 0x8941, 0x8b1b, 0x92fc, 0x964d, 0x9c47,
+ 0x4ecb, 0x4ef7, 0x500b, 0x51f1, 0x584f, 0x6137, 0x613e, 0x6168, 0x6539,
+ 0x69ea, 0x6f11, 0x75a5, 0x7686, 0x76d6, 0x7b87, 0x82a5, 0x84cb, 0xf900,
+ 0x93a7, 0x958b, 0x5580, 0x5ba2, 0x5751, 0xf901, 0x7cb3, 0x7fb9, 0x91b5,
+ 0x5028, 0x53bb, 0x5c45, 0x5de8, 0x62d2, 0x636e, 0x64da, 0x64e7, 0x6e20,
+ 0x70ac, 0x795b, 0x8ddd, 0x8e1e, 0xf902, 0x907d, 0x9245, 0x92f8, 0x4e7e,
+ 0x4ef6, 0x5065, 0x5dfe, 0x5efa, 0x6106, 0x6957, 0x8171, 0x8654, 0x8e47,
+ 0x9375, 0x9a2b, 0x4e5e, 0x5091, 0x6770, 0x6840, 0x5109, 0x528d, 0x5292,
+ 0x6aa2, 0x77bc, 0x9210, 0x9ed4, 0x52ab, 0x602f, 0x8ff2, 0x5048, 0x61a9,
+ 0x63ed, 0x64ca, 0x683c, 0x6a84, 0x6fc0, 0x8188, 0x89a1, 0x9694, 0x5805,
+ 0x727d, 0x72ac, 0x7504, 0x7d79, 0x7e6d, 0x80a9, 0x898b, 0x8b74, 0x9063,
+ 0x9d51, 0x6289, 0x6c7a, 0x6f54, 0x7d50, 0x7f3a, 0x8a23, 0x517c, 0x614a,
+ 0x7b9d, 0x8b19, 0x9257, 0x938c, 0x4eac, 0x4fd3, 0x501e, 0x50be, 0x5106,
+ 0x52c1, 0x52cd, 0x537f, 0x5770, 0x5883, 0x5e9a, 0x5f91, 0x6176, 0x61ac,
+ 0x64ce, 0x656c, 0x666f, 0x66bb, 0x66f4, 0x6897, 0x6d87, 0x7085, 0x70f1,
+ 0x749f, 0x74a5, 0x74ca, 0x75d9, 0x786c, 0x78ec, 0x7adf, 0x7af6, 0x7d45,
+ 0x7d93, 0x8015, 0x803f, 0x811b, 0x8396, 0x8b66, 0x8f15, 0x9015, 0x93e1,
+ 0x9803, 0x9838, 0x9a5a, 0x9be8, 0x4fc2, 0x5553, 0x583a, 0x5951, 0x5b63,
+ 0x5c46, 0x60b8, 0x6212, 0x6842, 0x68b0, 0x68e8, 0x6eaa, 0x754c, 0x7678,
+ 0x78ce, 0x7a3d, 0x7cfb, 0x7e6b, 0x7e7c, 0x8a08, 0x8aa1, 0x8c3f, 0x968e,
+ 0x9dc4, 0x53e4, 0x53e9, 0x544a, 0x5471, 0x56fa, 0x59d1, 0x5b64, 0x5c3b,
+ 0x5eab, 0x62f7, 0x6537, 0x6545, 0x6572, 0x66a0, 0x67af, 0x69c1, 0x6cbd,
+ 0x75fc, 0x7690, 0x777e, 0x7a3f, 0x7f94, 0x8003, 0x80a1, 0x818f, 0x82e6,
+ 0x82fd, 0x83f0, 0x85c1, 0x8831, 0x88b4, 0x8aa5, 0xf903, 0x8f9c, 0x932e,
+ 0x96c7, 0x9867, 0x9ad8, 0x9f13, 0x54ed, 0x659b, 0x66f2, 0x688f, 0x7a40,
+ 0x8c37, 0x9d60, 0x56f0, 0x5764, 0x5d11, 0x6606, 0x68b1, 0x68cd, 0x6efe,
+ 0x7428, 0x889e, 0x9be4, 0x6c68, 0xf904, 0x9aa8, 0x4f9b, 0x516c, 0x5171,
+ 0x529f, 0x5b54, 0x5de5, 0x6050, 0x606d, 0x62f1, 0x63a7, 0x653b, 0x73d9,
+ 0x7a7a, 0x86a3, 0x8ca2, 0x978f, 0x4e32, 0x5be1, 0x6208, 0x679c, 0x74dc,
+ 0x79d1, 0x83d3, 0x8a87, 0x8ab2, 0x8de8, 0x904e, 0x934b, 0x9846, 0x5ed3,
+ 0x69e8, 0x85ff, 0x90ed, 0xf905, 0x51a0, 0x5b98, 0x5bec, 0x6163, 0x68fa,
+ 0x6b3e, 0x704c, 0x742f, 0x74d8, 0x7ba1, 0x7f50, 0x83c5, 0x89c0, 0x8cab,
+ 0x95dc, 0x9928, 0x522e, 0x605d, 0x62ec, 0x9002, 0x4f8a, 0x5149, 0x5321,
+ 0x58d9, 0x5ee3, 0x66e0, 0x6d38, 0x709a, 0x72c2, 0x73d6, 0x7b50, 0x80f1,
+ 0x945b, 0x5366, 0x639b, 0x7f6b, 0x4e56, 0x5080, 0x584a, 0x58de, 0x602a,
+ 0x6127, 0x62d0, 0x69d0, 0x9b41, 0x5b8f, 0x7d18, 0x80b1, 0x8f5f, 0x4ea4,
+ 0x50d1, 0x54ac, 0x55ac, 0x5b0c, 0x5da0, 0x5de7, 0x652a, 0x654e, 0x6821,
+ 0x6a4b, 0x72e1, 0x768e, 0x77ef, 0x7d5e, 0x7ff9, 0x81a0, 0x854e, 0x86df,
+ 0x8f03, 0x8f4e, 0x90ca, 0x9903, 0x9a55, 0x9bab, 0x4e18, 0x4e45, 0x4e5d,
+ 0x4ec7, 0x4ff1, 0x5177, 0x52fe, 0x5340, 0x53e3, 0x53e5, 0x548e, 0x5614,
+ 0x5775, 0x57a2, 0x5bc7, 0x5d87, 0x5ed0, 0x61fc, 0x62d8, 0x6551, 0x67b8,
+ 0x67e9, 0x69cb, 0x6b50, 0x6bc6, 0x6bec, 0x6c42, 0x6e9d, 0x7078, 0x72d7,
+ 0x7396, 0x7403, 0x77bf, 0x77e9, 0x7a76, 0x7d7f, 0x8009, 0x81fc, 0x8205,
+ 0x820a, 0x82df, 0x8862, 0x8b33, 0x8cfc, 0x8ec0, 0x9011, 0x90b1, 0x9264,
+ 0x92b6, 0x99d2, 0x9a45, 0x9ce9, 0x9dd7, 0x9f9c, 0x570b, 0x5c40, 0x83ca,
+ 0x97a0, 0x97ab, 0x9eb4, 0x541b, 0x7a98, 0x7fa4, 0x88d9, 0x8ecd, 0x90e1,
+ 0x5800, 0x5c48, 0x6398, 0x7a9f, 0x5bae, 0x5f13, 0x7a79, 0x7aae, 0x828e,
+ 0x8eac, 0x5026, 0x5238, 0x52f8, 0x5377, 0x5708, 0x62f3, 0x6372, 0x6b0a,
+ 0x6dc3, 0x7737, 0x53a5, 0x7357, 0x8568, 0x8e76, 0x95d5, 0x673a, 0x6ac3,
+ 0x6f70, 0x8a6d, 0x8ecc, 0x994b, 0xf906, 0x6677, 0x6b78, 0x8cb4, 0x9b3c,
+ 0xf907, 0x53eb, 0x572d, 0x594e, 0x63c6, 0x69fb, 0x73ea, 0x7845, 0x7aba,
+ 0x7ac5, 0x7cfe, 0x8475, 0x898f, 0x8d73, 0x9035, 0x95a8, 0x52fb, 0x5747,
+ 0x7547, 0x7b60, 0x83cc, 0x921e, 0xf908, 0x6a58, 0x514b, 0x524b, 0x5287,
+ 0x621f, 0x68d8, 0x6975, 0x9699, 0x50c5, 0x52a4, 0x52e4, 0x61c3, 0x65a4,
+ 0x6839, 0x69ff, 0x747e, 0x7b4b, 0x82b9, 0x83eb, 0x89b2, 0x8b39, 0x8fd1,
+ 0x9949, 0xf909, 0x4eca, 0x5997, 0x64d2, 0x6611, 0x6a8e, 0x7434, 0x7981,
+ 0x79bd, 0x82a9, 0x887e, 0x887f, 0x895f, 0xf90a, 0x9326, 0x4f0b, 0x53ca,
+ 0x6025, 0x6271, 0x6c72, 0x7d1a, 0x7d66, 0x4e98, 0x5162, 0x77dc, 0x80af,
+ 0x4f01, 0x4f0e, 0x5176, 0x5180, 0x55dc, 0x5668, 0x573b, 0x57fa, 0x57fc,
+ 0x5914, 0x5947, 0x5993, 0x5bc4, 0x5c90, 0x5d0e, 0x5df1, 0x5e7e, 0x5fcc,
+ 0x6280, 0x65d7, 0x65e3, 0x671e, 0x671f, 0x675e, 0x68cb, 0x68c4, 0x6a5f,
+ 0x6b3a, 0x6c23, 0x6c7d, 0x6c82, 0x6dc7, 0x7398, 0x7426, 0x742a, 0x7482,
+ 0x74a3, 0x7578, 0x757f, 0x7881, 0x78ef, 0x7941, 0x7947, 0x7948, 0x797a,
+ 0x7b95, 0x7d00, 0x7dba, 0x7f88, 0x8006, 0x802d, 0x808c, 0x8a18, 0x8b4f,
+ 0x8c48, 0x8d77, 0x9321, 0x9324, 0x98e2, 0x9951, 0x9a0e, 0x9a0f, 0x9a65,
+ 0x9e92, 0x7dca, 0x4f76, 0x5409, 0x62ee, 0x6854, 0x91d1, 0x55ab, 0x513a,
+ 0xf90b, 0xf90c, 0x5a1c, 0x61e6, 0xf90d, 0x62cf, 0x62ff, 0xf90e, 0xf90f,
+ 0xf910, 0xf911, 0xf912, 0xf913, 0x90a3, 0xf914, 0xf915, 0xf916, 0xf917,
+ 0xf918, 0x8afe, 0xf919, 0xf91a, 0xf91b, 0xf91c, 0x6696, 0xf91d, 0x7156,
+ 0xf91e, 0xf91f, 0x96e3, 0xf920, 0x634f, 0x637a, 0x5357, 0xf921, 0x678f,
+ 0x6960, 0x6e73, 0xf922, 0x7537, 0xf923, 0xf924, 0xf925, 0x7d0d, 0xf926,
+ 0xf927, 0x8872, 0x56ca, 0x5a18, 0xf928, 0xf929, 0xf92a, 0xf92b, 0xf92c,
+ 0x4e43, 0xf92d, 0x5167, 0x5948, 0x67f0, 0x8010, 0xf92e, 0x5973, 0x5e74,
+ 0x649a, 0x79ca, 0x5ff5, 0x606c, 0x62c8, 0x637b, 0x5be7, 0x5bd7, 0x52aa,
+ 0xf92f, 0x5974, 0x5f29, 0x6012, 0xf930, 0xf931, 0xf932, 0x7459, 0xf933,
+ 0xf934, 0xf935, 0xf936, 0xf937, 0xf938, 0x99d1, 0xf939, 0xf93a, 0xf93b,
+ 0xf93c, 0xf93d, 0xf93e, 0xf93f, 0xf940, 0xf941, 0xf942, 0xf943, 0x6fc3,
+ 0xf944, 0xf945, 0x81bf, 0x8fb2, 0x60f1, 0xf946, 0xf947, 0x8166, 0xf948,
+ 0xf949, 0x5c3f, 0xf94a, 0xf94b, 0xf94c, 0xf94d, 0xf94e, 0xf94f, 0xf950,
+ 0xf951, 0x5ae9, 0x8a25, 0x677b, 0x7d10, 0xf952, 0xf953, 0xf954, 0xf955,
+ 0xf956, 0xf957, 0x80fd, 0xf958, 0xf959, 0x5c3c, 0x6ce5, 0x533f, 0x6eba,
+ 0x591a, 0x8336, 0x4e39, 0x4eb6, 0x4f46, 0x55ae, 0x5718, 0x58c7, 0x5f56,
+ 0x65b7, 0x65e6, 0x6a80, 0x6bb5, 0x6e4d, 0x77ed, 0x7aef, 0x7c1e, 0x7dde,
+ 0x86cb, 0x8892, 0x9132, 0x935b, 0x64bb, 0x6fbe, 0x737a, 0x75b8, 0x9054,
+ 0x5556, 0x574d, 0x61ba, 0x64d4, 0x66c7, 0x6de1, 0x6e5b, 0x6f6d, 0x6fb9,
+ 0x75f0, 0x8043, 0x81bd, 0x8541, 0x8983, 0x8ac7, 0x8b5a, 0x931f, 0x6c93,
+ 0x7553, 0x7b54, 0x8e0f, 0x905d, 0x5510, 0x5802, 0x5858, 0x5e62, 0x6207,
+ 0x649e, 0x68e0, 0x7576, 0x7cd6, 0x87b3, 0x9ee8, 0x4ee3, 0x5788, 0x576e,
+ 0x5927, 0x5c0d, 0x5cb1, 0x5e36, 0x5f85, 0x6234, 0x64e1, 0x73b3, 0x81fa,
+ 0x888b, 0x8cb8, 0x968a, 0x9edb, 0x5b85, 0x5fb7, 0x60b3, 0x5012, 0x5200,
+ 0x5230, 0x5716, 0x5835, 0x5857, 0x5c0e, 0x5c60, 0x5cf6, 0x5d8b, 0x5ea6,
+ 0x5f92, 0x60bc, 0x6311, 0x6389, 0x6417, 0x6843, 0x68f9, 0x6ac2, 0x6dd8,
+ 0x6e21, 0x6ed4, 0x6fe4, 0x71fe, 0x76dc, 0x7779, 0x79b1, 0x7a3b, 0x8404,
+ 0x89a9, 0x8ced, 0x8df3, 0x8e48, 0x9003, 0x9014, 0x9053, 0x90fd, 0x934d,
+ 0x9676, 0x97dc, 0x6bd2, 0x7006, 0x7258, 0x72a2, 0x7368, 0x7763, 0x79bf,
+ 0x7be4, 0x7e9b, 0x8b80, 0x58a9, 0x60c7, 0x6566, 0x65fd, 0x66be, 0x6c8c,
+ 0x711e, 0x71c9, 0x8c5a, 0x9813, 0x4e6d, 0x7a81, 0x4edd, 0x51ac, 0x51cd,
+ 0x52d5, 0x540c, 0x61a7, 0x6771, 0x6850, 0x68df, 0x6d1e, 0x6f7c, 0x75bc,
+ 0x77b3, 0x7ae5, 0x80f4, 0x8463, 0x9285, 0x515c, 0x6597, 0x675c, 0x6793,
+ 0x75d8, 0x7ac7, 0x8373, 0xf95a, 0x8c46, 0x9017, 0x982d, 0x5c6f, 0x81c0,
+ 0x829a, 0x9041, 0x906f, 0x920d, 0x5f97, 0x5d9d, 0x6a59, 0x71c8, 0x767b,
+ 0x7b49, 0x85e4, 0x8b04, 0x9127, 0x9a30, 0x5587, 0x61f6, 0xf95b, 0x7669,
+ 0x7f85, 0x863f, 0x87ba, 0x88f8, 0x908f, 0xf95c, 0x6d1b, 0x70d9, 0x73de,
+ 0x7d61, 0x843d, 0xf95d, 0x916a, 0x99f1, 0xf95e, 0x4e82, 0x5375, 0x6b04,
+ 0x6b12, 0x703e, 0x721b, 0x862d, 0x9e1e, 0x524c, 0x8fa3, 0x5d50, 0x64e5,
+ 0x652c, 0x6b16, 0x6feb, 0x7c43, 0x7e9c, 0x85cd, 0x8964, 0x89bd, 0x62c9,
+ 0x81d8, 0x881f, 0x5eca, 0x6717, 0x6d6a, 0x72fc, 0x7405, 0x746f, 0x8782,
+ 0x90de, 0x4f86, 0x5d0d, 0x5fa0, 0x840a, 0x51b7, 0x63a0, 0x7565, 0x4eae,
+ 0x5006, 0x5169, 0x51c9, 0x6881, 0x6a11, 0x7cae, 0x7cb1, 0x7ce7, 0x826f,
+ 0x8ad2, 0x8f1b, 0x91cf, 0x4fb6, 0x5137, 0x52f5, 0x5442, 0x5eec, 0x616e,
+ 0x623e, 0x65c5, 0x6ada, 0x6ffe, 0x792a, 0x85dc, 0x8823, 0x95ad, 0x9a62,
+ 0x9a6a, 0x9e97, 0x9ece, 0x529b, 0x66c6, 0x6b77, 0x701d, 0x792b, 0x8f62,
+ 0x9742, 0x6190, 0x6200, 0x6523, 0x6f23, 0x7149, 0x7489, 0x7df4, 0x806f,
+ 0x84ee, 0x8f26, 0x9023, 0x934a, 0x51bd, 0x5217, 0x52a3, 0x6d0c, 0x70c8,
+ 0x88c2, 0x5ec9, 0x6582, 0x6bae, 0x6fc2, 0x7c3e, 0x7375, 0x4ee4, 0x4f36,
+ 0x56f9, 0xf95f, 0x5cba, 0x5dba, 0x601c, 0x73b2, 0x7b2d, 0x7f9a, 0x7fce,
+ 0x8046, 0x901e, 0x9234, 0x96f6, 0x9748, 0x9818, 0x9f61, 0x4f8b, 0x6fa7,
+ 0x79ae, 0x91b4, 0x96b7, 0x52de, 0xf960, 0x6488, 0x64c4, 0x6ad3, 0x6f5e,
+ 0x7018, 0x7210, 0x76e7, 0x8001, 0x8606, 0x865c, 0x8def, 0x8f05, 0x9732,
+ 0x9b6f, 0x9dfa, 0x9e75, 0x788c, 0x797f, 0x7da0, 0x83c9, 0x9304, 0x9e7f,
+ 0x9e93, 0x8ad6, 0x58df, 0x5f04, 0x6727, 0x7027, 0x74cf, 0x7c60, 0x807e,
+ 0x5121, 0x7028, 0x7262, 0x78ca, 0x8cc2, 0x8cda, 0x8cf4, 0x96f7, 0x4e86,
+ 0x50da, 0x5bee, 0x5ed6, 0x6599, 0x71ce, 0x7642, 0x77ad, 0x804a, 0x84fc,
+ 0x907c, 0x9b27, 0x9f8d, 0x58d8, 0x5a41, 0x5c62, 0x6a13, 0x6dda, 0x6f0f,
+ 0x763b, 0x7d2f, 0x7e37, 0x851e, 0x8938, 0x93e4, 0x964b, 0x5289, 0x65d2,
+ 0x67f3, 0x69b4, 0x6d41, 0x6e9c, 0x700f, 0x7409, 0x7460, 0x7559, 0x7624,
+ 0x786b, 0x8b2c, 0x985e, 0x516d, 0x622e, 0x9678, 0x4f96, 0x502b, 0x5d19,
+ 0x6dea, 0x7db8, 0x8f2a, 0x5f8b, 0x6144, 0x6817, 0xf961, 0x9686, 0x52d2,
+ 0x808b, 0x51dc, 0x51cc, 0x695e, 0x7a1c, 0x7dbe, 0x83f1, 0x9675, 0x4fda,
+ 0x5229, 0x5398, 0x540f, 0x550e, 0x5c65, 0x60a7, 0x674e, 0x68a8, 0x6d6c,
+ 0x7281, 0x72f8, 0x7406, 0x7483, 0xf962, 0x75e2, 0x7c6c, 0x7f79, 0x7fb8,
+ 0x8389, 0x88cf, 0x88e1, 0x91cc, 0x91d0, 0x96e2, 0x9bc9, 0x541d, 0x6f7e,
+ 0x71d0, 0x7498, 0x85fa, 0x8eaa, 0x96a3, 0x9c57, 0x9e9f, 0x6797, 0x6dcb,
+ 0x7433, 0x81e8, 0x9716, 0x782c, 0x7acb, 0x7b20, 0x7c92, 0x6469, 0x746a,
+ 0x75f2, 0x78bc, 0x78e8, 0x99ac, 0x9b54, 0x9ebb, 0x5bde, 0x5e55, 0x6f20,
+ 0x819c, 0x83ab, 0x9088, 0x4e07, 0x534d, 0x5a29, 0x5dd2, 0x5f4e, 0x6162,
+ 0x633d, 0x6669, 0x66fc, 0x6eff, 0x6f2b, 0x7063, 0x779e, 0x842c, 0x8513,
+ 0x883b, 0x8f13, 0x9945, 0x9c3b, 0x551c, 0x62b9, 0x672b, 0x6cab, 0x8309,
+ 0x896a, 0x977a, 0x4ea1, 0x5984, 0x5fd8, 0x5fd9, 0x671b, 0x7db2, 0x7f54,
+ 0x8292, 0x832b, 0x83bd, 0x8f1e, 0x9099, 0x57cb, 0x59b9, 0x5a92, 0x5bd0,
+ 0x6627, 0x679a, 0x6885, 0x6bcf, 0x7164, 0x7f75, 0x8cb7, 0x8ce3, 0x9081,
+ 0x9b45, 0x8108, 0x8c8a, 0x964c, 0x9a40, 0x9ea5, 0x5b5f, 0x6c13, 0x731b,
+ 0x76f2, 0x76df, 0x840c, 0x51aa, 0x8993, 0x514d, 0x5195, 0x52c9, 0x68c9,
+ 0x6c94, 0x7704, 0x7720, 0x7dbf, 0x7dec, 0x9762, 0x9eb5, 0x6ec5, 0x8511,
+ 0x51a5, 0x540d, 0x547d, 0x660e, 0x669d, 0x6927, 0x6e9f, 0x76bf, 0x7791,
+ 0x8317, 0x84c2, 0x879f, 0x9169, 0x9298, 0x9cf4, 0x8882, 0x4fae, 0x5192,
+ 0x52df, 0x59c6, 0x5e3d, 0x6155, 0x6478, 0x6479, 0x66ae, 0x67d0, 0x6a21,
+ 0x6bcd, 0x6bdb, 0x725f, 0x7261, 0x7441, 0x7738, 0x77db, 0x8017, 0x82bc,
+ 0x8305, 0x8b00, 0x8b28, 0x8c8c, 0x6728, 0x6c90, 0x7267, 0x76ee, 0x7766,
+ 0x7a46, 0x9da9, 0x6b7f, 0x6c92, 0x5922, 0x6726, 0x8499, 0x536f, 0x5893,
+ 0x5999, 0x5edf, 0x63cf, 0x6634, 0x6773, 0x6e3a, 0x732b, 0x7ad7, 0x82d7,
+ 0x9328, 0x52d9, 0x5deb, 0x61ae, 0x61cb, 0x620a, 0x62c7, 0x64ab, 0x65e0,
+ 0x6959, 0x6b66, 0x6bcb, 0x7121, 0x73f7, 0x755d, 0x7e46, 0x821e, 0x8302,
+ 0x856a, 0x8aa3, 0x8cbf, 0x9727, 0x9d61, 0x58a8, 0x9ed8, 0x5011, 0x520e,
+ 0x543b, 0x554f, 0x6587, 0x6c76, 0x7d0a, 0x7d0b, 0x805e, 0x868a, 0x9580,
+ 0x96ef, 0x52ff, 0x6c95, 0x7269, 0x5473, 0x5a9a, 0x5c3e, 0x5d4b, 0x5f4c,
+ 0x5fae, 0x672a, 0x68b6, 0x6963, 0x6e3c, 0x6e44, 0x7709, 0x7c73, 0x7f8e,
+ 0x8587, 0x8b0e, 0x8ff7, 0x9761, 0x9ef4, 0x5cb7, 0x60b6, 0x610d, 0x61ab,
+ 0x654f, 0x65fb, 0x65fc, 0x6c11, 0x6cef, 0x739f, 0x73c9, 0x7de1, 0x9594,
+ 0x5bc6, 0x871c, 0x8b10, 0x525d, 0x535a, 0x62cd, 0x640f, 0x64b2, 0x6734,
+ 0x6a38, 0x6cca, 0x73c0, 0x749e, 0x7b94, 0x7c95, 0x7e1b, 0x818a, 0x8236,
+ 0x8584, 0x8feb, 0x96f9, 0x99c1, 0x4f34, 0x534a, 0x53cd, 0x53db, 0x62cc,
+ 0x642c, 0x6500, 0x6591, 0x69c3, 0x6cee, 0x6f58, 0x73ed, 0x7554, 0x7622,
+ 0x76e4, 0x76fc, 0x78d0, 0x78fb, 0x792c, 0x7d46, 0x822c, 0x87e0, 0x8fd4,
+ 0x9812, 0x98ef, 0x52c3, 0x62d4, 0x64a5, 0x6e24, 0x6f51, 0x767c, 0x8dcb,
+ 0x91b1, 0x9262, 0x9aee, 0x9b43, 0x5023, 0x508d, 0x574a, 0x59a8, 0x5c28,
+ 0x5e47, 0x5f77, 0x623f, 0x653e, 0x65b9, 0x65c1, 0x6609, 0x678b, 0x699c,
+ 0x6ec2, 0x78c5, 0x7d21, 0x80aa, 0x8180, 0x822b, 0x82b3, 0x84a1, 0x868c,
+ 0x8a2a, 0x8b17, 0x90a6, 0x9632, 0x9f90, 0x500d, 0x4ff3, 0xf963, 0x57f9,
+ 0x5f98, 0x62dc, 0x6392, 0x676f, 0x6e43, 0x7119, 0x76c3, 0x80cc, 0x80da,
+ 0x88f4, 0x88f5, 0x8919, 0x8ce0, 0x8f29, 0x914d, 0x966a, 0x4f2f, 0x4f70,
+ 0x5e1b, 0x67cf, 0x6822, 0x767d, 0x767e, 0x9b44, 0x5e61, 0x6a0a, 0x7169,
+ 0x71d4, 0x756a, 0xf964, 0x7e41, 0x8543, 0x85e9, 0x98dc, 0x4f10, 0x7b4f,
+ 0x7f70, 0x95a5, 0x51e1, 0x5e06, 0x68b5, 0x6c3e, 0x6c4e, 0x6cdb, 0x72af,
+ 0x7bc4, 0x8303, 0x6cd5, 0x743a, 0x50fb, 0x5288, 0x58c1, 0x64d8, 0x6a97,
+ 0x74a7, 0x7656, 0x78a7, 0x8617, 0x95e2, 0x9739, 0xf965, 0x535e, 0x5f01,
+ 0x8b8a, 0x8fa8, 0x8faf, 0x908a, 0x5225, 0x77a5, 0x9c49, 0x9f08, 0x4e19,
+ 0x5002, 0x5175, 0x5c5b, 0x5e77, 0x661e, 0x663a, 0x67c4, 0x68c5, 0x70b3,
+ 0x7501, 0x75c5, 0x79c9, 0x7add, 0x8f27, 0x9920, 0x9a08, 0x4fdd, 0x5821,
+ 0x5831, 0x5bf6, 0x666e, 0x6b65, 0x6d11, 0x6e7a, 0x6f7d, 0x73e4, 0x752b,
+ 0x83e9, 0x88dc, 0x8913, 0x8b5c, 0x8f14, 0x4f0f, 0x50d5, 0x5310, 0x535c,
+ 0x5b93, 0x5fa9, 0x670d, 0x798f, 0x8179, 0x832f, 0x8514, 0x8907, 0x8986,
+ 0x8f39, 0x8f3b, 0x99a5, 0x9c12, 0x672c, 0x4e76, 0x4ff8, 0x5949, 0x5c01,
+ 0x5cef, 0x5cf0, 0x6367, 0x68d2, 0x70fd, 0x71a2, 0x742b, 0x7e2b, 0x84ec,
+ 0x8702, 0x9022, 0x92d2, 0x9cf3, 0x4e0d, 0x4ed8, 0x4fef, 0x5085, 0x5256,
+ 0x526f, 0x5426, 0x5490, 0x57e0, 0x592b, 0x5a66, 0x5b5a, 0x5b75, 0x5bcc,
+ 0x5e9c, 0xf966, 0x6276, 0x6577, 0x65a7, 0x6d6e, 0x6ea5, 0x7236, 0x7b26,
+ 0x7c3f, 0x7f36, 0x8150, 0x8151, 0x819a, 0x8240, 0x8299, 0x83a9, 0x8a03,
+ 0x8ca0, 0x8ce6, 0x8cfb, 0x8d74, 0x8dba, 0x90e8, 0x91dc, 0x961c, 0x9644,
+ 0x99d9, 0x9ce7, 0x5317, 0x5206, 0x5429, 0x5674, 0x58b3, 0x5954, 0x596e,
+ 0x5fff, 0x61a4, 0x626e, 0x6610, 0x6c7e, 0x711a, 0x76c6, 0x7c89, 0x7cde,
+ 0x7d1b, 0x82ac, 0x8cc1, 0x96f0, 0xf967, 0x4f5b, 0x5f17, 0x5f7f, 0x62c2,
+ 0x5d29, 0x670b, 0x68da, 0x787c, 0x7e43, 0x9d6c, 0x4e15, 0x5099, 0x5315,
+ 0x532a, 0x5351, 0x5983, 0x5a62, 0x5e87, 0x60b2, 0x618a, 0x6249, 0x6279,
+ 0x6590, 0x6787, 0x69a7, 0x6bd4, 0x6bd6, 0x6bd7, 0x6bd8, 0x6cb8, 0xf968,
+ 0x7435, 0x75fa, 0x7812, 0x7891, 0x79d5, 0x79d8, 0x7c83, 0x7dcb, 0x7fe1,
+ 0x80a5, 0x813e, 0x81c2, 0x83f2, 0x871a, 0x88e8, 0x8ab9, 0x8b6c, 0x8cbb,
+ 0x9119, 0x975e, 0x98db, 0x9f3b, 0x56ac, 0x5b2a, 0x5f6c, 0x658c, 0x6ab3,
+ 0x6baf, 0x6d5c, 0x6ff1, 0x7015, 0x725d, 0x73ad, 0x8ca7, 0x8cd3, 0x983b,
+ 0x6191, 0x6c37, 0x8058, 0x9a01, 0x4e4d, 0x4e8b, 0x4e9b, 0x4ed5, 0x4f3a,
+ 0x4f3c, 0x4f7f, 0x4fdf, 0x50ff, 0x53f2, 0x53f8, 0x5506, 0x55e3, 0x56db,
+ 0x58eb, 0x5962, 0x5a11, 0x5beb, 0x5bfa, 0x5c04, 0x5df3, 0x5e2b, 0x5f99,
+ 0x601d, 0x6368, 0x659c, 0x65af, 0x67f6, 0x67fb, 0x68ad, 0x6b7b, 0x6c99,
+ 0x6cd7, 0x6e23, 0x7009, 0x7345, 0x7802, 0x793e, 0x7940, 0x7960, 0x79c1,
+ 0x7be9, 0x7d17, 0x7d72, 0x8086, 0x820d, 0x838e, 0x84d1, 0x86c7, 0x88df,
+ 0x8a50, 0x8a5e, 0x8b1d, 0x8cdc, 0x8d66, 0x8fad, 0x90aa, 0x98fc, 0x99df,
+ 0x9e9d, 0x524a, 0xf969, 0x6714, 0xf96a, 0x5098, 0x522a, 0x5c71, 0x6563,
+ 0x6c55, 0x73ca, 0x7523, 0x759d, 0x7b97, 0x849c, 0x9178, 0x9730, 0x4e77,
+ 0x6492, 0x6bba, 0x715e, 0x85a9, 0x4e09, 0xf96b, 0x6749, 0x68ee, 0x6e17,
+ 0x829f, 0x8518, 0x886b, 0x63f7, 0x6f81, 0x9212, 0x98af, 0x4e0a, 0x50b7,
+ 0x50cf, 0x511f, 0x5546, 0x55aa, 0x5617, 0x5b40, 0x5c19, 0x5ce0, 0x5e38,
+ 0x5e8a, 0x5ea0, 0x5ec2, 0x60f3, 0x6851, 0x6a61, 0x6e58, 0x723d, 0x7240,
+ 0x72c0, 0x76f8, 0x7965, 0x7bb1, 0x7fd4, 0x88f3, 0x89f4, 0x8a73, 0x8c61,
+ 0x8cde, 0x971c, 0x585e, 0x74bd, 0x8cfd, 0x55c7, 0xf96c, 0x7a61, 0x7d22,
+ 0x8272, 0x7272, 0x751f, 0x7525, 0xf96d, 0x7b19, 0x5885, 0x58fb, 0x5dbc,
+ 0x5e8f, 0x5eb6, 0x5f90, 0x6055, 0x6292, 0x637f, 0x654d, 0x6691, 0x66d9,
+ 0x66f8, 0x6816, 0x68f2, 0x7280, 0x745e, 0x7b6e, 0x7d6e, 0x7dd6, 0x7f72,
+ 0x80e5, 0x8212, 0x85af, 0x897f, 0x8a93, 0x901d, 0x92e4, 0x9ecd, 0x9f20,
+ 0x5915, 0x596d, 0x5e2d, 0x60dc, 0x6614, 0x6673, 0x6790, 0x6c50, 0x6dc5,
+ 0x6f5f, 0x77f3, 0x78a9, 0x84c6, 0x91cb, 0x932b, 0x4ed9, 0x50ca, 0x5148,
+ 0x5584, 0x5b0b, 0x5ba3, 0x6247, 0x657e, 0x65cb, 0x6e32, 0x717d, 0x7401,
+ 0x7444, 0x7487, 0x74bf, 0x766c, 0x79aa, 0x7dda, 0x7e55, 0x7fa8, 0x817a,
+ 0x81b3, 0x8239, 0x861a, 0x87ec, 0x8a75, 0x8de3, 0x9078, 0x9291, 0x9425,
+ 0x994d, 0x9bae, 0x5368, 0x5c51, 0x6954, 0x6cc4, 0x6d29, 0x6e2b, 0x820c,
+ 0x859b, 0x893b, 0x8a2d, 0x8aaa, 0x96ea, 0x9f67, 0x5261, 0x66b9, 0x6bb2,
+ 0x7e96, 0x87fe, 0x8d0d, 0x9583, 0x965d, 0x651d, 0x6d89, 0x71ee, 0xf96e,
+ 0x57ce, 0x59d3, 0x5bac, 0x6027, 0x60fa, 0x6210, 0x661f, 0x665f, 0x7329,
+ 0x73f9, 0x76db, 0x7701, 0x7b6c, 0x8056, 0x8072, 0x8165, 0x8aa0, 0x9192,
+ 0x4e16, 0x52e2, 0x6b72, 0x6d17, 0x7a05, 0x7b39, 0x7d30, 0xf96f, 0x8cb0,
+ 0x53ec, 0x562f, 0x5851, 0x5bb5, 0x5c0f, 0x5c11, 0x5de2, 0x6240, 0x6383,
+ 0x6414, 0x662d, 0x68b3, 0x6cbc, 0x6d88, 0x6eaf, 0x701f, 0x70a4, 0x71d2,
+ 0x7526, 0x758f, 0x758e, 0x7619, 0x7b11, 0x7be0, 0x7c2b, 0x7d20, 0x7d39,
+ 0x852c, 0x856d, 0x8607, 0x8a34, 0x900d, 0x9061, 0x90b5, 0x92b7, 0x97f6,
+ 0x9a37, 0x4fd7, 0x5c6c, 0x675f, 0x6d91, 0x7c9f, 0x7e8c, 0x8b16, 0x8d16,
+ 0x901f, 0x5b6b, 0x5dfd, 0x640d, 0x84c0, 0x905c, 0x98e1, 0x7387, 0x5b8b,
+ 0x609a, 0x677e, 0x6dde, 0x8a1f, 0x8aa6, 0x9001, 0x980c, 0x5237, 0xf970,
+ 0x7051, 0x788e, 0x9396, 0x8870, 0x91d7, 0x4fee, 0x53d7, 0x55fd, 0x56da,
+ 0x5782, 0x58fd, 0x5ac2, 0x5b88, 0x5cab, 0x5cc0, 0x5e25, 0x6101, 0x620d,
+ 0x624b, 0x6388, 0x641c, 0x6536, 0x6578, 0x6a39, 0x6b8a, 0x6c34, 0x6d19,
+ 0x6f31, 0x71e7, 0x72e9, 0x7378, 0x7407, 0x74b2, 0x7626, 0x7761, 0x79c0,
+ 0x7a57, 0x7aea, 0x7cb9, 0x7d8f, 0x7dac, 0x7e61, 0x7f9e, 0x8129, 0x8331,
+ 0x8490, 0x84da, 0x85ea, 0x8896, 0x8ab0, 0x8b90, 0x8f38, 0x9042, 0x9083,
+ 0x916c, 0x9296, 0x92b9, 0x968b, 0x96a7, 0x96a8, 0x96d6, 0x9700, 0x9808,
+ 0x9996, 0x9ad3, 0x9b1a, 0x53d4, 0x587e, 0x5919, 0x5b70, 0x5bbf, 0x6dd1,
+ 0x6f5a, 0x719f, 0x7421, 0x74b9, 0x8085, 0x83fd, 0x5de1, 0x5f87, 0x5faa,
+ 0x6042, 0x65ec, 0x6812, 0x696f, 0x6a53, 0x6b89, 0x6d35, 0x6df3, 0x73e3,
+ 0x76fe, 0x77ac, 0x7b4d, 0x7d14, 0x8123, 0x821c, 0x8340, 0x84f4, 0x8563,
+ 0x8a62, 0x8ac4, 0x9187, 0x931e, 0x9806, 0x99b4, 0x620c, 0x8853, 0x8ff0,
+ 0x9265, 0x5d07, 0x5d27, 0x5d69, 0x745f, 0x819d, 0x8768, 0x6fd5, 0x62fe,
+ 0x7fd2, 0x8936, 0x8972, 0x4e1e, 0x4e58, 0x50e7, 0x52dd, 0x5347, 0x627f,
+ 0x6607, 0x7e69, 0x8805, 0x965e, 0x4f8d, 0x5319, 0x5636, 0x59cb, 0x5aa4,
+ 0x5c38, 0x5c4e, 0x5c4d, 0x5e02, 0x5f11, 0x6043, 0x65bd, 0x662f, 0x6642,
+ 0x67be, 0x67f4, 0x731c, 0x77e2, 0x793a, 0x7fc5, 0x8494, 0x84cd, 0x8996,
+ 0x8a66, 0x8a69, 0x8ae1, 0x8c55, 0x8c7a, 0x57f4, 0x5bd4, 0x5f0f, 0x606f,
+ 0x62ed, 0x690d, 0x6b96, 0x6e5c, 0x7184, 0x7bd2, 0x8755, 0x8b58, 0x8efe,
+ 0x98df, 0x98fe, 0x4f38, 0x4f81, 0x4fe1, 0x547b, 0x5a20, 0x5bb8, 0x613c,
+ 0x65b0, 0x6668, 0x71fc, 0x7533, 0x795e, 0x7d33, 0x814e, 0x81e3, 0x8398,
+ 0x85aa, 0x85ce, 0x8703, 0x8a0a, 0x8eab, 0x8f9b, 0xf971, 0x8fc5, 0x5931,
+ 0x5ba4, 0x5be6, 0x6089, 0x5be9, 0x5c0b, 0x5fc3, 0x6c81, 0xf972, 0x6df1,
+ 0x700b, 0x751a, 0x82af, 0x8af6, 0x4ec0, 0x5341, 0xf973, 0x96d9, 0x6c0f,
+ 0x4e9e, 0x4fc4, 0x5152, 0x555e, 0x5a25, 0x5ce8, 0x6211, 0x7259, 0x82bd,
+ 0x83aa, 0x86fe, 0x8859, 0x8a1d, 0x963f, 0x96c5, 0x9913, 0x9d09, 0x9d5d,
+ 0x580a, 0x5cb3, 0x5dbd, 0x5e44, 0x60e1, 0x6115, 0x63e1, 0x6a02, 0x6e25,
+ 0x9102, 0x9354, 0x984e, 0x9c10, 0x9f77, 0x5b89, 0x5cb8, 0x6309, 0x664f,
+ 0x6848, 0x773c, 0x96c1, 0x978d, 0x9854, 0x9b9f, 0x65a1, 0x8b01, 0x8ecb,
+ 0x95bc, 0x5535, 0x5ca9, 0x5dd6, 0x5eb5, 0x6697, 0x764c, 0x83f4, 0x95c7,
+ 0x58d3, 0x62bc, 0x72ce, 0x9d28, 0x4ef0, 0x592e, 0x600f, 0x663b, 0x6b83,
+ 0x79e7, 0x9d26, 0x5393, 0x54c0, 0x57c3, 0x5d16, 0x611b, 0x66d6, 0x6daf,
+ 0x788d, 0x827e, 0x9698, 0x9744, 0x5384, 0x627c, 0x6396, 0x6db2, 0x7e0a,
+ 0x814b, 0x984d, 0x6afb, 0x7f4c, 0x9daf, 0x9e1a, 0x4e5f, 0x503b, 0x51b6,
+ 0x591c, 0x60f9, 0x63f6, 0x6930, 0x723a, 0x8036, 0xf974, 0x91ce, 0x5f31,
+ 0xf975, 0xf976, 0x7d04, 0x82e5, 0x846f, 0x84bb, 0x85e5, 0x8e8d, 0xf977,
+ 0x4f6f, 0xf978, 0xf979, 0x58e4, 0x5b43, 0x6059, 0x63da, 0x6518, 0x656d,
+ 0x6698, 0xf97a, 0x694a, 0x6a23, 0x6d0b, 0x7001, 0x716c, 0x75d2, 0x760d,
+ 0x79b3, 0x7a70, 0xf97b, 0x7f8a, 0xf97c, 0x8944, 0xf97d, 0x8b93, 0x91c0,
+ 0x967d, 0xf97e, 0x990a, 0x5704, 0x5fa1, 0x65bc, 0x6f01, 0x7600, 0x79a6,
+ 0x8a9e, 0x99ad, 0x9b5a, 0x9f6c, 0x5104, 0x61b6, 0x6291, 0x6a8d, 0x81c6,
+ 0x5043, 0x5830, 0x5f66, 0x7109, 0x8a00, 0x8afa, 0x5b7c, 0x8616, 0x4ffa,
+ 0x513c, 0x56b4, 0x5944, 0x63a9, 0x6df9, 0x5daa, 0x696d, 0x5186, 0x4e88,
+ 0x4f59, 0xf97f, 0xf980, 0xf981, 0x5982, 0xf982, 0xf983, 0x6b5f, 0x6c5d,
+ 0xf984, 0x74b5, 0x7916, 0xf985, 0x8207, 0x8245, 0x8339, 0x8f3f, 0x8f5d,
+ 0xf986, 0x9918, 0xf987, 0xf988, 0xf989, 0x4ea6, 0xf98a, 0x57df, 0x5f79,
+ 0x6613, 0xf98b, 0xf98c, 0x75ab, 0x7e79, 0x8b6f, 0xf98d, 0x9006, 0x9a5b,
+ 0x56a5, 0x5827, 0x59f8, 0x5a1f, 0x5bb4, 0xf98e, 0x5ef6, 0xf98f, 0xf990,
+ 0x6350, 0x633b, 0xf991, 0x693d, 0x6c87, 0x6cbf, 0x6d8e, 0x6d93, 0x6df5,
+ 0x6f14, 0xf992, 0x70df, 0x7136, 0x7159, 0xf993, 0x71c3, 0x71d5, 0xf994,
+ 0x784f, 0x786f, 0xf995, 0x7b75, 0x7de3, 0xf996, 0x7e2f, 0xf997, 0x884d,
+ 0x8edf, 0xf998, 0xf999, 0xf99a, 0x925b, 0xf99b, 0x9cf6, 0xf99c, 0xf99d,
+ 0xf99e, 0x6085, 0x6d85, 0xf99f, 0x71b1, 0xf9a0, 0xf9a1, 0x95b1, 0x53ad,
+ 0xf9a2, 0xf9a3, 0xf9a4, 0x67d3, 0xf9a5, 0x708e, 0x7130, 0x7430, 0x8276,
+ 0x82d2, 0xf9a6, 0x95bb, 0x9ae5, 0x9e7d, 0x66c4, 0xf9a7, 0x71c1, 0x8449,
+ 0xf9a8, 0xf9a9, 0x584b, 0xf9aa, 0xf9ab, 0x5db8, 0x5f71, 0xf9ac, 0x6620,
+ 0x668e, 0x6979, 0x69ae, 0x6c38, 0x6cf3, 0x6e36, 0x6f41, 0x6fda, 0x701b,
+ 0x702f, 0x7150, 0x71df, 0x7370, 0xf9ad, 0x745b, 0xf9ae, 0x74d4, 0x76c8,
+ 0x7a4e, 0x7e93, 0xf9af, 0xf9b0, 0x82f1, 0x8a60, 0x8fce, 0xf9b1, 0x9348,
+ 0xf9b2, 0x9719, 0xf9b3, 0xf9b4, 0x4e42, 0x502a, 0xf9b5, 0x5208, 0x53e1,
+ 0x66f3, 0x6c6d, 0x6fca, 0x730a, 0x777f, 0x7a62, 0x82ae, 0x85dd, 0x8602,
+ 0xf9b6, 0x88d4, 0x8a63, 0x8b7d, 0x8c6b, 0xf9b7, 0x92b3, 0xf9b8, 0x9713,
+ 0x9810, 0x4e94, 0x4f0d, 0x4fc9, 0x50b2, 0x5348, 0x543e, 0x5433, 0x55da,
+ 0x5862, 0x58ba, 0x5967, 0x5a1b, 0x5be4, 0x609f, 0xf9b9, 0x61ca, 0x6556,
+ 0x65ff, 0x6664, 0x68a7, 0x6c5a, 0x6fb3, 0x70cf, 0x71ac, 0x7352, 0x7b7d,
+ 0x8708, 0x8aa4, 0x9c32, 0x9f07, 0x5c4b, 0x6c83, 0x7344, 0x7389, 0x923a,
+ 0x6eab, 0x7465, 0x761f, 0x7a69, 0x7e15, 0x860a, 0x5140, 0x58c5, 0x64c1,
+ 0x74ee, 0x7515, 0x7670, 0x7fc1, 0x9095, 0x96cd, 0x9954, 0x6e26, 0x74e6,
+ 0x7aa9, 0x7aaa, 0x81e5, 0x86d9, 0x8778, 0x8a1b, 0x5a49, 0x5b8c, 0x5b9b,
+ 0x68a1, 0x6900, 0x6d63, 0x73a9, 0x7413, 0x742c, 0x7897, 0x7de9, 0x7feb,
+ 0x8118, 0x8155, 0x839e, 0x8c4c, 0x962e, 0x9811, 0x66f0, 0x5f80, 0x65fa,
+ 0x6789, 0x6c6a, 0x738b, 0x502d, 0x5a03, 0x6b6a, 0x77ee, 0x5916, 0x5d6c,
+ 0x5dcd, 0x7325, 0x754f, 0xf9ba, 0xf9bb, 0x50e5, 0x51f9, 0x582f, 0x592d,
+ 0x5996, 0x59da, 0x5be5, 0xf9bc, 0xf9bd, 0x5da2, 0x62d7, 0x6416, 0x6493,
+ 0x64fe, 0xf9be, 0x66dc, 0xf9bf, 0x6a48, 0xf9c0, 0x71ff, 0x7464, 0xf9c1,
+ 0x7a88, 0x7aaf, 0x7e47, 0x7e5e, 0x8000, 0x8170, 0xf9c2, 0x87ef, 0x8981,
+ 0x8b20, 0x9059, 0xf9c3, 0x9080, 0x9952, 0x617e, 0x6b32, 0x6d74, 0x7e1f,
+ 0x8925, 0x8fb1, 0x4fd1, 0x50ad, 0x5197, 0x52c7, 0x57c7, 0x5889, 0x5bb9,
+ 0x5eb8, 0x6142, 0x6995, 0x6d8c, 0x6e67, 0x6eb6, 0x7194, 0x7462, 0x7528,
+ 0x752c, 0x8073, 0x8338, 0x84c9, 0x8e0a, 0x9394, 0x93de, 0xf9c4, 0x4e8e,
+ 0x4f51, 0x5076, 0x512a, 0x53c8, 0x53cb, 0x53f3, 0x5b87, 0x5bd3, 0x5c24,
+ 0x611a, 0x6182, 0x65f4, 0x725b, 0x7397, 0x7440, 0x76c2, 0x7950, 0x7991,
+ 0x79b9, 0x7d06, 0x7fbd, 0x828b, 0x85d5, 0x865e, 0x8fc2, 0x9047, 0x90f5,
+ 0x91ea, 0x9685, 0x96e8, 0x96e9, 0x52d6, 0x5f67, 0x65ed, 0x6631, 0x682f,
+ 0x715c, 0x7a36, 0x90c1, 0x980a, 0x4e91, 0xf9c5, 0x6a52, 0x6b9e, 0x6f90,
+ 0x7189, 0x8018, 0x82b8, 0x8553, 0x904b, 0x9695, 0x96f2, 0x97fb, 0x851a,
+ 0x9b31, 0x4e90, 0x718a, 0x96c4, 0x5143, 0x539f, 0x54e1, 0x5713, 0x5712,
+ 0x57a3, 0x5a9b, 0x5ac4, 0x5bc3, 0x6028, 0x613f, 0x63f4, 0x6c85, 0x6d39,
+ 0x6e72, 0x6e90, 0x7230, 0x733f, 0x7457, 0x82d1, 0x8881, 0x8f45, 0x9060,
+ 0xf9c6, 0x9662, 0x9858, 0x9d1b, 0x6708, 0x8d8a, 0x925e, 0x4f4d, 0x5049,
+ 0x50de, 0x5371, 0x570d, 0x59d4, 0x5a01, 0x5c09, 0x6170, 0x6690, 0x6e2d,
+ 0x7232, 0x744b, 0x7def, 0x80c3, 0x840e, 0x8466, 0x853f, 0x875f, 0x885b,
+ 0x8918, 0x8b02, 0x9055, 0x97cb, 0x9b4f, 0x4e73, 0x4f91, 0x5112, 0x516a,
+ 0xf9c7, 0x552f, 0x55a9, 0x5b7a, 0x5ba5, 0x5e7c, 0x5e7d, 0x5ebe, 0x60a0,
+ 0x60df, 0x6108, 0x6109, 0x63c4, 0x6538, 0x6709, 0xf9c8, 0x67d4, 0x67da,
+ 0xf9c9, 0x6961, 0x6962, 0x6cb9, 0x6d27, 0xf9ca, 0x6e38, 0xf9cb, 0x6fe1,
+ 0x7336, 0x7337, 0xf9cc, 0x745c, 0x7531, 0xf9cd, 0x7652, 0xf9ce, 0xf9cf,
+ 0x7dad, 0x81fe, 0x8438, 0x88d5, 0x8a98, 0x8adb, 0x8aed, 0x8e30, 0x8e42,
+ 0x904a, 0x903e, 0x907a, 0x9149, 0x91c9, 0x936e, 0xf9d0, 0xf9d1, 0x5809,
+ 0xf9d2, 0x6bd3, 0x8089, 0x80b2, 0xf9d3, 0xf9d4, 0x5141, 0x596b, 0x5c39,
+ 0xf9d5, 0xf9d6, 0x6f64, 0x73a7, 0x80e4, 0x8d07, 0xf9d7, 0x9217, 0x958f,
+ 0xf9d8, 0xf9d9, 0xf9da, 0xf9db, 0x807f, 0x620e, 0x701c, 0x7d68, 0x878d,
+ 0xf9dc, 0x57a0, 0x6069, 0x6147, 0x6bb7, 0x8abe, 0x9280, 0x96b1, 0x4e59,
+ 0x541f, 0x6deb, 0x852d, 0x9670, 0x97f3, 0x98ee, 0x63d6, 0x6ce3, 0x9091,
+ 0x51dd, 0x61c9, 0x81ba, 0x9df9, 0x4f9d, 0x501a, 0x5100, 0x5b9c, 0x610f,
+ 0x61ff, 0x64ec, 0x6905, 0x6bc5, 0x7591, 0x77e3, 0x7fa9, 0x8264, 0x858f,
+ 0x87fb, 0x8863, 0x8abc, 0x8b70, 0x91ab, 0x4e8c, 0x4ee5, 0x4f0a, 0xf9dd,
+ 0xf9de, 0x5937, 0x59e8, 0xf9df, 0x5df2, 0x5f1b, 0x5f5b, 0x6021, 0xf9e0,
+ 0xf9e1, 0xf9e2, 0xf9e3, 0x723e, 0x73e5, 0xf9e4, 0x7570, 0x75cd, 0xf9e5,
+ 0x79fb, 0xf9e6, 0x800c, 0x8033, 0x8084, 0x82e1, 0x8351, 0xf9e7, 0xf9e8,
+ 0x8cbd, 0x8cb3, 0x9087, 0xf9e9, 0xf9ea, 0x98f4, 0x990c, 0xf9eb, 0xf9ec,
+ 0x7037, 0x76ca, 0x7fca, 0x7fcc, 0x7ffc, 0x8b1a, 0x4eba, 0x4ec1, 0x5203,
+ 0x5370, 0xf9ed, 0x54bd, 0x56e0, 0x59fb, 0x5bc5, 0x5f15, 0x5fcd, 0x6e6e,
+ 0xf9ee, 0xf9ef, 0x7d6a, 0x8335, 0xf9f0, 0x8693, 0x8a8d, 0xf9f1, 0x976d,
+ 0x9777, 0xf9f2, 0xf9f3, 0x4e00, 0x4f5a, 0x4f7e, 0x58f9, 0x65e5, 0x6ea2,
+ 0x9038, 0x93b0, 0x99b9, 0x4efb, 0x58ec, 0x598a, 0x59d9, 0x6041, 0xf9f4,
+ 0xf9f5, 0x7a14, 0xf9f6, 0x834f, 0x8cc3, 0x5165, 0x5344, 0xf9f7, 0xf9f8,
+ 0xf9f9, 0x4ecd, 0x5269, 0x5b55, 0x82bf, 0x4ed4, 0x523a, 0x54a8, 0x59c9,
+ 0x59ff, 0x5b50, 0x5b57, 0x5b5c, 0x6063, 0x6148, 0x6ecb, 0x7099, 0x716e,
+ 0x7386, 0x74f7, 0x75b5, 0x78c1, 0x7d2b, 0x8005, 0x81ea, 0x8328, 0x8517,
+ 0x85c9, 0x8aee, 0x8cc7, 0x96cc, 0x4f5c, 0x52fa, 0x56bc, 0x65ab, 0x6628,
+ 0x707c, 0x70b8, 0x7235, 0x7dbd, 0x828d, 0x914c, 0x96c0, 0x9d72, 0x5b71,
+ 0x68e7, 0x6b98, 0x6f7a, 0x76de, 0x5c91, 0x66ab, 0x6f5b, 0x7bb4, 0x7c2a,
+ 0x8836, 0x96dc, 0x4e08, 0x4ed7, 0x5320, 0x5834, 0x58bb, 0x58ef, 0x596c,
+ 0x5c07, 0x5e33, 0x5e84, 0x5f35, 0x638c, 0x66b2, 0x6756, 0x6a1f, 0x6aa3,
+ 0x6b0c, 0x6f3f, 0x7246, 0xf9fa, 0x7350, 0x748b, 0x7ae0, 0x7ca7, 0x8178,
+ 0x81df, 0x81e7, 0x838a, 0x846c, 0x8523, 0x8594, 0x85cf, 0x88dd, 0x8d13,
+ 0x91ac, 0x9577, 0x969c, 0x518d, 0x54c9, 0x5728, 0x5bb0, 0x624d, 0x6750,
+ 0x683d, 0x6893, 0x6e3d, 0x6ed3, 0x707d, 0x7e21, 0x88c1, 0x8ca1, 0x8f09,
+ 0x9f4b, 0x9f4e, 0x722d, 0x7b8f, 0x8acd, 0x931a, 0x4f47, 0x4f4e, 0x5132,
+ 0x5480, 0x59d0, 0x5e95, 0x62b5, 0x6775, 0x696e, 0x6a17, 0x6cae, 0x6e1a,
+ 0x72d9, 0x732a, 0x75bd, 0x7bb8, 0x7d35, 0x82e7, 0x83f9, 0x8457, 0x85f7,
+ 0x8a5b, 0x8caf, 0x8e87, 0x9019, 0x90b8, 0x96ce, 0x9f5f, 0x52e3, 0x540a,
+ 0x5ae1, 0x5bc2, 0x6458, 0x6575, 0x6ef4, 0x72c4, 0xf9fb, 0x7684, 0x7a4d,
+ 0x7b1b, 0x7c4d, 0x7e3e, 0x7fdf, 0x837b, 0x8b2b, 0x8cca, 0x8d64, 0x8de1,
+ 0x8e5f, 0x8fea, 0x8ff9, 0x9069, 0x93d1, 0x4f43, 0x4f7a, 0x50b3, 0x5168,
+ 0x5178, 0x524d, 0x526a, 0x5861, 0x587c, 0x5960, 0x5c08, 0x5c55, 0x5edb,
+ 0x609b, 0x6230, 0x6813, 0x6bbf, 0x6c08, 0x6fb1, 0x714e, 0x7420, 0x7530,
+ 0x7538, 0x7551, 0x7672, 0x7b4c, 0x7b8b, 0x7bad, 0x7bc6, 0x7e8f, 0x8a6e,
+ 0x8f3e, 0x8f49, 0x923f, 0x9293, 0x9322, 0x942b, 0x96fb, 0x985a, 0x986b,
+ 0x991e, 0x5207, 0x622a, 0x6298, 0x6d59, 0x7664, 0x7aca, 0x7bc0, 0x7d76,
+ 0x5360, 0x5cbe, 0x5e97, 0x6f38, 0x70b9, 0x7c98, 0x9711, 0x9b8e, 0x9ede,
+ 0x63a5, 0x647a, 0x8776, 0x4e01, 0x4e95, 0x4ead, 0x505c, 0x5075, 0x5448,
+ 0x59c3, 0x5b9a, 0x5e40, 0x5ead, 0x5ef7, 0x5f81, 0x60c5, 0x633a, 0x653f,
+ 0x6574, 0x65cc, 0x6676, 0x6678, 0x67fe, 0x6968, 0x6a89, 0x6b63, 0x6c40,
+ 0x6dc0, 0x6de8, 0x6e1f, 0x6e5e, 0x701e, 0x70a1, 0x738e, 0x73fd, 0x753a,
+ 0x775b, 0x7887, 0x798e, 0x7a0b, 0x7a7d, 0x7cbe, 0x7d8e, 0x8247, 0x8a02,
+ 0x8aea, 0x8c9e, 0x912d, 0x914a, 0x91d8, 0x9266, 0x92cc, 0x9320, 0x9706,
+ 0x9756, 0x975c, 0x9802, 0x9f0e, 0x5236, 0x5291, 0x557c, 0x5824, 0x5e1d,
+ 0x5f1f, 0x608c, 0x63d0, 0x68af, 0x6fdf, 0x796d, 0x7b2c, 0x81cd, 0x85ba,
+ 0x88fd, 0x8af8, 0x8e44, 0x918d, 0x9664, 0x969b, 0x973d, 0x984c, 0x9f4a,
+ 0x4fce, 0x5146, 0x51cb, 0x52a9, 0x5632, 0x5f14, 0x5f6b, 0x63aa, 0x64cd,
+ 0x65e9, 0x6641, 0x66fa, 0x66f9, 0x671d, 0x689d, 0x68d7, 0x69fd, 0x6f15,
+ 0x6f6e, 0x7167, 0x71e5, 0x722a, 0x74aa, 0x773a, 0x7956, 0x795a, 0x79df,
+ 0x7a20, 0x7a95, 0x7c97, 0x7cdf, 0x7d44, 0x7e70, 0x8087, 0x85fb, 0x86a4,
+ 0x8a54, 0x8abf, 0x8d99, 0x8e81, 0x9020, 0x906d, 0x91e3, 0x963b, 0x96d5,
+ 0x9ce5, 0x65cf, 0x7c07, 0x8db3, 0x93c3, 0x5b58, 0x5c0a, 0x5352, 0x62d9,
+ 0x731d, 0x5027, 0x5b97, 0x5f9e, 0x60b0, 0x616b, 0x68d5, 0x6dd9, 0x742e,
+ 0x7a2e, 0x7d42, 0x7d9c, 0x7e31, 0x816b, 0x8e2a, 0x8e35, 0x937e, 0x9418,
+ 0x4f50, 0x5750, 0x5de6, 0x5ea7, 0x632b, 0x7f6a, 0x4e3b, 0x4f4f, 0x4f8f,
+ 0x505a, 0x59dd, 0x80c4, 0x546a, 0x5468, 0x55fe, 0x594f, 0x5b99, 0x5dde,
+ 0x5eda, 0x665d, 0x6731, 0x67f1, 0x682a, 0x6ce8, 0x6d32, 0x6e4a, 0x6f8d,
+ 0x70b7, 0x73e0, 0x7587, 0x7c4c, 0x7d02, 0x7d2c, 0x7da2, 0x821f, 0x86db,
+ 0x8a3b, 0x8a85, 0x8d70, 0x8e8a, 0x8f33, 0x9031, 0x914e, 0x9152, 0x9444,
+ 0x99d0, 0x7af9, 0x7ca5, 0x4fca, 0x5101, 0x51c6, 0x57c8, 0x5bef, 0x5cfb,
+ 0x6659, 0x6a3d, 0x6d5a, 0x6e96, 0x6fec, 0x710c, 0x756f, 0x7ae3, 0x8822,
+ 0x9021, 0x9075, 0x96cb, 0x99ff, 0x8301, 0x4e2d, 0x4ef2, 0x8846, 0x91cd,
+ 0x537d, 0x6adb, 0x696b, 0x6c41, 0x847a, 0x589e, 0x618e, 0x66fe, 0x62ef,
+ 0x70dd, 0x7511, 0x75c7, 0x7e52, 0x84b8, 0x8b49, 0x8d08, 0x4e4b, 0x53ea,
+ 0x54ab, 0x5730, 0x5740, 0x5fd7, 0x6301, 0x6307, 0x646f, 0x652f, 0x65e8,
+ 0x667a, 0x679d, 0x67b3, 0x6b62, 0x6c60, 0x6c9a, 0x6f2c, 0x77e5, 0x7825,
+ 0x7949, 0x7957, 0x7d19, 0x80a2, 0x8102, 0x81f3, 0x829d, 0x82b7, 0x8718,
+ 0x8a8c, 0xf9fc, 0x8d04, 0x8dbe, 0x9072, 0x76f4, 0x7a19, 0x7a37, 0x7e54,
+ 0x8077, 0x5507, 0x55d4, 0x5875, 0x632f, 0x6422, 0x6649, 0x664b, 0x686d,
+ 0x699b, 0x6b84, 0x6d25, 0x6eb1, 0x73cd, 0x7468, 0x74a1, 0x755b, 0x75b9,
+ 0x76e1, 0x771e, 0x778b, 0x79e6, 0x7e09, 0x7e1d, 0x81fb, 0x852f, 0x8897,
+ 0x8a3a, 0x8cd1, 0x8eeb, 0x8fb0, 0x9032, 0x93ad, 0x9663, 0x9673, 0x9707,
+ 0x4f84, 0x53f1, 0x59ea, 0x5ac9, 0x5e19, 0x684e, 0x74c6, 0x75be, 0x79e9,
+ 0x7a92, 0x81a3, 0x86ed, 0x8cea, 0x8dcc, 0x8fed, 0x659f, 0x6715, 0xf9fd,
+ 0x57f7, 0x6f57, 0x7ddd, 0x8f2f, 0x93f6, 0x96c6, 0x5fb5, 0x61f2, 0x6f84,
+ 0x4e14, 0x4f98, 0x501f, 0x53c9, 0x55df, 0x5d6f, 0x5dee, 0x6b21, 0x6b64,
+ 0x78cb, 0x7b9a, 0xf9fe, 0x8e49, 0x8eca, 0x906e, 0x6349, 0x643e, 0x7740,
+ 0x7a84, 0x932f, 0x947f, 0x9f6a, 0x64b0, 0x6faf, 0x71e6, 0x74a8, 0x74da,
+ 0x7ac4, 0x7c12, 0x7e82, 0x7cb2, 0x7e98, 0x8b9a, 0x8d0a, 0x947d, 0x9910,
+ 0x994c, 0x5239, 0x5bdf, 0x64e6, 0x672d, 0x7d2e, 0x50ed, 0x53c3, 0x5879,
+ 0x6158, 0x6159, 0x61fa, 0x65ac, 0x7ad9, 0x8b92, 0x8b96, 0x5009, 0x5021,
+ 0x5275, 0x5531, 0x5a3c, 0x5ee0, 0x5f70, 0x6134, 0x655e, 0x660c, 0x6636,
+ 0x66a2, 0x69cd, 0x6ec4, 0x6f32, 0x7316, 0x7621, 0x7a93, 0x8139, 0x8259,
+ 0x83d6, 0x84bc, 0x50b5, 0x57f0, 0x5bc0, 0x5be8, 0x5f69, 0x63a1, 0x7826,
+ 0x7db5, 0x83dc, 0x8521, 0x91c7, 0x91f5, 0x518a, 0x67f5, 0x7b56, 0x8cac,
+ 0x51c4, 0x59bb, 0x60bd, 0x8655, 0x501c, 0xf9ff, 0x5254, 0x5c3a, 0x617d,
+ 0x621a, 0x62d3, 0x64f2, 0x65a5, 0x6ecc, 0x7620, 0x810a, 0x8e60, 0x965f,
+ 0x96bb, 0x4edf, 0x5343, 0x5598, 0x5929, 0x5ddd, 0x64c5, 0x6cc9, 0x6dfa,
+ 0x7394, 0x7a7f, 0x821b, 0x85a6, 0x8ce4, 0x8e10, 0x9077, 0x91e7, 0x95e1,
+ 0x9621, 0x97c6, 0x51f8, 0x54f2, 0x5586, 0x5fb9, 0x64a4, 0x6f88, 0x7db4,
+ 0x8f1f, 0x8f4d, 0x9435, 0x50c9, 0x5c16, 0x6cbe, 0x6dfb, 0x751b, 0x77bb,
+ 0x7c3d, 0x7c64, 0x8a79, 0x8ac2, 0x581e, 0x59be, 0x5e16, 0x6377, 0x7252,
+ 0x758a, 0x776b, 0x8adc, 0x8cbc, 0x8f12, 0x5ef3, 0x6674, 0x6df8, 0x807d,
+ 0x83c1, 0x8acb, 0x9751, 0x9bd6, 0xfa00, 0x5243, 0x66ff, 0x6d95, 0x6eef,
+ 0x7de0, 0x8ae6, 0x902e, 0x905e, 0x9ad4, 0x521d, 0x527f, 0x54e8, 0x6194,
+ 0x6284, 0x62db, 0x68a2, 0x6912, 0x695a, 0x6a35, 0x7092, 0x7126, 0x785d,
+ 0x7901, 0x790e, 0x79d2, 0x7a0d, 0x8096, 0x8278, 0x82d5, 0x8349, 0x8549,
+ 0x8c82, 0x8d85, 0x9162, 0x918b, 0x91ae, 0x4fc3, 0x56d1, 0x71ed, 0x77d7,
+ 0x8700, 0x89f8, 0x5bf8, 0x5fd6, 0x6751, 0x90a8, 0x53e2, 0x585a, 0x5bf5,
+ 0x60a4, 0x6181, 0x6460, 0x7e3d, 0x8070, 0x8525, 0x9283, 0x64ae, 0x50ac,
+ 0x5d14, 0x6700, 0x589c, 0x62bd, 0x63a8, 0x690e, 0x6978, 0x6a1e, 0x6e6b,
+ 0x76ba, 0x79cb, 0x82bb, 0x8429, 0x8acf, 0x8da8, 0x8ffd, 0x9112, 0x914b,
+ 0x919c, 0x9310, 0x9318, 0x939a, 0x96db, 0x9a36, 0x9c0d, 0x4e11, 0x755c,
+ 0x795d, 0x7afa, 0x7b51, 0x7bc9, 0x7e2e, 0x84c4, 0x8e59, 0x8e74, 0x8ef8,
+ 0x9010, 0x6625, 0x693f, 0x7443, 0x51fa, 0x672e, 0x9edc, 0x5145, 0x5fe0,
+ 0x6c96, 0x87f2, 0x885d, 0x8877, 0x60b4, 0x81b5, 0x8403, 0x8d05, 0x53d6,
+ 0x5439, 0x5634, 0x5a36, 0x5c31, 0x708a, 0x7fe0, 0x805a, 0x8106, 0x81ed,
+ 0x8da3, 0x9189, 0x9a5f, 0x9df2, 0x5074, 0x4ec4, 0x53a0, 0x60fb, 0x6e2c,
+ 0x5c64, 0x4f88, 0x5024, 0x55e4, 0x5cd9, 0x5e5f, 0x6065, 0x6894, 0x6cbb,
+ 0x6dc4, 0x71be, 0x75d4, 0x75f4, 0x7661, 0x7a1a, 0x7a49, 0x7dc7, 0x7dfb,
+ 0x7f6e, 0x81f4, 0x86a9, 0x8f1c, 0x96c9, 0x99b3, 0x9f52, 0x5247, 0x52c5,
+ 0x98ed, 0x89aa, 0x4e03, 0x67d2, 0x6f06, 0x4fb5, 0x5be2, 0x6795, 0x6c88,
+ 0x6d78, 0x741b, 0x7827, 0x91dd, 0x937c, 0x87c4, 0x79e4, 0x7a31, 0x5feb,
+ 0x4ed6, 0x54a4, 0x553e, 0x58ae, 0x59a5, 0x60f0, 0x6253, 0x62d6, 0x6736,
+ 0x6955, 0x8235, 0x9640, 0x99b1, 0x99dd, 0x502c, 0x5353, 0x5544, 0x577c,
+ 0xfa01, 0x6258, 0xfa02, 0x64e2, 0x666b, 0x67dd, 0x6fc1, 0x6fef, 0x7422,
+ 0x7438, 0x8a17, 0x9438, 0x5451, 0x5606, 0x5766, 0x5f48, 0x619a, 0x6b4e,
+ 0x7058, 0x70ad, 0x7dbb, 0x8a95, 0x596a, 0x812b, 0x63a2, 0x7708, 0x803d,
+ 0x8caa, 0x5854, 0x642d, 0x69bb, 0x5b95, 0x5e11, 0x6e6f, 0xfa03, 0x8569,
+ 0x514c, 0x53f0, 0x592a, 0x6020, 0x614b, 0x6b86, 0x6c70, 0x6cf0, 0x7b1e,
+ 0x80ce, 0x82d4, 0x8dc6, 0x90b0, 0x98b1, 0xfa04, 0x64c7, 0x6fa4, 0x6491,
+ 0x6504, 0x514e, 0x5410, 0x571f, 0x8a0e, 0x615f, 0x6876, 0xfa05, 0x75db,
+ 0x7b52, 0x7d71, 0x901a, 0x5806, 0x69cc, 0x817f, 0x892a, 0x9000, 0x9839,
+ 0x5078, 0x5957, 0x59ac, 0x6295, 0x900f, 0x9b2a, 0x615d, 0x7279, 0x95d6,
+ 0x5761, 0x5a46, 0x5df4, 0x628a, 0x64ad, 0x64fa, 0x6777, 0x6ce2, 0x6d3e,
+ 0x722c, 0x7436, 0x7834, 0x7f77, 0x82ad, 0x8ddb, 0x9817, 0x5224, 0x5742,
+ 0x677f, 0x7248, 0x74e3, 0x8ca9, 0x8fa6, 0x9211, 0x962a, 0x516b, 0x53ed,
+ 0x634c, 0x4f69, 0x5504, 0x6096, 0x6557, 0x6c9b, 0x6d7f, 0x724c, 0x72fd,
+ 0x7a17, 0x8987, 0x8c9d, 0x5f6d, 0x6f8e, 0x70f9, 0x81a8, 0x610e, 0x4fbf,
+ 0x504f, 0x6241, 0x7247, 0x7bc7, 0x7de8, 0x7fe9, 0x904d, 0x97ad, 0x9a19,
+ 0x8cb6, 0x576a, 0x5e73, 0x67b0, 0x840d, 0x8a55, 0x5420, 0x5b16, 0x5e63,
+ 0x5ee2, 0x5f0a, 0x6583, 0x80ba, 0x853d, 0x9589, 0x965b, 0x4f48, 0x5305,
+ 0x530d, 0x530f, 0x5486, 0x54fa, 0x5703, 0x5e03, 0x6016, 0x629b, 0x62b1,
+ 0x6355, 0xfa06, 0x6ce1, 0x6d66, 0x75b1, 0x7832, 0x80de, 0x812f, 0x82de,
+ 0x8461, 0x84b2, 0x888d, 0x8912, 0x900b, 0x92ea, 0x98fd, 0x9b91, 0x5e45,
+ 0x66b4, 0x66dd, 0x7011, 0x7206, 0xfa07, 0x4ff5, 0x527d, 0x5f6a, 0x6153,
+ 0x6753, 0x6a19, 0x6f02, 0x74e2, 0x7968, 0x8868, 0x8c79, 0x98c7, 0x98c4,
+ 0x9a43, 0x54c1, 0x7a1f, 0x6953, 0x8af7, 0x8c4a, 0x98a8, 0x99ae, 0x5f7c,
+ 0x62ab, 0x75b2, 0x76ae, 0x88ab, 0x907f, 0x9642, 0x5339, 0x5f3c, 0x5fc5,
+ 0x6ccc, 0x73cc, 0x7562, 0x758b, 0x7b46, 0x82fe, 0x999d, 0x4e4f, 0x903c,
+ 0x4e0b, 0x4f55, 0x53a6, 0x590f, 0x5ec8, 0x6630, 0x6cb3, 0x7455, 0x8377,
+ 0x8766, 0x8cc0, 0x9050, 0x971e, 0x9c15, 0x58d1, 0x5b78, 0x8650, 0x8b14,
+ 0x9db4, 0x5bd2, 0x6068, 0x608d, 0x65f1, 0x6c57, 0x6f22, 0x6fa3, 0x701a,
+ 0x7f55, 0x7ff0, 0x9591, 0x9592, 0x9650, 0x97d3, 0x5272, 0x8f44, 0x51fd,
+ 0x542b, 0x54b8, 0x5563, 0x558a, 0x6abb, 0x6db5, 0x7dd8, 0x8266, 0x929c,
+ 0x9677, 0x9e79, 0x5408, 0x54c8, 0x76d2, 0x86e4, 0x95a4, 0x95d4, 0x965c,
+ 0x4ea2, 0x4f09, 0x59ee, 0x5ae6, 0x5df7, 0x6052, 0x6297, 0x676d, 0x6841,
+ 0x6c86, 0x6e2f, 0x7f38, 0x809b, 0x822a, 0xfa08, 0xfa09, 0x9805, 0x4ea5,
+ 0x5055, 0x54b3, 0x5793, 0x595a, 0x5b69, 0x5bb3, 0x61c8, 0x6977, 0x6d77,
+ 0x7023, 0x87f9, 0x89e3, 0x8a72, 0x8ae7, 0x9082, 0x99ed, 0x9ab8, 0x52be,
+ 0x6838, 0x5016, 0x5e78, 0x674f, 0x8347, 0x884c, 0x4eab, 0x5411, 0x56ae,
+ 0x73e6, 0x9115, 0x97ff, 0x9909, 0x9957, 0x9999, 0x5653, 0x589f, 0x865b,
+ 0x8a31, 0x61b2, 0x6af6, 0x737b, 0x8ed2, 0x6b47, 0x96aa, 0x9a57, 0x5955,
+ 0x7200, 0x8d6b, 0x9769, 0x4fd4, 0x5cf4, 0x5f26, 0x61f8, 0x665b, 0x6ceb,
+ 0x70ab, 0x7384, 0x73b9, 0x73fe, 0x7729, 0x774d, 0x7d43, 0x7d62, 0x7e23,
+ 0x8237, 0x8852, 0xfa0a, 0x8ce2, 0x9249, 0x986f, 0x5b51, 0x7a74, 0x8840,
+ 0x9801, 0x5acc, 0x4fe0, 0x5354, 0x593e, 0x5cfd, 0x633e, 0x6d79, 0x72f9,
+ 0x8105, 0x8107, 0x83a2, 0x92cf, 0x9830, 0x4ea8, 0x5144, 0x5211, 0x578b,
+ 0x5f62, 0x6cc2, 0x6ece, 0x7005, 0x7050, 0x70af, 0x7192, 0x73e9, 0x7469,
+ 0x834a, 0x87a2, 0x8861, 0x9008, 0x90a2, 0x93a3, 0x99a8, 0x516e, 0x5f57,
+ 0x60e0, 0x6167, 0x66b3, 0x8559, 0x8e4a, 0x91af, 0x978b, 0x4e4e, 0x4e92,
+ 0x547c, 0x58d5, 0x58fa, 0x597d, 0x5cb5, 0x5f27, 0x6236, 0x6248, 0x660a,
+ 0x6667, 0x6beb, 0x6d69, 0x6dcf, 0x6e56, 0x6ef8, 0x6f94, 0x6fe0, 0x6fe9,
+ 0x705d, 0x72d0, 0x7425, 0x745a, 0x74e0, 0x7693, 0x795c, 0x7cca, 0x7e1e,
+ 0x80e1, 0x82a6, 0x846b, 0x84bf, 0x864e, 0x865f, 0x8774, 0x8b77, 0x8c6a,
+ 0x93ac, 0x9800, 0x9865, 0x60d1, 0x6216, 0x9177, 0x5a5a, 0x660f, 0x6df7,
+ 0x6e3e, 0x743f, 0x9b42, 0x5ffd, 0x60da, 0x7b0f, 0x54c4, 0x5f18, 0x6c5e,
+ 0x6cd3, 0x6d2a, 0x70d8, 0x7d05, 0x8679, 0x8a0c, 0x9d3b, 0x5316, 0x548c,
+ 0x5b05, 0x6a3a, 0x706b, 0x7575, 0x798d, 0x79be, 0x82b1, 0x83ef, 0x8a71,
+ 0x8b41, 0x8ca8, 0x9774, 0xfa0b, 0x64f4, 0x652b, 0x78ba, 0x78bb, 0x7a6b,
+ 0x4e38, 0x559a, 0x5950, 0x5ba6, 0x5e7b, 0x60a3, 0x63db, 0x6b61, 0x6665,
+ 0x6853, 0x6e19, 0x7165, 0x74b0, 0x7d08, 0x9084, 0x9a69, 0x9c25, 0x6d3b,
+ 0x6ed1, 0x733e, 0x8c41, 0x95ca, 0x51f0, 0x5e4c, 0x5fa8, 0x604d, 0x60f6,
+ 0x6130, 0x614c, 0x6643, 0x6644, 0x69a5, 0x6cc1, 0x6e5f, 0x6ec9, 0x6f62,
+ 0x714c, 0x749c, 0x7687, 0x7bc1, 0x7c27, 0x8352, 0x8757, 0x9051, 0x968d,
+ 0x9ec3, 0x532f, 0x56de, 0x5efb, 0x5f8a, 0x6062, 0x6094, 0x61f7, 0x6666,
+ 0x6703, 0x6a9c, 0x6dee, 0x6fae, 0x7070, 0x736a, 0x7e6a, 0x81be, 0x8334,
+ 0x86d4, 0x8aa8, 0x8cc4, 0x5283, 0x7372, 0x5b96, 0x6a6b, 0x9404, 0x54ee,
+ 0x5686, 0x5b5d, 0x6548, 0x6585, 0x66c9, 0x689f, 0x6d8d, 0x6dc6, 0x723b,
+ 0x80b4, 0x9175, 0x9a4d, 0x4faf, 0x5019, 0x539a, 0x540e, 0x543c, 0x5589,
+ 0x55c5, 0x5e3f, 0x5f8c, 0x673d, 0x7166, 0x73dd, 0x9005, 0x52db, 0x52f3,
+ 0x5864, 0x58ce, 0x7104, 0x718f, 0x71fb, 0x85b0, 0x8a13, 0x6688, 0x85a8,
+ 0x55a7, 0x6684, 0x714a, 0x8431, 0x5349, 0x5599, 0x6bc1, 0x5f59, 0x5fbd,
+ 0x63ee, 0x6689, 0x7147, 0x8af1, 0x8f1d, 0x9ebe, 0x4f11, 0x643a, 0x70cb,
+ 0x7566, 0x8667, 0x6064, 0x8b4e, 0x9df8, 0x5147, 0x51f6, 0x5308, 0x6d36,
+ 0x80f8, 0x9ed1, 0x6615, 0x6b23, 0x7098, 0x75d5, 0x5403, 0x5c79, 0x7d07,
+ 0x8a16, 0x6b20, 0x6b3d, 0x6b46, 0x5438, 0x6070, 0x6d3d, 0x7fd5, 0x8208,
+ 0x50d6, 0x51de, 0x559c, 0x566b, 0x56cd, 0x59ec, 0x5b09, 0x5e0c, 0x6199,
+ 0x6198, 0x6231, 0x665e, 0x66e6, 0x7199, 0x71b9, 0x71ba, 0x72a7, 0x79a7,
+ 0x7a00, 0x7fb2, 0x8a70,
0/* End of table; # of entries=8741(0x2225)+1 */
};
blob - cb223dae213ce51bbdb5862f36314c23168bf545
blob + 5afa316a97d1735e81c06218cda25d90a2c71a50
--- src/cmd/tcs/misc.h
+++ src/cmd/tcs/misc.h
0x00bf, 0x2310, 0x00ac, 0x00bd, 0x00bc, 0x00a1, 0x00ab, 0x00bb,
0x00e3, 0x00f5, 0x00d8, 0x00f8, 0x0153, 0x0152, 0x00c0, 0x00c3,
0x00d5, 0x00a8, 0x00b4, 0x2020, 0x00b6, 0x00a9, 0x00ae, 0x2122,
-0x0133, 0x0132,
+0x0133, 0x0132,
0x05d0, 0x05d1, 0x05d2, 0x05d3, 0x05d4, 0x05d5, /* hebrew */
0x05d6, 0x05d7, 0x05d8, 0x05d9, 0x05db, 0x05dc, 0x05de, 0x05e0,
0x05e1, 0x05e2, 0x05e4, 0x05e6, 0x05e7, 0x05e8, 0x05e9, 0x05ea,
-0x05df, 0x05da, 0x05dd, 0x05e3, 0x05e5,
+0x05df, 0x05da, 0x05dd, 0x05e3, 0x05e5,
0x00a7, 0x2038, 0x221e, /* math */
0x03b1, 0x03b2, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* greek */
-0x03a6, 0x03b8, 0x2126, 0x03b4,
+0x03a6, 0x03b8, 0x2126, 0x03b4,
0x222e, 0x03c6, 0x2208, 0x220f, /* math */
0x2261, 0x00b1, 0x2265, 0x2264, 0x2320, 0x2321, 0x00f7, 0x2248,
0x00b0, 0x2022, 0x00b7, 0x221a, 0x207f, 0x00b2, 0x00b3, 0x00af
0x00a9, 0x2563, 0x2551, 0x2557, 0x255d, 0x00a2, 0x00a5, 0x2510,
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x00e3, 0x00c3,
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x00a4,
-0x00f0, 0x00d0, 0x00ca, 0x00cb, 0x00c8, 0x0131, 0x00cd, 0x00ce,
+0x00f0, 0x00d0, 0x00ca, 0x00cb, 0x00c8, 0x0131, 0x00cd, 0x00ce,
0x00cf, 0x2518, 0x250c, 0x2588, 0x2584, 0x00a6, 0x00cc, 0x2580,
0x00d3, 0x00df, 0x00d4, 0x00d2, 0x00f5, 0x00d5, 0x00b5, 0x00fe,
0x00de, 0x00da, 0x00db, 0x00d9, 0x00fd, 0x00dd, 0x00af, 0x00b4,
blob - 617dd198a97c617399a28ab081ba0b0bb8f8193f
blob + 90ecfec5bb546e30efadc51bfc98d9d79cbe3b5a
--- src/cmd/tcs/ms.h
+++ src/cmd/tcs/ms.h
for(i in $*){
j=`{echo $i | sed 's;.*./;cp;'}
echo long tab$j'[256] = {'
- hget http://www.microsoft.com/globaldev/reference/$i.mspx | htmlfmt |
+ hget http://www.microsoft.com/globaldev/reference/$i.mspx | htmlfmt |
9 grep '^.. = U\+....:' | 9 sed 's/= U\+/ 0x/; s/:.*.//' | awk '
{ t[$1] = $2 }
- END {
+ END {
for(i=0; i<256; i++) {
s = sprintf("%.2X", i);
if(s in t)
blob - 6722bb6bef8805ca80b35417cdbe828fa5bd6872
blob + d796ba63ecc504825832854271507bda63d50ba6
--- src/cmd/tcs/tcs.c
+++ src/cmd/tcs/tcs.c
break;
case 'f':
from = EARGF(usage());
- break;
+ break;
case 'l':
listem = 1;
break;
0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
-0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
+0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* greek */
0x03a6, 0x0398, 0x2126, 0x03b4, 0x221e, 0x2205, 0x2208, 0x2229,
0x2555, 0x2563, 0x2551, 0x2557, 0x255d, 0x255c, 0x255b, 0x2510,
0x2514, 0x2534, 0x252c, 0x251c, 0x2500, 0x253c, 0x255e, 0x255f,
0x255a, 0x2554, 0x2569, 0x2566, 0x2560, 0x2550, 0x256c, 0x2567,
-0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
+0x2568, 0x2564, 0x2565, 0x2559, 0x2558, 0x2552, 0x2553, 0x256b,
0x256a, 0x2518, 0x250c, 0x2588, 0x2584, 0x258c, 0x2590, 0x2580,
0x03b1, 0x00df, 0x0393, 0x03c0, 0x03a3, 0x03c3, 0x00b5, 0x03c4, /* greek */
0x03a6, 0x0398, 0x2126, 0x03b4, 0x221e, 0x2205, 0x2208, 0x2229,
blob - 1046b779650658b399ba494467885b1a04dcd297
blob + 5542008d4ad95a09f54745676cdbc24d49f053eb
--- src/cmd/tcs/tune.c
+++ src/cmd/tcs/tune.c
static Rune t2[] =
{
- 0x0bcd/*்*/,
+ 0x0bcd/*்*/,
0x0bcd/*்*/, // filler
0x0bbe/*ா*/,
0x0bbf/*ி*/,
Rune rbuf[N];
Rune *r, *er, tr;
int c, i;
-
+
USED(x);
r = rbuf;
er = rbuf+N-3;
case 0xe38d/**/:
*r++ = 0x0bb6/*ஶ*/; *r++ = 0x0bcd/*்*/; *r++ = 0x0bb0/*ர*/; *r++ = 0x0bc0/*ீ*/;
break;
- default:
+ default:
if(c >= 0xe200 && c <= 0xe3ff){
if(squawk)
EPR "%s: rune 0x%x not in output cs\n", argv0, c);
blob - 6688293e33b72599114f6fb15f30d9b4141aec1c
blob + 471e2b17d3474eb50d24139a0dcdda431e154bd0
--- src/cmd/touch.c
+++ src/cmd/touch.c
case 'c':
nocreate = 1;
break;
- default:
+ default:
usage();
}ARGEND
blob - 9c98d197734555687eeaefd3faa276b86eb441e0
blob + de43dcd23a95af78672813106b8db4276b96527e
--- src/cmd/tpic/arcgen.c
+++ src/cmd/tpic/arcgen.c
else if( x> 0.0 && y<=0.0) return(4);
else return 0; /* shut up lint */
}
-
blob - 8a7e08be5dc576de1cd14b2473bdac77a21c3ed9
blob + 639cdb474de3fc0271a19e577383b8606213df62
--- src/cmd/tpic/linegen.c
+++ src/cmd/tpic/linegen.c
extreme(ex, ey);
nx = xi; ny = yi;
}
-
+
}
p->o_ddval = ddval;
if (dbg) {
blob - 438e71a6ec3557bbc80d90e565ca5148b2940f24
blob + a11c74782fd3812e2b01f1734448b9829934ada7
--- src/cmd/tpic/pic.h
+++ src/cmd/tpic/pic.h
int yyparse(void);
#include "tex.h"
-
blob - ade5df6b526715e839bc9e585b8274b3e8b86537
blob + 678dba60769951d44c4f82897daece4338c61253
--- src/cmd/tpic/tex.c
+++ src/cmd/tpic/tex.c
}
void
-box(double x0, double y0, double x1, double y1)
+box(double x0, double y0, double x1, double y1)
{
fprintf(TEXFILE," \\special{pa %d %d}",TRX(x0),TRY(y0));
fprintf(TEXFILE,"\\special{pa %d %d}",TRX(x1),TRY(y0));
}
void
-line(double x0, double y0, double x1, double y1)
+line(double x0, double y0, double x1, double y1)
{
move(x0, y0);
vec(x1, y1);
}
void
-move(double xx, double yy)
+move(double xx, double yy)
{
- e1->copyx = xx;
+ e1->copyx = xx;
e1->copyy = yy;
}
void
openpl(void)
-{
+{
TEXFILE = stdout;
space(xmin, ymin, xmax, ymax);
}
void
-range(double x0, double y0, double x1, double y1)
+range(double x0, double y0, double x1, double y1)
{
e1->xmin = x0;
e1->ymin = y0;
}
void
-rmove(double xx, double yy)
+rmove(double xx, double yy)
{
e1->copyx += xx;
e1->copyy += yy;
}
void
-rvec(double xx, double yy)
+rvec(double xx, double yy)
{
vec(xx+e1->copyx, yy+e1->copyy);
}
void
-sbox(double x0, double y0, double x1, double y1)
+sbox(double x0, double y0, double x1, double y1)
{
fprintf(TEXFILE," \\special{bk}%%\n");
box(x0, y0, x1, y1);
}
void
-vec(double xx, double yy)
+vec(double xx, double yy)
{
fprintf(TEXFILE," \\special{pa %d %d}",TRX(e1->copyx),TRY(e1->copyy));
- e1->copyx = xx;
+ e1->copyx = xx;
e1->copyy = yy;
fprintf(TEXFILE,"\\special{pa %d %d}",TRX(xx),TRY(yy));
switch(e1->pen){
blob - 036967d6d6edcd58999ea2220e1944c794cf86cc
blob + 3b20c49bffb878b847db4de844040a8131abe5e2
--- src/cmd/tr.c
+++ src/cmd/tr.c
writerune(1, (Rune) from);
}
}
-
+
} else {
while (readrune(0, &from) > 0){
if (from > high)
writerune(1, (Rune) from);
}
}
-
+
} else {
while (readrune(0, &from) > 0) {
if (from <= high)
blob - 064a0b02746165b2c72558d185b4cf793e660d75
blob + 5ecad041218a293839d269afac638a1e3b05c7b3
--- src/cmd/troff/dwbinit.c
+++ src/cmd/troff/dwbinit.c
* NULL, xyzzy, sizeof(xyzzy),
* NULL, NULL, 0
* };
- *
+ *
* The last element must have NULL entries for the address and
* value fields. The main() routine would then do,
*
* not great, but should be good enough for now. Also probably should
* have DWBhome() only do the lookup once, and remember the value if
* called again.
- *
+ *
*/
if ( strncmp(path, DWBPREFIX, len) == 0 ) {
} /* End of DWBprefix */
/*****************************************************************************/
-
blob - 8df12f2c6e34c8b9d6d6464e450dbb1867afcd5d
blob + 4c2fcf9d814812f2d24d51af732447459b0e787d
--- src/cmd/troff/ext.h
+++ src/cmd/troff/ext.h
extern char *DWBfontdir;
extern char *DWBntermdir;
extern char *DWBalthyphens;
-
blob - c97b036ca8ee2f520857f95c466271d0e88efc66
blob + 3976350882ef081e000c9c0555e33706b2c1935c
--- src/cmd/troff/mbwc.c
+++ src/cmd/troff/mbwc.c
}
return p-s;
}
-
blob - c65898cec0f5528cc29e8b773d23bd7bbc9d6377
blob + adda8c4b46ccabe4256644df55392c7ce7f2bb9b
--- src/cmd/troff/n1.c
+++ src/cmd/troff/n1.c
save_tty();
break;
case 'V':
- fprintf(stdout, "%croff: DWB %s\n",
+ fprintf(stdout, "%croff: DWB %s\n",
TROFF ? 't' : 'n', DWBVERSION);
exit(0);
case 't':
return(k);
}
if (k == FLSS) {
- copyf++;
+ copyf++;
raw++;
i = getch0();
if (!fi)
flss = i;
- copyf--;
+ copyf--;
raw--;
goto g0;
}
}
if (k == fc || k == tabch || k == ldrch) {
if ((i = setfield(k)) == 0)
- goto g0;
- else
+ goto g0;
+ else
return(i);
}
if (k == '\b') {
blob - b6be4c512b0c5d06395362b83da68de39514962e
blob + 6f41dae23135d7484ee35682f3b39f4e62aa6af7
--- src/cmd/troff/n10.c
+++ src/cmd/troff/n10.c
j = -j;
if (isvmot(i))
lead += j;
- else
+ else
esc += j;
continue;
}
} else if (*k & 0200) {
if (*k & 0100) {
if (*k & 040)
- j = t.up;
- else
+ j = t.up;
+ else
j = t.down;
} else {
if (*k & 040)
- j = t.left;
- else
+ j = t.left;
+ else
j = t.right;
}
if ((i = *k & 037) == 0) { /* 2nd 0200 turns it off */
}
while (i--)
oputs(j);
- } else
+ } else
oput(*k);
}
oputs(t.plotoff);
iesct = esct;
if (esct += esc)
- i = "\0";
- else
+ i = "\0";
+ else
i = "\n\0";
j = t.hlf;
p = t.right;
} else { /* no half-line forward, not at line begining */
k = lead / t.Newline;
lead = lead % t.Newline;
- if (k > 0)
+ if (k > 0)
esc = esct;
i = "\n";
- while (k--)
+ while (k--)
oputs(i);
}
}
blob - 2943e55307b2ecd96e3c951cadb94ef4c72d8da0
blob + 41b2ec1e2ea1db2db6a7b26ee8c86abad97c09d2
--- src/cmd/troff/n2.c
+++ src/cmd/troff/n2.c
return 0;
}
if (ismot(i)) {
- pchar1(i);
+ pchar1(i);
return 0;
}
switch (j = cbits(i)) {
}
-void done(int x)
+void done(int x)
{
int i;
}
-void done1(int x)
+void done1(int x)
{
error |= x;
if (numtabp[NL].val) {
}
-void done2(int x)
+void done2(int x)
{
ptlead();
if (TROFF && !ascii)
done3(x);
}
-void done3(int x)
+void done3(int x)
{
error |= x;
flusho();
}
-void edone(int x)
+void edone(int x)
{
frame = stk;
nxf = frame + 1;
blob - 8279d74892e8f25f716ecf91f1a18099a49af353
blob + 1c7c574f62fb49bce7838576435f6eb2e2c8fac2
--- src/cmd/troff/n3.c
+++ src/cmd/troff/n3.c
/*
* troff3.c
- *
+ *
* macro and string routines, storage allocation
*/
}
void munhash(Contab *mp)
-{
+{
Contab *p;
Contab **lp;
if (contabp[i].rq == 0)
break;
}
- if (i == nm)
+ if (i == nm)
growcontab();
freeslot = i + 1;
if ((nextb = alloc()) == -1) {
else
return(popi());
}
-
+
i = rbf0(ip);
if (i == 0) {
if (!app)
lastpbp = pbp;
pendt = ch = 0;
frame = nxf;
- if (nxf->nargs == 0)
+ if (nxf->nargs == 0)
nxf += 1;
- else
+ else
nxf = (Stack *)argtop;
return(ip = newip);
}
return(0);
if (i == '(')
return(getrq());
- else
+ else
return(i);
}
quote = 0;
if (cbits(i = getch()) == '"')
quote++;
- else
+ else
ch = i;
while (1) {
i = getch();
if (ismot(delim = getch())) {
ch = delim;
delim = '\'';
- } else
+ } else
delim = cbits(delim);
tp = buf;
numtabp[HP].val = 0;
tcnt++;
j = contabp[i].mx;
for (k = 1; (j = blist[bindex(j)].nextoff) != -1; )
- k++;
+ k++;
cnt++;
kk += k;
if (!tot)
blob - a1abe943d96493a7e25e41cd76035ba14c552ce4
blob + 08e06ad36c33ecb9da91eb756e559744da6014fb
--- src/cmd/troff/n4.c
+++ src/cmd/troff/n4.c
i = ls;
break;
case 'R': /* maximal # of regs that can be addressed */
- i = 255*256 - regcnt;
+ i = 255*256 - regcnt;
break;
case 'z':
p = unpair(dip->curd);
cpushback(cfname[ifi]);
return;
case 'S':
- buf[0] = j = 0;
+ buf[0] = j = 0;
for( i = 0; tabtab[i] != 0 && i < NTAB; i++) {
if (i > 0)
buf[j++] = ' ';
blob - 7266432794e3021b88591f50391a82d53c5d632b
blob + eab395fef51ded6afe92d33dc756e5514051f769
--- src/cmd/troff/n5.c
+++ src/cmd/troff/n5.c
/*
* troff5.c
- *
+ *
* misc processing requests
*/
case 'c': /*centered adj*/
admod = 1;
break;
- case 'b':
+ case 'b':
case 'n':
admod = 0;
break;
- case '0':
- case '2':
+ case '0':
+ case '2':
case '4':
ad = 0;
- case '1':
- case '3':
+ case '1':
+ case '3':
case '5':
admod = (i - '0') / 2;
}
if (skip() || ismot(i = getch()) || cbits(i) == ' ' || cbits(i) == '\n') {
ch = i;
return(c);
- } else
+ } else
return cbits(i); /* was (i & BYTEMASK) */
}
{
if (aa > bb)
return(aa);
- else
+ else
return(bb);
}
skip();
if ((i = vnumb(&pl)) == 0)
pl = 11 * INCH; /*11in*/
- else
+ else
pl = i;
if (numtabp[NL].val > pl)
numtabp[NL].val = pl;
skip();
if (!(j = getrq()))
return;
- else
+ else
for (k = 0; k < NTRAP; k++)
if (mlist[k] == j)
break;
ERROR "fm: missing filename" WARN;
return;
}
-
+
for (i = 0; i < 15 && fcache[i].fp != NULL; i++) {
if (strcmp(nextf, fcache[i].name) == 0)
break;
casetm1(0, fcache[i].fp);
}
-void casetm1(int ab, FILE *out)
+void casetm1(int ab, FILE *out)
{
int i, j, c;
char *p;
trace = savtrac;
}
} else
- skip();
+ skip();
for (i = 0; i < NTM - 2; ) {
if ((c = cbits(getch())) == '\n' || c == RIGHT)
break;
j = vnumb((int *)0);
if (nonumb)
j = lss;
- } else
+ } else
j = a;
if (j == 0)
return;
j = i;
savlss = lss;
if (dip != d)
- i = dip->dnl;
- else
+ i = dip->dnl;
+ else
i = numtabp[NL].val;
if ((i + j) < 0)
j = -i;
skip();
if (dip != d)
- p = &dip->dnl;
- else
+ p = &dip->dnl;
+ else
p = &numtabp[NL].val;
a = vnumb(p);
if (nonumb)
ERROR "cannot do .ev %d", nxev WARN;
if (error)
done2(040);
- else
+ else
edone(040);
return;
}
if (read(0, &onechar, 1) == 1) {
if (onechar == '\n')
tty++;
- else
+ else
tty = 1;
if (tty != 3)
return(onechar);
j = TABMASK;
}
tabtab[i] = j & TABMASK;
- if (!nonumb)
+ if (!nonumb)
switch (cbits(ch)) {
case 'C':
tabtab[i] |= CTAB;
if (skip() || !(i = getrq()) || i == 'S' || (j = findft(i)) == -1)
ulfont = ULFONT; /*default underline position*/
- else
+ else
ulfont = j;
if (NROFF && ulfont == FT)
ulfont = ULFONT;
int i, j;
if (dip != d)
- j = dip->dnl;
- else
+ j = dip->dnl;
+ else
j = numtabp[NL].val;
if (skip()) {
dip->mkline = j;
blob - 69d48f2e654f6de157d710528cdf9498d220e9c6
blob + d44e67dac2d783ac0d96567dea06ded2a027c8a0
--- src/cmd/troff/n6.c
+++ src/cmd/troff/n6.c
if (a)
i = getrq();
- else
+ else
i = getsn();
if (!i || i == 'P') {
j = font1;
k = -k;
base -= k;
emsz = 0;
- } else
+ } else
continue;
if (base < numtabp[SB].val)
numtabp[SB].val = base;
if (skip() || !(i = getrq()) || (j = findft(i)) == -1) {
if (k)
goto bd1;
- else
+ else
return;
}
if (j == smnt) {
blob - 15bcfd5b0bbac2bccf2e2a62470c9a4075fa83fb
blob + 414563c09286507c9b655ea51a295a4fb0497f00
--- src/cmd/troff/n7.c
+++ src/cmd/troff/n7.c
/*
* troff7.c
- *
+ *
* text
*/
horiz(un);
if (NROFF) {
if (adrem % t.Adj)
- resol = t.Hor;
- else
+ resol = t.Hor;
+ else
resol = t.Adj;
} else
resol = HOR;
}
if (icf)
icf++;
- else
+ else
ic = 0;
ne = nwd = 0;
un = in;
nflush++;
numtabp[HP].val = 0;
if ((dip == d) && (numtabp[NL].val == -1)) {
- newline(1);
+ newline(1);
return;
}
setnel();
goto t4;
if (pendt)
if (spcnt)
- goto t2;
- else
+ goto t2;
+ else
goto t3;
pendt++;
if (spcnt)
adsp = adrem = 0;
if (ad) {
if (nwd == 1)
- adsp = nel;
- else
+ adsp = nel;
+ else
adsp = nel / (nwd - 1);
adsp = (adsp / HOR) * HOR;
adrem = nel - adsp*(nwd-1);
int i;
if (flss)
- i = flss;
- else
+ i = flss;
+ else
i = lss;
flss = 0;
casesp1(i);
}
if (dip->ditrap && !dip->ditf && dip->dnl >= dip->ditrap && dip->dimac)
if (control(dip->dimac, 0)) {
- trap++;
+ trap++;
dip->ditf++;
}
return;
if (dip != d)
i = dip->dnl;
- else
+ else
i = numtabp[NL].val;
return(findt(i));
}
ejf++;
if (a)
ejl = a;
- else
+ else
ejl = frame;
if (trap)
return;
blob - 9ff2ebce8b2e28b33709d565f77fdb2e4f7c2c17
blob + 92c42724fe28bb86ea5dd79296a03b1418cfe03f
--- src/cmd/troff/n8.c
+++ src/cmd/troff/n8.c
/*
* troff8.c
- *
+ *
* hyphenation
*/
/* this appears to sort hyphenation points into increasing order */
*hyp++ = 0;
- if (*hyptr)
+ if (*hyptr)
for (j = 1; j; ) {
j = 0;
for (hyp = hyptr + 1; *hyp != 0; hyp++) {
return(0);
w = wdstart;
while (*e && w <= hyend && (*e & 0177) == maplow(cbits(*w))) {
- e++;
+ e++;
w++;
}
if (!*e) {
}
return(1);
} else {
- e++;
+ e++;
continue;
}
- } else
+ } else
while (*e++)
;
}
}
s = s0 + i - 1;
w = hyend;
- if (*s0 & HY_BIT)
+ if (*s0 & HY_BIT)
goto mark;
while (s > s0) {
w--;
int
maplow(int i)
{
- if (isupper(i))
+ if (isupper(i))
i = tolower(i);
return(i);
}
val *= dilook('a', cbits(*w), bxh);
else if (w == wdstart + 1)
val *= dilook(cbits(*(w-1)), cbits(*w), bxxh);
- else
+ else
val *= dilook(cbits(*(w-1)), cbits(*w), xxh);
val *= dilook(cbits(*w), cbits(*(w+1)), xhx);
val *= dilook(cbits(*(w+1)), cbits(*(w+2)), hxx);
blob - 3e3ad97f2f2ad929bf763f06c392da6643cde5ef
blob + 7c09de0248d4e3e4d121a168d5d271acbd159941
--- src/cmd/troff/n9.c
+++ src/cmd/troff/n9.c
/*
* troff9.c
- *
+ *
* misc functions
*/
}
}
}
- else
+ else
return;
*pbp++ = makem(w[0] / 2);
for (k = 0; o[k]; k++)
}
if ((cbits(c = getch())) == delim) {
c = BOXRULE | chbits; /*default box rule*/
- } else
+ } else
getch();
c |= ZBIT;
neg = 0;
static Tchar wbuf[] = { WORDSP, 0};
rchar = 0;
- if (x == tabch)
+ if (x == tabch)
rchar = tabc | chbits;
- else if (x == ldrch)
+ else if (x == ldrch)
rchar = dotc | chbits;
temp = npad = ws = 0;
savfc = fc;
if (pp > padptr + NPP - 1)
break;
goto s1;
- } else if (j == savfc)
+ } else if (j == savfc)
break;
else if (j == '\n') {
temp = j;
}
if (length)
jj = length | MOT;
- else
+ else
jj = getch0();
if (savepos > 0)
pushback(wbuf);
numtabp[HP].val += jj;
widthp = jj;
*fp++ = ii;
- if (fp > fbuf + FBUFSZ - 3)
+ if (fp > fbuf + FBUFSZ - 3)
break;
}
*fp++ = ii;
*fp = 0;
if (type == RTAB)
length -= ws;
- else
+ else
length -= ws / 2; /*CTAB*/
pushback(fbuf);
if ((j = width(rchar)) != 0 && length > 0) {
blob - ee09ed4a037ee431bd7e202d198194e0c8899b68
blob + e12a3a08cc127f5bb287bfdbef9f5102b8ce7f21
--- src/cmd/troff/ni.c
+++ src/cmd/troff/ni.c
void (*setfont)(int a);
void (*setps)(void);
void (*setwd)(void);
-
blob - b037bdda3d49d0c679a8f5d0ead5d6b8508903dc
blob + 0c77252470c32801fb46ebb5c13921a1df42f129
--- src/cmd/troff/t10.c
+++ src/cmd/troff/t10.c
/*
* troff10.c
- *
+ *
* typesetter interface
*/
j = -j;
if (isvmot(i))
lead += j;
- else
+ else
esc += j;
return(outsize);
}
if (sfbits(i) == oldbits) {
xfont = pfont;
xpts = ppts;
- } else
+ } else
xbits(i, 2);
if (k == XON) {
extern int xon;
}
if (iszbit(i)) {
if (cs)
- w = -j;
- else
+ w = -j;
+ else
w = 0;
z = 1;
}
blob - f930d8b1b7b7c08923c1766b5cf2c441bbf57afd
blob + 9cd831c9dd80d754e6e5b4b0d72a3b942d47d862
--- src/cmd/troff/t11.c
+++ src/cmd/troff/t11.c
chadd(s, Troffchar, Install);
break;
}
- /* else
+ /* else
just skip anything else */
skipline(fin);
}
}
fclose(fp);
return status;
-
+
}
int
blob - 4a2bd02483cc1f25c3b4a65d6bf8bf49d3506720
blob + 1e0dc968371a37da3e874c5e23ce60bf4c6cc571
--- src/cmd/troff/t6.c
+++ src/cmd/troff/t6.c
/*
* t6.c
- *
+ *
* width functions, sizes and fonts
*/
if (sfbits(j) == oldbits) {
xfont = pfont;
xpts = ppts;
- } else
+ } else
xbits(j, 0);
if (i < nchnames + ALPHABET && widcache[i].fontpts == (xfont<<8) + xpts && !setwdf)
k = widcache[i].width;
if (setwdf)
numtabp[CT].val |= fp->wp[n].kern;
} else if (n == -2) { /* \N with default width */
-
+
k = fp->defaultwidth;
} else { /* not on current font */
nocache = 1;
if (cs = cstab[xfont]) {
nocache = 1;
if (ccs = ccstab[xfont])
- x = ccs;
- else
+ x = ccs;
+ else
x = xpts;
cs = (cs * EMPTS(x)) / 36;
}
return j | chbits;
} else
return chadd(temp, Troffchar, Install) | chbits; /* add name even if haven't seen it */
-
+
#endif /*UNICODE*/
}
if (a)
i = getrq();
- else
+ else
i = getsn();
if (!i || i == 'P') {
j = font1;
k = -k;
base -= k;
emsz = 0;
- } else
+ } else
continue;
if (base < numtabp[SB].val)
numtabp[SB].val = base;
*pbp++ = k;
j = LIG_FF;
}
- } else
+ } else
j = LIG_FF;
} else {
*pbp++ = j;
if (i <= 0 || i > nfonts)
ERROR "fp: bad font position %d", i WARN;
else if (skip() || !(j = getrq()))
- ERROR "fp: no font name" WARN;
+ ERROR "fp: no font name" WARN;
else if (skip() || !getname())
setfp(i, j, (char*) 0, 1);
else /* 3rd argument = filename */
ptfont();
}
if (pos == smnt) {
- smnt = 0;
- sbold = 0;
+ smnt = 0;
+ sbold = 0;
}
fontlab[pos] = f;
if (smnt == 0 && fonts[pos].specfont)
if (skip() || !(i = getrq()) || (j = findft(i)) == -1) {
if (k)
goto bd1;
- else
+ else
return;
}
if (j == smnt) {
i = inumb(&lss);
if (nonumb)
i = lss1;
- if (i < VERT)
+ if (i < VERT)
i = VERT;
lss1 = lss;
lss = i;
blob - 25c9270cc6e3921dc92420dd79910037b942cba4
blob + 4e6a4976f0750b12074fd22104acac59926ae65b
--- src/cmd/troff/tdef.h
+++ src/cmd/troff/tdef.h
/* 0 and 040 don't have any graphic or other function.
/* The few that do have a purpose (e.g., \n, \b, \t, ...
/* are avoided by the ad hoc choices here.
-/* See ifilt[] in n1.c for others -- 1, 2, 3, 5, 6, 7, 010, 011, 012
+/* See ifilt[] in n1.c for others -- 1, 2, 3, 5, 6, 7, 010, 011, 012
*/
#define LEADER 001
/* 128 for parochial USA 7-bit ascii, */
/* 256 for "European" mode with e.g., Latin-1 */
- /* NCHARS must be greater than
+ /* NCHARS must be greater than
ALPHABET (ascii stuff) + total number of distinct char names
from all fonts that will be run in this job (including
unnamed ones and \N's)
error. In this version, the array is represented by a list of blocks,
pointed to by blist[].bp. Each block is of size BLK Tchars, and BLK
MUST be a power of 2 for the macros below to work.
-
+
The blocks associated with a particular string or macro are chained
together in the array blist[]. Each blist[i].nextoff contains the
Offset associated with the next block in the giant array, or -1 if
this is the last block in the chain. If .nextoff is 0, the block is
free.
-
+
To find the right index in blist for an Offset, divide by BLK.
*/
blob - 9f43946c10c6b0d8f9691fe04879a2f16599b295
blob + d3e30db521cb7f39d691adb9b13ccbfd5c96fe89
--- src/cmd/troff2html/troff2html.c
+++ src/cmd/troff2html/troff2html.c
{
emitul(r | attr, 0);
/*
- * Close man page references early, so that
+ * Close man page references early, so that
* .IR proof (1),
* doesn't make the comma part of the link.
*/
blob - 88fb9286481994a367b2327aaba04546fc2be554
blob + 152975e02081e64db25beb7063f3a17e90a42231
--- src/cmd/uniq.c
+++ src/cmd/uniq.c
while(nf++ < fields) {
while(*s == ' ' || *s == '\t')
s++;
- while(!(*s == ' ' || *s == '\t' || *s == 0) )
+ while(!(*s == ' ' || *s == '\t' || *s == 0) )
s++;
}
- while(nl++ < letters && *s != 0)
+ while(nl++ < letters && *s != 0)
s++;
return s;
}
blob - 0be7aa8ead04aef4ce56aa048fe08012a5ff5906
blob + 001a5aa3b0b5976d0ca7aec05d21ec880eb3984e
--- src/cmd/unutf.c
+++ src/cmd/unutf.c
/*
- * stupid little program to pipe unicode chars through
+ * stupid little program to pipe unicode chars through
* when converting to non-utf compilers.
*/
#include <u.h>
blob - 6be960ff67b826cfc544f9e8ef2c24af9df76c00
blob + 3679b3184f65d3a5c59ccc5a77418499b8091223
--- src/cmd/upas/bayes/addhash.c
+++ src/cmd/upas/bayes/addhash.c
if(fd < 0)
sysfatal("could not open %s: %r\n", out);
}
-
+
Binit(&bout, fd, OWRITE);
Bwritehash(&bout, &hash);
Bterm(&bout);
exits(0);
}
-
blob - ce4dc58a6a770734cacb6e28bcd8a71789027108
blob + b038343b2b630f05bd149d111091a00fb99c37d1
--- src/cmd/upas/bayes/dfa.c
+++ src/cmd/upas/bayes/dfa.c
}
/*
- * Compute the list of important characters.
+ * Compute the list of important characters.
* Other characters behave like the ones that surround them.
*/
static void
dp = dregcvt(p);
print("=== dfa\n");
dump(dp);
-
+
for(i=2; i<argc; i++)
print("match %d\n", dregexec(dp, argv[i], 0));
exits(0);
blob - 28c43dbc45aba64f0ec903cc4170e7e93d17c253
blob + 429f04e586684cf3eaa36be8a4dbe474e4f0955d
--- src/cmd/upas/bayes/dfa.h
+++ src/cmd/upas/bayes/dfa.h
int dregexec(Dreprog*, char*, int);
Dreprog* Breaddfa(Biobuf *b);
void Bprintdfa(Biobuf*, Dreprog*);
-
blob - 404538c1b606c564a7a21d72715cd9afaa053cd6
blob + c753fb2c8d8d5e093113e61a38713f51ed2a76bd
--- src/cmd/upas/bayes/dump.c
+++ src/cmd/upas/bayes/dump.c
dp = dregcvt(p);
print("=== dfa\n");
dump(dp);
-
+
for(i=2; i<argc; i++)
print("match %d\n", dregexec(dp, argv[i], 1));
exits(0);
blob - 999ba50c33c810ecda849667f45b0dc487a76630
blob + 2e80202af49afcf3697e38847149943bae672227
--- src/cmd/upas/bayes/msgclass.c
+++ src/cmd/upas/bayes/msgclass.c
close(fd);
atexit(killtickle);
}
-
blob - 122e0c64606aa22a1e02bca5c3c83d8abbba46d0
blob + fe14796177f89faf7755a06c62131b8eff4e1f19
--- src/cmd/upas/bayes/msgtok.c
+++ src/cmd/upas/bayes/msgtok.c
/*
* RFC822 message tokenizer (really feature generator) for spam filter.
- *
+ *
* See Paul Graham's musings on spam filtering for theory.
*/
p[i] += 'a' - 'A';
*/
if(tag){
- i = strlen(tag);
+ i = strlen(tag);
memmove(buf, tag, i);
memmove(buf+i, p, m[1]);
buf[i+m[1]] = 0;
return 0;
}
return -1;
-}
-
+}
blob - 8afaf2157fe1ece7320b323f44d100f994879910
blob + 96fa2e6e7d4dadbf31ab2513ba9c0b4cfab8c2aa
--- src/cmd/upas/bayes/regcomp.c
+++ src/cmd/upas/bayes/regcomp.c
while(*s)
*cp++ = *s++;
*cp++ = c;
- *cp = '\0';
+ *cp = '\0';
rcerror(buf);
}
blob - cddf034a1c58f60da33d2a4b4b46612701cf7c94
blob + d5f14cb51e2bdcaa9a91d4571ae9ca203db4e267
--- src/cmd/upas/bayes/regen.c
+++ src/cmd/upas/bayes/regen.c
* Regular expression for matching.
*/
-char *ignore[] =
+char *ignore[] =
{
/* HTML that isn't A, IMG, or FONT */
/* Must have a space somewhere to avoid catching <email@address> */
static char buf[16384], *s;
re[0] = dregcomp("^From ");
-
+
s = buf;
for(i=0; i<nelem(keywords); i++){
if(i != 0)
Bprintdfa(&b, re[2]);
exits(0);
}
-
-
\ No newline at end of file
blob - 7a26dea1b11c0de0e2a9c5ff2653e9bbbd23cef8
blob + 0fae80f8da9acb8e037818b1a2177217e2e15fb1
--- src/cmd/upas/common/common.h
+++ src/cmd/upas/common/common.h
Elemlen= 28,
Errlen= 128,
Pathlen= 256,
-
+
RetryCode = 2
};
extern int proc_wait(process*);
extern int proc_free(process*);
extern int proc_kill(process*);
-
-
blob - 8d1e7a0248cff4d9e99e4cc639bc6a7eccba9df1
blob + 97ce9cc22ea624a4b132fdcb519789d95c424e5b
--- src/cmd/upas/common/config.c
+++ src/cmd/upas/common/config.c
upasconfig(void)
{
static int did;
-
+
if(did)
return;
did = 1;
blob - b439cfde1180fe496b3c50ba8de6c946203d0a1e
blob + 2ed19494cba02bfa1bdd05f21d374891a28ba025
--- src/cmd/upas/common/libsys.c
+++ src/cmd/upas/common/libsys.c
free(l);
return 0;
}
-
+
/* fork process to keep lock alive */
switch(l->pid = rfork(RFPROC)){
default:
for(p=h->h_aliases; *p; p++)
;
-
+
namev = malloc((2+p-h->h_aliases)*sizeof namev[0]);
if(namev == 0)
return 0;
{
char *dir;
String *s;
-
+
if (dot || *path=='/' || strncmp(path, "./", 2) == 0
|| strncmp(path, "../", 3) == 0) {
to = s_append(to, path);
{
char *raddr;
NetConnInfo *nci;
-
+
if((nci = getnetconninfo(dir, fd)) == nil)
return nil;
raddr = strdup(nci->raddr);
blob - 56725a88715877d651cf97390c7002fc3be2d1e5
blob + f593d551f7781998faa0369774209bfa18bec4b8
--- src/cmd/upas/common/process.c
+++ src/cmd/upas/common/process.c
return 0;
}
rv->fp = &rv->bb;
- rv->fd = pfd[0];
+ rv->fd = pfd[0];
return rv;
}
blob - 1913c6ded4dc8ef2c19043a4bb0fbcc4598e317f
blob + 51a50e98694e56d65a3b6c944977e1c977400cd1
--- src/cmd/upas/filterkit/list.c
+++ src/cmd/upas/filterkit/list.c
s_free(s);
}
close(fd);
- return nil;
+ return nil;
}
void
blob - 9aadc1ab188ecd8a280acc8fbbc1a7f59e682bae
blob + 6ab9ed958f9f2f52acd2deae19cd988b62d0fd5e
--- src/cmd/upas/filterkit/readaddrs.c
+++ src/cmd/upas/filterkit/readaddrs.c
int intok = 0, inquote = 0;
if(max <= 0)
- return 0;
+ return 0;
for(na=0; ;str++)
switch(*str) {
case ' ':
blob - 4e91e261a9159cbc4ad6c6eb1ead6835afb61042
blob + 86564c2b62a6e4da4e0d9295d67dfd82ca633e19
--- src/cmd/upas/filterkit/token.c
+++ src/cmd/upas/filterkit/token.c
uchar digest[SHA1dlen];
char token[64];
String *s;
-
+
now = ctime(thetime);
memset(now+11, ':', 8);
hmac_sha1((uchar*)now, strlen(now), (uchar*)key, strlen(key), digest, nil);
if(i < 0)
return "no match";
buf[i] = 0;
-
+
now = time(0);
for(i = 0; i < 14; i++){
blob - 14208ed6af55b68cd4f85c6fb411cab887f974e0
blob + 6264822dcd0a0e7146078f5dde0f734fbabe6dbb
--- src/cmd/upas/fs/dat.h
+++ src/cmd/upas/fs/dat.h
void hfree(ulong, char*);
ulong msgallocd, msgfreed;
-
blob - 9fa433d8cd2055aafb47e0570394ba7be8047c93
blob + dc6ff3ba6f7ccf3308d5819f1284af496b492717
--- src/cmd/upas/fs/fs.c
+++ src/cmd/upas/fs/fs.c
for(i = 0; i < thdr.nwname; i++){
rv = dowalk(f, thdr.wname[i]);
if(rv != nil){
- if(nf != nil)
+ if(nf != nil)
rclunk(nf);
break;
}
cnt -= m;
}
pos += m;
-
+
for(mb = mbl; mb != nil; mb = mb->next){
mkstat(&d, mb, nil, Qmbox);
m = convD2M(&d, &buf[n], blen-n);
} else {
msg = f->mb->root->part;
pos = 0;
- }
+ }
for(; cnt > 0 && msg != nil; msg = msg->next){
/* act like deleted files aren't there */
Ignorance *ignorance;
/*
- * read the file of headers to ignore
+ * read the file of headers to ignore
*/
void
readignore(void)
blob - 48119fa77c2db201cc34634dc92b07288b8be315
blob + 7fcc51b5ba9faf69c20e1d759151fc3fffb47f91
--- src/cmd/upas/fs/imap4.c
+++ src/cmd/upas/fs/imap4.c
int i;
if(imap->data == nil){
- imap->base = emalloc(n+1);
+ imap->base = emalloc(n+1);
imap->data = imap->base;
imap->size = n+1;
}
ep = p+Blinelen(&imap->bin);
while(ep > p && (ep[-1]=='\n' || ep[-1]=='\r'))
*--ep = '\0';
-
+
if(imap->debug)
fprint(2, "<- %s\n", p);
strupr(p);
if(*p==' ')
p++;
verb = p;
-
+
if(p = strchr(verb, ' '))
p++;
else
/* <3031 bytes of data> */
/* ) */
if(strstr(p, "RFC822.SIZE") && strstr(p, "BODY[]")){
- if((q = strchr(p, '{'))
+ if((q = strchr(p, '{'))
&& (n=strtol(q+1, &en, 0), *en=='}')){
if(imap->data == nil || n >= imap->size)
imapgrow(imap, n);
/* ) */
/* * 1 FETCH (UID 1 RFC822.HEADER "data") */
if(strstr(p, "RFC822.HEADER") || strstr(p, "RFC822.TEXT")){
- if((q = strchr(p, '{'))
+ if((q = strchr(p, '{'))
&& (n=strtol(q+1, &en, 0), *en=='}')){
if(imap->data == nil || n >= imap->size)
imapgrow(imap, n);
blob - 2f4837473d6f2f904b725628ee9055b411b3638f
blob + b77306d6cd55ec923a5f68cdded10d9d3a1b6668
--- src/cmd/upas/fs/mbox.c
+++ src/cmd/upas/fs/mbox.c
p = skipwhite(p);
p = getstring(p, m->type, 1);
-
+
while(*p){
if(isattribute(&p, "boundary")){
s = s_new();
} else if(isattribute(&p, "charset")){
p = getstring(p, s_reset(m->charset), 0);
}
-
+
p = skiptosemi(p);
}
}
*q = '\0';
return s_copy(p);
}
-
blob - da8021dd29ba386f5ae597364b14009140380192
blob + d41d2b482191c7cbc4314a3ccd9b8585ee2a6e84
--- src/cmd/upas/fs/pop3.c
+++ src/cmd/upas/fs/pop3.c
(Qid){PATH(mb->id, Qmbox), mb->vers, QTDIR}, nil, mb);
}
- return nil;
+ return nil;
}
/* */
return nil;
}
-
blob - bcf0bcee0ca1a9c00015d7141432f0cdf50ecbdd
blob + 09a7914d427da569373c9f0414275c77743e705d
--- src/cmd/upas/fs/strtotm.c
+++ src/cmd/upas/fs/strtotm.c
static char* months[] = {
"jan", "feb", "mar", "apr",
- "may", "jun", "jul", "aug",
+ "may", "jun", "jul", "aug",
"sep", "oct", "nov", "dec"
};
continue;
/* look for time zone [A-Z][A-Z]T */
- if(q-p==3 && 'A' <= p[0] && p[0] <= 'Z'
+ if(q-p==3 && 'A' <= p[0] && p[0] <= 'Z'
&& 'A' <= p[1] && p[1] <= 'Z' && p[2] == 'T'){
strecpy(tm.zone, tm.zone+4, p);
continue;
blob - 3d24012efa7eaa37b814786c7b6d213e2ad6838e
blob + 30c15b312bb07204f6f4dfb5809ee5f41a029e9d
--- src/cmd/upas/fs/tester.c
+++ src/cmd/upas/fs/tester.c
info(indent+1, i++, nm);
}
}
-
+
void
main(int argc, char **argv)
{
blob - 8ebd3957a53dca237d23f98dd825c31df776e9aa
blob + e83328e94558bfc9ab7e4eb92d374a3e3349951a
--- src/cmd/upas/marshal/marshal.c
+++ src/cmd/upas/marshal/marshal.c
close(fd);
threadexitsall(waitforsubprocs());
}
-
+
if(Binit(&out, fd, OWRITE) < 0)
fatal("can't Binit 1: %r");
free(f);
return;
}
-
+
/* if it's not already mime encoded ... */
if(strcmp(a->type, "text/plain") != 0)
Bprint(out, "Content-Type: %s\n", a->type);
mopen(char *file, int mode)
{
int fd;
-
+
if((fd = open(file, mode)) >= 0)
return fd;
if(strncmp(file, "Mail/", 5) == 0 && mountmail() >= 0 && (fd = fsopenfd(mailfs, file+5, mode)) >= 0)
a->type = "application/octet-stream"; /* safest default */
if(pipe(pfd) < 0)
return a;
-
+
xfd[0] = mopen(file, OREAD);
xfd[1] = pfd[0];
xfd[2] = dup(2, -1);
teeproc(void *v)
{
int *a;
-
+
a = v;
tee(a[0], a[1], a[2]);
write(a[2], "\n", 1);
if(pipe(pfd) < 0)
fatal("pipe: %r");
-
+
xfd[0] = pfd[0];
xfd[1] = dup(1, -1);
xfd[2] = dup(2, -1);
proccreate(teeproc, targ, STACK);
sfd = pfd[1];
}
-
+
return sfd;
}
addr->next = 0;
*al = addr;
al = &addr->next;
- }
+ }
if(a->addr == nil || a->addr->next == nil){
freealias(a);
continue;
type = Twords;
quoting = 0;
for(; *p && (quoting || (!ISWHITE(*p) && *p != '>' && *p != '<' && *p != ',')); p++) {
- if(*p == '"')
+ if(*p == '"')
quoting = !quoting;
if(*p == '\\') {
if(*(p+1) == '\0') {
*pp = p;
*tok = s_copyn(op, p-op);
return type;
-}
+}
/* expand local aliases in an RFC822 mail line */
/* add list of expanded addresses to to. */
nto = nil;
werrstr("rfc822 syntax error");
rfc822syntaxerror = 1;
- goto Break2;
+ goto Break2;
}
}
Break2:
fmtprint(fmt, "=%.2uX", (uchar)*p);
else
fmtrune(fmt, (uchar)*p);
- }
+ }
fmtprint(fmt, "?=");
return 0;
}
blob - 20cf239706faa1ceb05f4db5d9b1220c5412f6cc
blob + bf2cff5619b5a513abaac45627be8c3d56452e09
--- src/cmd/upas/misc/mail.c
+++ src/cmd/upas/misc/mail.c
perror (realprog);
exit (1);
}
-
blob - 307a49255d9be40263571c98a790872bf2875e21
blob + c389d6396e610cffb49a5106db005b1a6a007b7b
--- src/cmd/upas/ml/common.c
+++ src/cmd/upas/ml/common.c
fprint(pfd[1], "the word 'remove' in the subject or body.\n");
}
close(pfd[1]);
-
+
/* wait for mailer to end */
while(w = wait()){
if(w->msg != nil && w->msg[0])
blob - 8dad05179af33e80574992f324d28b0613dd6d51
blob + a135b0511532b365a1b565dd4a504437ed82a595
--- src/cmd/upas/ml/ml.c
+++ src/cmd/upas/ml/ml.c
if(s_read_line(&in, firstline) == nil)
sysfatal("reading input: %r");
- /* read up to the first 128k of the message. more is redculous.
+ /* read up to the first 128k of the message. more is redculous.
Not if word documents are distributed. Upped it to 2MB (pb) */
if(s_read(&in, msg, 2*1024*1024) <= 0)
sysfatal("reading input: %r");
blob - ef0f731c8add5f73f376b01d9851435773c90be4
blob + 6acd73e4e4661fa43fc8f38cf5b321524c5a5c77
--- src/cmd/upas/ned/nedmail.c
+++ src/cmd/upas/ned/nedmail.c
if (n == 1)
return "";
- return "s";
+ return "s";
}
void
int i, nf, inquote;
char **f, *s;
Fmt fmt;
-
+
inquote = 0;
nf = 2;
for(s=t; *s; s++){
String *path;
char *f[30], *s, *t;
int i, nf;
-
+
m = mallocz(sizeof(Message), 1);
if(m == nil)
return nil;
if(t == nil)
continue;
*t++ = 0;
-
+
if(strcmp(s, "from") == 0)
m->from = mkaddrs(t);
else if(strcmp(s, "to") == 0)
{
int i, n, highest, newmsgs;
CFid *fd;
-
+
Dir *d;
Message *first, *last, *m;
goto number;
}
*mp = unspec;
- break;
+ break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
n = strtoul(p, pp, 10);
free(prog);
}
} else {
-
+
/* parse an address */
s = e = nil;
err = parseaddr(&p, first, cur, cur, &s);
err = parseaddr(&p, first, cur, last, &e);
if(err != nil)
return err;
-
+
/* select all messages in the range */
for(; s != nil; s = s->next){
*l = s;
}
cmd->f = cmdtab[i].f;
}
- return nil;
+ return nil;
}
/* inefficient read from standard input */
Bprint(&out, "\n!--- using plumber to display message of type %s\n", m->type);
else
Bprint(&out, "\n!--- cannot display messages of type %s\n", m->type);
-
+
return m;
}
ycmd(Cmd *x, Message *m)
{
USED(x);
-
+
doflush = 1;
return icmd(nil, m);
int intok = 0, inquote = 0;
if(max <= 0)
- return 0;
+ return 0;
for(na=0; ;str++)
switch(*str) {
case ' ':
fd = open("/mail/fs/ctl", ORDWR);
if(fd < 0)
sysfatal("can't open /mail/fs/ctl: %r");
-
+
path = s_new();
-
+
/* get an absolute path to the mail box */
if(strncmp(file, "./", 2) == 0){
/* resolve path here since upas/fs doesn't know */
} else {
mboxpath(file, user, path, 0);
}
-
+
/* make up a handle to use when talking to fs */
p = strrchr(file, '/');
if(p == nil){
blob - 202111f8e860c5c49904f5b355b83b5d3a370347
blob + a3525f0f378750b575d53c615a36f967578ce791
--- src/cmd/upas/nfs/box.c
+++ src/cmd/upas/nfs/box.c
subbox(Box *b, char *elem)
{
int i;
-
+
for(i=0; i<b->nsub; i++)
if(b->sub[i] && strcmp(b->sub[i]->elem, elem) == 0)
return b->sub[i];
boxbyid(uint id)
{
int i;
-
+
/* LATER: replace with binary search */
for(i=0; i<nboxes; i++)
if(boxes[i] && boxes[i]->id == id)
{
char *p;
Box *b, *bb;
-
+
if((b = boxbyname(name)) != nil)
return b;
-
+
b = emalloc(sizeof *b);
b->id = ++boxid;
b->time = time(0);
boxfree(Box *b)
{
int i;
-
+
if(b == nil)
return;
for(i=0; i<b->nmsg; i++)
partcreate(Msg *m, Part *pp)
{
Part *p;
-
+
if(m->npart%PartChunk == 0)
m->part = erealloc(m->part, (m->npart+PartChunk)*sizeof m->part[0]);
p = emalloc(sizeof *p);
p->msg = m;
- p->ix = m->npart;
+ p->ix = m->npart;
m->part[m->npart++] = p;
if(pp){
if(pp->nsub%PartSubChunk == 0)
partfree(Part *p)
{
int i;
-
+
if(p == nil)
return;
for(i=0; i<p->nsub; i++)
msgfree(Msg *m)
{
int i;
-
+
if(m == nil)
return;
for(i=0; i<m->npart; i++)
Plumbattr a[10];
char buf[256], date[40];
int ai;
-
+
if(m == nil || m->npart < 1 || m->part[0]->hdr == nil)
return;
if(m->box && strcmp(m->box->name, "mbox") != 0)
ai = 0;
a[ai].name = "filetype";
a[ai].value = "mail";
-
+
a[++ai].name = "mailtype";
a[ai].value = delete?"delete":"new";
a[ai-1].next = &a[ai];
a[ai].value = m->part[0]->hdr->digest;
a[ai-1].next = &a[ai];
}
-
+
strcpy(date, ctime(m->date));
date[strlen(date)-1] = 0; /* newline */
a[++ai].name = "date";
a[ai].value = date;
a[ai-1].next = &a[ai];
-
+
a[ai].next = nil;
-
+
p.attr = a;
#ifdef PLAN9PORT
snprint(buf, sizeof buf, "Mail/%s/%ud", m->box->name, m->id);
#endif
p.ndata = strlen(buf);
p.data = buf;
-
+
if(fd < 0)
fd = plumbopen("send", OWRITE);
if(fd < 0)
msgcreate(Box *box)
{
Msg *m;
-
+
m = emalloc(sizeof *m);
m->box = box;
partcreate(m, nil);
rootbox->name = estrdup("");
rootbox->time = time(0);
}
-
blob - 9ca3b8f9e18e0d67eda4a7fab1ed625e34a27a04
blob + bbb3851e2a256dcdb2866a834271c3981f0adeb4
--- src/cmd/upas/nfs/box.h
+++ src/cmd/upas/nfs/box.h
Msg** msg; /* array of messages (can have nils) */
uint nmsg;
-
+
char* imapname; /* name on IMAP server */
u32int validity; /* IMAP validity number */
uint uidnext; /* IMAP expected next uid */
uint flags; /* FlagDeleted etc. */
uint date; /* smtp envelope date */
uint size;
-
+
Part** part; /* message subparts - part[0] is root */
uint npart;
};
extern uint nboxes;
extern Box* rootbox;
-
blob - 3f8c4c681464eb371b636edb9dc112da3887f24a
blob + 0ad78ec4b31865d2f730b4fdc2748db21f85ecc2
--- src/cmd/upas/nfs/decode.c
+++ src/cmd/upas/nfs/decode.c
{
char *p, *ep;
uchar *eout, *out0;
-
+
out0 = out;
eout = out+lim;
for(p=in, ep=in+n; p<ep && out<eout; ){
*len = l;
t[l] = 0;
return t;
-
+
case Base64:
l = strlen(s)+1;
t = emalloc(l);
twriter(void *v)
{
Writeargs *w;
-
+
w = v;
write(w->fd, w->s, strlen(w->s));
close(w->fd);
int len;
Rune r;
Fmt fmt;
-
+
if(s == nil)
return nil;
if(strstr(s, "=?") == nil)
return s;
-
+
fmtstrinit(&fmt);
for(p=s; *p; ){
/* =?charset?e?text?= */
}
#ifdef TEST
-char *test[] =
+char *test[] =
{
"hello world",
"hello =?iso-8859-1?q?this is some text?=",
threadmain(int argc, char **argv)
{
int i;
-
+
for(i=0; i<nelem(test); i++)
print("%s\n\t%s\n", test[i], unrfc2047(estrdup(test[i])));
threadexitsall(0);
blob - 69cd6b5a944133a7ae05dbec3b34e4cb4044c373
blob + 361a3561d1e24b6b5242ddf2ad77e25fbc946c7f
--- src/cmd/upas/nfs/fs.c
+++ src/cmd/upas/nfs/fs.c
/*
* Mail file system.
- *
+ *
* Serve the bulk of requests out of memory, so they can
- * be in the main loop (will never see their flushes).
+ * be in the main loop (will never see their flushes).
* Some requests do block and they get handled in
* separate threads. They're all okay to give up on
* early, though, so we just respond saying interrupted
digest
disposition
filename
-
+
ctl messages
fetch mail on demand
Qbcc,
Qinreplyto,
Qmessageid,
-
+
/* part data - same order as stuct Part */
Qtype,
Qidstr,
Qrawheader,
Qrawbody,
Qmimeheader,
-
+
/* part numbers - same order as struct Part */
Qsize,
Qlines,
Qrawunix,
Qunixdate,
Qunixheader,
-
+
Qfile0 = Qbody,
Qnfile = Qunixheader+1-Qfile0
};
responderror(Req *r)
{
char e[ERRMAX];
-
+
rerrstr(e, sizeof e);
respond(r, e);
}
qid(int ctl, Box *box, Msg *msg, Part *part)
{
Qid q;
-
+
q.type = 0;
if(ctl == Qroot || ctl == Qbox || ctl == Qmsg)
q.type = QTDIR;
{
*msg = nil;
*part = nil;
-
+
*box = boxbyid(qboxid(q));
if(*box){
*msg = msgbyid(*box, qmsgid(q));
nameoftype(int t)
{
int i;
-
+
for(i=0; i<nelem(typenames); i++)
if(typenames[i].type == t)
return typenames[i].name;
typeofname(char *name)
{
int i;
-
+
for(i=0; i<nelem(typenames); i++)
if(strcmp(typenames[i].name, name) == 0)
return typenames[i].type;
Part *p, *part;
USED(arg);
-
+
switch(type = parseqid(fid->qid, &box, &msg, &part)){
case Qroot:
if(strcmp(name, "..") == 0)
char **f;
int i, nf, inquote;
char *p, *sep;
-
+
if(addrs == nil)
return;
addrs = estrdup(addrs);
}
static Qid ZQ;
-
+
static int
filedata(int type, Box *box, Msg *msg, Part *part, char **pp, int *len, int *freeme, int force, Qid q)
{
}
*pp = ((char**)&part->hdr->date)[type-Qdate];
return 0;
-
+
case Qunixdate:
strcpy(buf, ctime(msg->date));
*pp = buf;
if(part->hdr->from==nil
|| (part->hdr->sender && strcmp(part->hdr->sender, part->hdr->from) != 0))
addaddrs(&fmt, "Sender", part->hdr->sender);
- if(part->hdr->from==nil
+ if(part->hdr->from==nil
|| (part->hdr->replyto && strcmp(part->hdr->replyto, part->hdr->from) != 0))
addaddrs(&fmt, "Reply-To", part->hdr->replyto);
fmtprint(&fmt, "Subject: %s\n", part->hdr->subject);
case Qsearch:
d->mode = 0666;
break;
-
+
case Qflags:
d->mode = 0666;
goto msgfile;
}
return 0;
}
-
+
static void
fsstat(Req *r)
{
Box *box;
Msg *msg;
Part *part;
-
+
type = parseqid(r->fid->qid, &box, &msg, &part);
if(filldir(&r->d, type, box, msg, part) < 0)
responderror(r);
rootgen(int i, Dir *d, void *aux)
{
USED(aux);
-
+
if(i == 0)
return filldir(d, Qctl, nil, nil, nil);
i--;
}
static int msgdir[] = {
- Qtype,
- Qbody, Qbcc, Qcc, Qdate, Qflags, Qfrom, Qheader, Qinfo,
- Qinreplyto, Qlines, Qmimeheader, Qmessageid,
+ Qtype,
+ Qbody, Qbcc, Qcc, Qdate, Qflags, Qfrom, Qheader, Qinfo,
+ Qinreplyto, Qlines, Qmimeheader, Qmessageid,
Qraw, Qrawunix, Qrawbody, Qrawheader,
Qreplyto, Qsender, Qsubject, Qto,
Qunixdate, Qunixheader
};
static int mimemsgdir[] = {
- Qtype,
- Qbody, Qbcc, Qcc, Qdate, Qfrom, Qheader, Qinfo,
- Qinreplyto, Qlines, Qmimeheader, Qmessageid,
+ Qtype,
+ Qbody, Qbcc, Qcc, Qdate, Qfrom, Qheader, Qinfo,
+ Qinreplyto, Qlines, Qmimeheader, Qmessageid,
Qraw, Qrawunix, Qrawbody, Qrawheader,
Qreplyto, Qsender, Qsubject, Qto
};
Qmimeheader,
Qraw
};
-
+
int
msggen(int i, Dir *d, void *aux)
{
Box *box;
Msg *msg;
Part *part;
-
+
part = aux;
msg = part->msg;
box = msg->box;
Box *box;
Msg *msg;
Part *part;
-
+
switch(type = parseqid(r->fid->qid, &box, &msg, &part)){
case Qroot:
dirread9p(r, rootgen, nil);
dirread9p(r, msggen, part);
respond(r, nil);
return;
-
+
case Qctl:
case Qboxctl:
respond(r, Egreg);
{
int i, nm;
Msg **m;
-
+
m = emalloc(nf*sizeof m[0]);
nm = 0;
for(i=0; i<nf; i++)
respond(r, nil);
free(m);
break;
-
+
case CMjunk:
flag = FlagJunk;
goto flagit;
fsthread(void *v)
{
Req *r;
-
+
r = v;
switch(r->ifcall.type){
case Tread:
fs.write = fssend;
fs.stat = fssend;
fs.destroyfid = fsdestroyfid;
-
+
rootqid = qid(Qroot, nil, nil, nil);
-
+
fsreqchan = chancreate(sizeof(void*), 0);
mailthread(fsrecv, nil);
}
-
blob - ef76487b517b1732cb53ce8928d54ba595fa7dcb
blob + 5249e2e788518c1594bffd0c31bd42f0209bb3c0
--- src/cmd/upas/nfs/imap.c
+++ src/cmd/upas/nfs/imap.c
static struct {
char *name;
int flag;
-} flagstab[] =
+} flagstab[] =
{
"Junk", FlagJunk,
"NonJunk", FlagNonJunk,
z->fd = -1;
z->autoreconnect = 0;
z->io = ioproc();
-
+
qlock(&z->lk);
if(imapreconnect(z) < 0){
free(z);
return nil;
}
-
+
z->r.l = &z->rlk;
z->autoreconnect = 1;
qunlock(&z->lk);
-
+
proccreate(imaptimerproc, z, STACK);
mailthread(imaprefreshthread, z);
-
+
return z;
}
{
int i;
Box **r, **w, **e;
-
+
for(i=0; i<nboxes; i++){
boxes[i]->mark = 1;
boxes[i]->exists = 0;
{
int i;
Msg **r, **w, **e;
-
+
if(b == nil)
return 0;
-
+
for(i=0; i<b->nmsg; i++)
b->msg[i]->imapid = 0;
if(imapcmd(z, b, "UID FETCH 1:* FLAGS") < 0)
imaptimerproc(void *v)
{
Imap *z;
-
+
z = v;
for(;;){
sleep(60*1000);
imaprefreshthread(void *v)
{
Imap *z;
-
+
z = v;
for(;;){
qlock(z->r.l);
rsleep(&z->r);
qunlock(z->r.l);
-
+
qlock(&z->lk);
if(z->inbox)
checkbox(z, z->inbox);
Fmt f;
int len;
Sx *sx;
-
+
if(canqlock(&z->lk))
abort();
{
va_list arg;
Sx *sx;
-
+
va_start(arg, fmt);
sx = imapvcmdsx0(z, fmt, arg, 1);
va_end(arg);
{
int tries;
Sx *sx;
-
+
tries = 0;
z->nextbox = b;
imapwaitsx(Imap *z)
{
Sx *sx;
-
+
while((sx = zBrdsx(z)) != nil){
if(chattyimap)
fprint(2, "<| %#$\n", sx);
fetch1(Imap *z, Part *p, char *s)
{
qlock(&z->lk);
- imapcmd(z, p->msg->box, "UID FETCH %d BODY[%s]",
+ imapcmd(z, p->msg->box, "UID FETCH %d BODY[%s]",
p->msg->imapuid, bodyname(p, s));
qunlock(&z->lk);
}
int i, r;
char *cmd;
Fmt fmt;
-
+
if(nm == 0)
return 0;
}
fmtprint(&fmt, " %s", after);
cmd = fmtstrflush(&fmt);
-
+
r = 0;
if(imapcmd(z, box, "%s", cmd) < 0)
r = -1;
{
int rv;
char *name, *p;
-
+
if(nm == 0)
return 0;
imapremovelist(Imap *z, Msg **m, uint nm)
{
int rv;
-
+
if(nm == 0)
return 0;
char *mod, *s, *sep;
int i, rv;
Fmt fmt;
-
+
if(op > 0)
mod = "+";
else if(op == 0)
}
fmtprint(&fmt, ")");
s = fmtstrflush(&fmt);
-
+
qlock(&z->lk);
rv = imaplistcmd(z, m[0]->box, "UID STORE", m, nm, s);
qunlock(&z->lk);
{
char *server;
int mode;
-
+
server = va_arg(*arg, char*);
mode = va_arg(*arg, int);
return imapdial(server, mode);
{
Biobuf *b;
Sx **sx;
-
+
b = va_arg(*arg, Biobuf*);
sx = va_arg(*arg, Sx**);
*sx = Brdsx(b);
int fd[3];
char *tmp;
char *fpath;
-
+
switch(mode){
default:
case Unencrypted:
return dial(netmkaddr(server, "tcp", "143"), nil, nil, nil);
-
+
case Starttls:
werrstr("starttls not supported");
return -1;
free(tmp);
close(p[0]);
return p[1];
-
+
case Cmd:
if(pipe(p) < 0)
return -1;
sxmatch(Sx *sx, char *fmt)
{
int i;
-
+
for(i=0; fmt[i]; i++){
if(fmt[i] == '*')
fmt--; /* like i-- but better */
isatom(Sx *v, char *name)
{
int n;
-
+
if(v == nil || v->type != SxAtom)
return 0;
n = strlen(name);
static int
isnil(Sx *v)
{
- return v == nil ||
+ return v == nil ||
(v->type==SxList && v->nsx == 0) ||
(v->type==SxAtom && strcmp(v->data, "NIL") == 0);
}
parseflags(Sx *v)
{
int f, i, j;
-
+
if(v->type != SxList){
warn("malformed flags: %$", v);
return 0;
}
return f;
}
-
+
static char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
static int
parsemon(char *s)
{
int i;
-
+
for(i=0; months[i]; i+=3)
if(memcmp(s, months+i, 3) == 0)
return i/3;
uint t;
int delta;
char *p;
-
+
if(v->type != SxString || !stringmatch("01-Aaa-1111 01:11:11 +1111", v->data)){
bad:
warn("bad date: %$", v);
return 0;
}
-
+
/* cannot use atoi because 09 is malformed octal! */
memset(&tm, 0, sizeof tm);
p = v->data;
delta = ((p[22]-'0')*10+p[23]-'0')*3600 + ((p[24]-'0')*10+p[25]-'0')*60;
if(p[21] == '-')
delta = -delta;
-
+
t -= delta;
return t;
}
Hdr *hdr;
uchar digest[16];
DigestState ds;
-
+
if(v->type != SxList || !sxmatch(v, "SSLLLLLLSS")){
warn("bad envelope: %$", v);
return nil;
hdr->bcc = copyaddrs(v->sx[7]);
hdr->inreplyto = unrfc2047(nstring(v->sx[8]));
hdr->messageid = unrfc2047(nstring(v->sx[9]));
-
+
memset(&ds, 0, sizeof ds);
hash(&ds, "date", hdr->date);
hash(&ds, "subject", hdr->subject);
strlwr(char *s)
{
char *t;
-
+
if(s == nil)
return;
for(t=s; *t; t++)
nocr(char *s)
{
char *r, *w;
-
+
if(s == nil)
return;
for(r=w=s; *r; r++)
{
char *p, *t, *w, *last;
int n;
-
+
n = 0;
for(p=s; (p=strstr(p, a)) != nil; p+=strlen(a))
n++;
name = sx->sx[1]->data;
}else
return;
-
+
for(i=0; i<nelem(unextab); i++){
if(unextab[i].num == num && cistrcmp(unextab[i].name, name) == 0){
if(unextab[i].fmt && !sxmatch(sx, unextab[i].fmt)){
free(s);
s = t;
}
-
- /*
- * Plan 9 calls the main mailbox mbox.
+
+ /*
+ * Plan 9 calls the main mailbox mbox.
* Rename any existing mbox by appending a $.
*/
if(!inbox && strncmp(s, "mbox", 4) == 0 && alldollars(s+4)){
/*
* This response contains in sx->sx[2] the list of flags
* that can be validly attached to messages in z->box.
- * We don't have any use for this list, since we
+ * We don't have any use for this list, since we
* use only the standard flags.
*/
}
xsearch(Imap *z, Sx *sx)
{
int i;
-
+
free(z->uid);
z->uid = emalloc((sx->nsx-2)*sizeof z->uid[0]);
z->nuid = sx->nsx-2;
z->uid[i] = sx->sx[i+2]->number;
}
-/*
+/*
* Table-driven FETCH message info parser.
*/
static void xmsgflags(Msg*, Sx*, Sx*);
nstring(Sx *v)
{
char *p;
-
+
if(isnil(v))
return estrdup("");
p = v->data;
char *name, *email, *host, *mbox;
int i;
Fmt fmt;
-
+
if(v->nsx == 0)
return nil;
{
int i, j;
char *s, *t, **p;
-
+
if(isnil(v))
return;
if(v->nsx%2){
}
free(s);
free(t);
- }
+ }
}
static void
{
int i;
char *s, *t;
-
+
if(isnil(v))
return;
if(v->type != SxList){
strlwr(t);
free(part->type);
part->type = esmprint("%s/%s", s, t);
- if(v->nsx < 7 || !islist(v->sx[2]) || !isstring(v->sx[3])
+ if(v->nsx < 7 || !islist(v->sx[2]) || !isstring(v->sx[3])
|| !isstring(v->sx[4]) || !isstring(v->sx[5]) || !isnumber(v->sx[6]))
goto bad;
parseparams(part, v->sx[2]);
int i;
char *name, *p;
Part *part;
-
+
name = k->data;
name += 5; /* body[ */
p = strchr(name, ']');
if(p)
*p = 0;
-
+
/* now name is something like 1 or 3.2.MIME - walk down parts from root */
part = msg->part[0];
{
int i;
Box *b;
-
+
if((b=z->box) == nil)
return;
if(b->validity != sx->number){
USED(sx);
/* z->boxmode = OREAD; */
}
-
blob - ebcf701cab1116697b005a439a55f9319405d3f4
blob + c72a48494e13b795abdbd9a2cf69e2f1695e1b1c
--- src/cmd/upas/nfs/main.c
+++ src/cmd/upas/nfs/main.c
break;
}ARGEND
- quotefmtinstall();
+ quotefmtinstall();
fmtinstall('$', sxfmt);
if(argc != 1)
usage();
server = argv[0];
-
+
mailthreadinit();
boxinit();
fsinit0();
sysfatal("imapconnect: %r");
threadpostmountsrv(&fs, srvname, mtpt, 0);
}
-
blob - 5f90f0a21a51743e9a2a0e7023531b4719ccd284
blob + 1b60ffa6162f0f9d80131c61bbc66fa0b87b0922
--- src/cmd/upas/nfs/mbox.c
+++ src/cmd/upas/nfs/mbox.c
markboxes(int mark)
{
Mailbox *b;
-
+
for(i=0; i<nbox; i++)
if(box[i])
box[i]->mark = mark;
sweepboxes(void)
{
Mailbox *b;
-
+
for(i=0; i<nbox; i++)
if(box[i] && box[i]->mark){
freembox(box[i]);
mboxbyname(char *name)
{
int i;
-
+
for(i=0; i<nbox; i++)
if(box[i] && strcmp(box[i]->name, name) == 0)
return box[i];
mboxcreate(char *name)
{
Mailbox *b;
-
+
b = emalloc(sizeof *b);
b->name = estrdup(name);
if(nbox%64 == 0)
blob - f4a26862926c2ad17289029ddd00c225cd507fa2
blob + 622841a6c23dc81676bd217c52f7a3541acbc275
--- src/cmd/upas/nfs/msg.c
+++ src/cmd/upas/nfs/msg.c
before being tossed out
reload from disk, then from server
-
blob - 65d338c217e197c645100973ea7204433ae6aeec
blob + 55e2934e7749ee7ada2482ad84df32ff0b81ab07
--- src/cmd/upas/nfs/sx.c
+++ src/cmd/upas/nfs/sx.c
{
Sx **sx, *x;
int nsx;
-
+
nsx = 0;
sx = nil;
while((x = Brdsx1(b)) != nil){
return x;
}
-int
+int
sxwalk(Sx *sx)
{
int i, n;
-
+
if(sx == nil)
return 1;
switch(sx->type){
freesx(Sx *sx)
{
int i;
-
+
if(sx == nil)
return;
switch(sx->type){
char *s;
vlong n;
Sx *x;
-
+
c = Bgetc(b);
if(c == ' ')
c = Bgetc(b);
s = emalloc(1);
s[0] = c;
nbr = 0;
- while((c = Bgetc(b)) >= 0 && c > ' ' && !strchr("(){}", c)){
+ while((c = Bgetc(b)) >= 0 && c > ' ' && !strchr("(){}", c)){
/* allow embedded brackets as in BODY[] */
if(c == '['){
if(s[0] == '[')
x->type = SxAtom;
x->data = s;
x->ndata = len;
- return x;
+ return x;
}
int
{
int i, paren;
Sx *sx;
-
+
sx = va_arg(fmt->args, Sx*);
if(sx == nil)
return 0;
int
oksx(Sx *sx)
{
- return sx->nsx >= 2
- && sx->sx[1]->type == SxAtom
+ return sx->nsx >= 2
+ && sx->sx[1]->type == SxAtom
&& cistrcmp(sx->sx[1]->data, "OK") == 0;
}
blob - 38a801d45ba3115a0dc70b8e5f23e12b5d821356
blob + 696b5a704e89fa658b1227d20e0592121d127acc
--- src/cmd/upas/nfs/sx.h
+++ src/cmd/upas/nfs/sx.h
int oksx(Sx*);
int sxfmt(Fmt*);
int sxwalk(Sx*);
-
blob - bb40def13ac755337573f4b0b3d357d2e232cf56
blob + b4c893ee0db739ffbbe15c0d3abad98f99c1d237
--- src/cmd/upas/nfs/thread.c
+++ src/cmd/upas/nfs/thread.c
mailthread(void (*fn)(void*), void *arg)
{
New n;
-
+
n.fn = fn;
n.arg = arg;
send(mailthreadchan, &n);
mailproc(void *v)
{
New n;
-
+
USED(v);
while(recv(mailthreadchan, &n) == 1)
threadcreate(n.fn, n.arg, STACK);
mailthreadchan = chancreate(sizeof(New), 0);
proccreate(mailproc, nil, STACK);
}
-
blob - ac9deba8ada839246655030f9f2f9ae2e9f41879
blob + 048eef052a0076170dce2f703e248dcdbc5fcde5
--- src/cmd/upas/nfs/util.c
+++ src/cmd/upas/nfs/util.c
warn(char *fmt, ...)
{
va_list arg;
-
+
va_start(arg, fmt);
fprint(2, "warning: ");
vfprint(2, fmt, arg);
blob - af674368515fa877152d695f57e7ac1c89105981
blob + 4974a8b52e63d212043cb31dceeb5d673d027d02
--- src/cmd/upas/pop3/pop3.c
+++ src/cmd/upas/pop3/pop3.c
static int didtls;
typedef struct Msg Msg;
-struct Msg
+struct Msg
{
int upasnum;
char digest[64];
Binit(&out, 1, OWRITE);
didtls = 1;
return 0;
-}
+}
static int
topcmd(char *arg)
return senderr("no such message");
sendok("%d %s", n+1, msg[n].digest);
}
- return 0;
+ return 0;
}
static char*
if(tries++ >= 5){
senderr("authentication failed: %r; server exiting");
exits(nil);
- }
+ }
return senderr("authentication failed");
}
return -1;
return dologin(resp);
}
-
blob - 2e3685040fcd95947cc6139bc46df89b86089a41
blob + 3030142405b891a20306bf919cfae7d9b3534c55
--- src/cmd/upas/scanmail/common.c
+++ src/cmd/upas/scanmail/common.c
p = *msg;
if(ishtml == 0){
ishtml = htmlmatch(htmlcmds, p, end, &n);
-
+
/* If not an HTML keyword, check if it's
* an HTML comment (<!comment>). if so,
* skip over it; otherwise copy it in.
} else if(htmlmatch(hrefs, p, end, &n)) /* if special HTML string */
return '<'; /* copy it */
-
+
/*
* this is an uninteresting HTML command; skip over it.
*/
blob - 48cd4bbfe4649c5ab0078413ba37b4262d5e4587
blob + 79399c8bfa5651ab3dd322b9d2f4f51e6868e57a
--- src/cmd/upas/scanmail/testscan.c
+++ src/cmd/upas/scanmail/testscan.c
exits("open");
}
Binit(&bin, fd, OREAD);
- } else
+ } else
Binit(&bin, 0, OREAD);
*body = 0;
blob - 8a8fc8eacf1d390698cf7666c354847aec0ac7cd
blob + 05327975a25a5d0ab37712934108df3ced608dfa
--- src/cmd/upas/send/bind.c
+++ src/cmd/upas/send/bind.c
return 1;
return 0;
}
-
blob - 6c455833a76b1779a8eb19e4e8353d9d6c00ef00
blob + 15a2026e0bf62a4fa1c3885680671af0ed75b83d
--- src/cmd/upas/send/main.c
+++ src/cmd/upas/send/main.c
/*
* If this is a gateway, translate the sender address into a local
- * address. This only happens if mail to the local address is
+ * address. This only happens if mail to the local address is
* forwarded to the sender.
*/
gateway(mp);
blob - 3ec8d706eb2610f42a48b412ac85dc4e986b9000
blob + 60dd050b3b365df416c70b4a3e244a8921ac0437
--- src/cmd/upas/send/message.c
+++ src/cmd/upas/send/message.c
if(p->addr){
cp = skipequiv(s_to_c(p->s));
s_append(body, cp);
- } else
+ } else
s_append(body, s_to_c(p->s));
}else{
s_putc(body, p->c);
isutf8(String *s)
{
char *p;
-
+
for(p = s_to_c(s); *p; p++)
if(*p&0x80)
return 1;
blob - 3f30d4f3aa0d0e0eee788df78e07854e961905aa
blob + 3b19da27b0ac64dd8dca0cef5bd2670c26f4123f
--- src/cmd/upas/send/rewrite.c
+++ src/cmd/upas/send/rewrite.c
extern int debug;
-/*
+/*
* Routines for dealing with the rewrite rules.
*/
char *s;
char *sp;
String *stp;
-
+
if(source == 0)
return 0;
sp = s_to_c(source);
s_putc(stp, *sp);
break;
}
- } else if(*sp == '&') {
+ } else if(*sp == '&') {
if(subexp[0].s.sp != 0)
for (s = subexp[0].s.sp;
s < subexp[0].e.ep; s++)
fprint(2, " '%s'\n", rp->repl2 ? rp->repl2->base:"...");
}
}
-
blob - f40181ad58d56b659bcb3a19657c752d9cf711ac
blob + d5bf0bb17e6612b946c9ef7e1335169017f7084a
--- src/cmd/upas/send/skipequiv.c
+++ src/cmd/upas/send/skipequiv.c
len = strlen(cp);
Bseek(fp, 0, 0);
-
+
/* one iteration per system name in the file */
while(buf = Brdline(fp, '\n')) {
ep = &buf[Blinelen(fp)];
blob - 56962dcd55066ac3268ea5e7d3644c9054181f03
blob + f7a009afda00ff5ac2eee75fd19f61be1ad2fd14
--- src/cmd/upas/smtp/mxdial.c
+++ src/cmd/upas/smtp/mxdial.c
{
int i, n, nmx;
Ndbtuple *t, *tmx, *tpref, *tip;
-
+
strcpy(domain, ds->host);
ds->netdir = "/net";
nmx = 0;
nmx++;
break;
}
- }
+ }
}
ndbfree(t);
}
strncpy(mx[i].ip, tip->val, sizeof(mx[i].ip)-1);
ndbfree(t);
continue;
-
+
no:
/* remove mx[i] and go around again */
nmx--;
mx[i] = mx[nmx];
i--;
}
- return nmx;
+ return nmx;
}
static int
blob - 92873723d4e3438cec3cf38cfd368ec3c382f3c9
blob + 88d7f7a4d7fb807ba36ec3a5509966ab01b50976
--- src/cmd/upas/smtp/smtp.c
+++ src/cmd/upas/smtp/smtp.c
usage(void)
{
fprint(2, "usage: smtp [-adips] [-uuser] [-hhost] [.domain] net!host[!service] sender rcpt-list\n");
- threadexitsall(Giveup);
+ threadexitsall(Giveup);
}
int
nbytes += Bprint(&bout, "Message-ID: <%s@%s>\r\n", id, hostdomain);
if(debug)
Bprint(&berr, "Message-ID: <%s@%s>\r\n", id, hostdomain);
- }
+ }
if(originator==0){
nbytes += Bprint(&bout, "From: %s\r\n", s_to_c(fromline));
/*
* send body
*/
-
+
putcrnl(uneaten, buf+n - uneaten);
nbytes += buf+n - uneaten;
if(eof == 0){
return Bputc(&bout, x);
}
-char*
+char*
expand_addr(char *addr)
{
static char buf[256];
char *p, *q, *name, *sys;
Ndbtuple *t;
Ndb *db;
-
+
p = strchr(addr, '!');
if(p){
q = strchr(p+1, '!');
name++;
if(q)
*q = 0;
-
+
sys = sysname();
db = ndbopen(0);
t = ndbipinfo(db, "sys", sys, &name, 1);
*q = '!';
return addr;
}
-
+
*(name-1) = 0;
if(q)
*q = '!';
blob - e59dbddd2ae63c26d0e94675e086be081e8e3cbd
blob + df722c10836d5c108403195611cba851a8c8c7cc
--- src/cmd/upas/smtp/smtpd.c
+++ src/cmd/upas/smtp/smtpd.c
if (extended) {
if(tlscert != nil)
reply("250-STARTTLS\r\n");
- if (passwordinclear)
+ if (passwordinclear)
reply("250 AUTH CRAM-MD5 PLAIN LOGIN\r\n");
else
reply("250 AUTH CRAM-MD5\r\n");
* Could add an option with the remote IP address
* to allow validatesender to implement SPF eventually.
*/
- execl(validate, "validatesender",
+ execl(validate, "validatesender",
"-n", nci->root, senddom, user, nil);
threadexitsall("exec validatesender: %r");
default:
reply("450 %s\r\n", errx);
for(l=rcvers.first; l; l=l->next)
syslog(0, "smtpd", "[%s/%s] %s -> %s sendercheck: %s",
- him, nci->rsys, s_to_c(senders.first->p),
+ him, nci->rsys, s_to_c(senders.first->p),
s_to_c(l->p), errx);
rejectcount++;
return;
code = 554;
} else {
syslog(0, "smtpd", "++[%s/%s] %s %s %s%s%sreturned %#q %s", him, nci->rsys,
- s_to_c(senders.first->p), s_to_c(cmd),
+ s_to_c(senders.first->p), s_to_c(cmd),
piperror ? "error during pipemsg: " : "",
piperror ? piperror : "",
piperror ? "; " : "",
blob - bb982a2f398e625a598e6f6b9e7b1377841c33f6
blob + 9f8cdffaf54967e2416e9ddcd20c1e4c29adb7bf
--- src/cmd/upas/smtp/smtpd.h
+++ src/cmd/upas/smtp/smtpd.h
MAXREJECTS = 100
};
-
+
typedef struct Link Link;
typedef struct List List;
blob - 723e341d5e2a5f4cd524d2bf1116c85b7498ed47
blob + 2422dfe9bff6703b967694a5d60aa170df6ab86d
--- src/cmd/upas/smtp/spam.c
+++ src/cmd/upas/smtp/spam.c
"norelay", NORELAY,
"verifysenderdom", DNSVERIFY,
"saveblockedmsg", SAVEBLOCK,
- "defaultdomain", DOMNAME,
+ "defaultdomain", DOMNAME,
"ournets", OURNETS,
"ourdomains", OURDOMS,
0, NONE
return ACCEPT;
for(k = actions; k->name != 0; k++){
- snprint(buf, sizeof buf, "%s/mail/ratify/%s/%s/%s",
+ snprint(buf, sizeof buf, "%s/mail/ratify/%s/%s/%s",
get9root(), k->name, type, s);
if(access(buf,0) >= 0)
return k->code;
if((v4peerip&m) == a)
return 1;
cp += strlen(cp)+1;
- }
+ }
return 0;
}
int pid;
Waitmsg *w;
static int beenhere;
-
+
if(!beenhere){
beenhere++;
validator = unsharp(validator);
blob - aecbca62de064d7fb9a50be9eb1a013ce12aec8c
blob + 7269da900a51f64d63b96b716694b3d5e12df0e1
--- src/cmd/upas/vf/unvf.c
+++ src/cmd/upas/vf/unvf.c
Biobuf b, b1;
char *p, *encoding;
int e, len;
-
+
Binit(&b, 0, OREAD);
Binit(&b1, 1, OWRITE);
-
+
/* header */
encoding = nil;
while((p = Brdstr(&b, '\n', 1)) != nil){
}
/*
- * decode quoted
+ * decode quoted
*/
enum
{
return p - out;
}
-
blob - fb54d4a19b71d8e9865393acf60e9ddb1b991379
blob + 5aab37fef2ee0cd1b5a2298e170a8036eae6fb75
--- src/cmd/upas/vf/vf.c
+++ src/cmd/upas/vf/vf.c
passnotheader();
return part(p);
} else {
- /*
+ /*
* This is the meat. This may be an executable.
* if so, wrap it and change its type
*/
Bprint(&out, "\n");
Bterm(&out);
close(fd);
-
+
memset(&out, 0, sizeof out);
Binit(&out, 1, OWRITE);
return 0;
{
char buf[40], *name;
int fd;
-
+
strcpy(buf, "/var/tmp/vf.XXXXXXXXXXX");
if((fd = mkstemp(buf)) < 0){
fprint(2, "error creating temporary file: %r\n");
char *name;
Waitmsg *w;
static char *val;
-
+
if(val == nil)
val = unsharp("#9/mail/lib/validateattachment");
if(val == nil || access(val, AEXEC) < 0)
if(justreject)
return p;
-
+
syslog(0, "mail", "vf wrapped %s %s", p->type?s_to_c(p->type):"?",
p->filename?s_to_c(p->filename):"?");
}
/*
- * parse content type header
+ * parse content type header
*/
static void
ctype(Part *p, Hdef *h, char *cp)
cp = getstring(cp, p->type, 1);
if(badtype(s_to_c(p->type)))
p->badtype = 1;
-
+
while(*cp){
if(isattribute(&cp, "boundary")){
s = s_new();
p->charset = s_new();
cp = getstring(cp, s_reset(p->charset), 0);
}
-
+
cp = skiptosemi(cp);
}
}
/*
- * parse content encoding header
+ * parse content encoding header
*/
static void
cencoding(Part *m, Hdef *h, char *p)
}
/*
- * parse content disposition header
+ * parse content disposition header
*/
static void
cdisposition(Part *p, Hdef *h, char *cp)
}
/*
- * decode quoted
+ * decode quoted
*/
enum
{
blob - b064feaf1e632fd6c7233f98064bea8f294a1038
blob + 8d4a71e6a783372833a2ecef49cf7c4ea4773830
--- src/cmd/usage.c
+++ src/cmd/usage.c
char *argv0, *args, *flags, *p, *p0;
int single;
Rune r;
-
+
argv0 = getenv("0");
if(argv0 == nil) {
if(argc > 1)
argv0 = p+1;
flags = getenv("flagfmt");
args = getenv("args");
-
+
if(argv0 == nil){
fprint(2, "aux/usage: $0 not set\n");
exits("$0");
blob - 000a762a8de80c9fb0dfe3eec6a6971a6b225182
blob + 7182d52b888ebc422197629aa573bc061239bed6
--- src/cmd/vac/dat.h
+++ src/cmd/vac/dat.h
int i, n;
VacDir *buf;
};
-
blob - d96502892bbf09bc39ee0684040b851cb9afb3df
blob + e25f6cfc6b1317033b966a631a2b2cd21810621d
--- src/cmd/vac/file.c
+++ src/cmd/vac/file.c
/*
* Vac file system. This is a simplified version of the same code in Fossil.
- *
+ *
* The locking order in the tree is upward: a thread can hold the lock
* for a VacFile and then acquire the lock of f->up (the parent),
* but not vice-versa.
- *
+ *
* A vac file is one or two venti files. Plain data files are one venti file,
* while directores are two: a venti data file containing traditional
- * directory entries, and a venti directory file containing venti
+ * directory entries, and a venti directory file containing venti
* directory entries. The traditional directory entries in the data file
* contain integers indexing into the venti directory entry file.
* It's a little complicated, but it makes the data usable by standard
* tools like venti/copy.
*
*/
-
+
static int filemetaflush(VacFile*, char*);
struct VacFile
VtFile *msource; /* metadata for children in a directory */
VacFile *down; /* children */
int mode;
-
+
uvlong qidoffset; /* qid offset */
};
filefree(f);
return 0;
}
-
+
filemetalock(f);
f->ref--;
if(f->ref > 0){
}
-/*
- * Construct a vacfile for the root of a vac tree, given the
- * venti file for the root information. That venti file is a
+/*
+ * Construct a vacfile for the root of a vac tree, given the
+ * venti file for the root information. That venti file is a
* directory file containing VtEntries for three more venti files:
- * the two venti files making up the root directory, and a
- * third venti file that would be the metadata half of the
+ * the two venti files making up the root directory, and a
+ * third venti file that would be the metadata half of the
* "root's parent".
*
* Fossil generates slightly different vac files, due to a now
_vacfileroot(VacFs *fs, VtFile *r)
{
int redirected;
- char err[ERRMAX];
+ char err[ERRMAX];
VtBlock *b;
VtFile *r0, *r1, *r2;
MetaBlock mb;
* to look at every block to find a given name.
* Dirlookup looks in f for an element name elem.
* It returns a new VacFile with the dir, boff, and mode
- * filled in, but the sources (venti files) are not, and f is
+ * filled in, but the sources (venti files) are not, and f is
* not yet linked into the tree. These details must be taken
* care of by the caller.
*
return nil;
}
-/*
- * Open a path in the vac file system:
+/*
+ * Open a path in the vac file system:
* just walk each element one at a time.
*/
VacFile*
* Directory reading.
*
* A VacDirEnum is a buffer containing directory entries.
- * Directory entries contain malloced strings and need to
- * be cleaned up with vdcleanup. The invariant in the
+ * Directory entries contain malloced strings and need to
+ * be cleaned up with vdcleanup. The invariant in the
* VacDirEnum is that the directory entries between
* vde->i and vde->n are owned by the vde and need to
* be cleaned up if it is closed. Those from 0 up to vde->i
- * have been handed to the reader, and the reader must
+ * have been handed to the reader, and the reader must
* take care of calling vdcleanup as appropriate.
*/
VacDirEnum*
/*
* There might be changes to this directory's children
* that have not been flushed out into the cache yet.
- * Those changes are only available if we look at the
+ * Those changes are only available if we look at the
* VacFile structures directory. But the directory reader
* is going to read the cache blocks directly, so update them.
*/
* On to mutation. If the vac file system has been opened
* read-write, then the files and directories can all be edited.
* Changes are kept in the in-memory cache until flushed out
- * to venti, so we must be careful to explicitly flush data
+ * to venti, so we must be careful to explicitly flush data
* that we're not likely to modify again.
*
* Each VacFile has its own copy of its VacDir directory entry
* in f->dir, but otherwise the cache is the authoratative source
- * for data. Thus, for the most part, it suffices if we just
+ * for data. Thus, for the most part, it suffices if we just
* call vtfileflushbefore and vtfileflush when we modify things.
* There are a few places where we have to remember to write
* changed VacDirs back into the cache. If f->dir *is* out of sync,
* then f->dirty should be set.
*
* The metadata in a directory is, to venti, a plain data file,
- * but as mentioned above it is actually a sequence of
+ * but as mentioned above it is actually a sequence of
* MetaBlocks that contain sorted lists of VacDir entries.
* The filemetaxxx routines manipulate that stream.
*/
int i, n;
MetaEntry me;
VtFile *ms;
-
+
ms = fp->msource;
n = vdsize(dir, VacDirVersion);
-
+
/* Look for a block with room for a new entry of size n. */
nb = (vtfilegetsize(ms)+ms->dsize-1)/ms->dsize;
if(start == NilBlock){
else
start = 0;
}
-
+
if(start > nb)
start = nb;
for(bo=start; bo<nb; bo++){
}
/*
- * Update f's directory entry in the block cache.
+ * Update f's directory entry in the block cache.
* We look for the directory entry by name;
* if we're trying to rename the file, oelem is the old name.
*
goto Err;
/*
- * Check whether we can resize the entry and keep it
+ * Check whether we can resize the entry and keep it
* in this block.
*/
n = vdsize(&f->dir, VacDirVersion);
vdunpack(&f->dir, &me);
mbinsert(&mb, i, &me);
mbpack(&mb);
-
+
/* Done */
vtblockput(b);
vtfileunlock(fp->msource);
f->dirty = 0;
return 0;
}
-
+
/*
* The entry must be moved to another block.
* This can only really happen on renames that
* make the name very long.
*/
-
+
/* Allocate a spot in a new block. */
if((bo = filemetaalloc(fp, &f->dir, f->boff+1)) == NilBlock){
/* mbresize above might have modified block */
int ret;
VacFile **kids, *p;
int i, nkids;
-
+
if(f->mode == VtOREAD)
return 0;
/*
* Now we can flush our own data.
- */
+ */
vtfilelock(f->source, -1);
if(vtfileflush(f->source) < 0)
ret = -1;
return ret;
}
-
+
/*
* Create a new file named elem in fp with the given mode.
* The mode can be changed later except for the ModeDir bit.
vacfileincref(fp);
fileunlock(fp);
-
+
filelock(ff);
vtfilelock(ff->source, -1);
vtfileunlock(ff->source);
werrstr(ENotFile);
return -1;
}
-
+
if(filelock(f) < 0)
return -1;
if(filelock(f) < 0)
return -1;
filemetalock(f);
-
+
if(f->source->mode != VtORDWR){
werrstr(EReadOnly);
goto Err;
int fd;
uchar score[VtScoreSize];
char *prefix;
-
+
if(vtparsescore(file, &prefix, score) >= 0){
if(prefix == nil || strcmp(prefix, "vac") != 0){
werrstr("not a vac file");
memmove(e.score, rt.score, VtScoreSize);
e.gen = 0;
-
+
// Don't waste cache memory on pointer blocks
// when rt.blocksize is large.
e.psize = (rt.blocksize/VtEntrySize)*VtEntrySize;
vacfsgetmaxqid(VacFs *fs, uvlong *maxqid)
{
VacDir vd;
-
+
if(vacfilegetdir(fs->root, &vd) < 0)
return -1;
if(vd.qidspace)
VacDir vd;
MetaEntry me;
int psize;
-
+
if((fs = vacfsalloc(z, bsize, cachemem, VtORDWR)) == nil)
return nil;
vtblockwrite(b);
memmove(metascore, b->score, VtScoreSize);
vtblockput(b);
-
+
/* First entry: empty venti directory stream. */
memset(&e, 0, sizeof e);
e.flags = VtEntryActive;
memmove(e.score, vtzeroscore, VtScoreSize);
vtentrypack(&e, buf, 0);
vtfilewrite(f, buf, VtEntrySize, 0);
-
+
/* Second entry: empty metadata stream. */
e.type = VtDataType;
vtentrypack(&e, buf, 0);
vtfileflush(f);
vtfileunlock(f);
-
+
/* Now open it as a vac fs. */
fs->root = _vacfileroot(fs, f);
if(fs->root == nil){
{
uchar fscore[VtScoreSize];
uchar bufscore[VtScoreSize];
-
+
if(vacfileblockscore(f, b, fscore) < 0)
return 0;
n = vtzerotruncate(VtDataType, buf, n);
return 1;
return 0;
}
-
blob - 863eb848619be881ba23e577da0c7675eb9ed7d0
blob + 69602ad75f5ddcc3e41221b3ef8ce0262d29dedd
--- src/cmd/vac/glob.c
+++ src/cmd/vac/glob.c
*w++ = ')';
*w++ = '$';
*w = 0;
-
+
re = regcomp(s);
if(re == nil){
syntax:
case '#':
continue;
}
-
+
inc = 0;
if(strncmp(p, "include ", 8) == 0){
inc = 1;
excludepattern(char *p)
{
Reprog *re;
-
+
if((re = glob2regexp(p)) == nil)
sysfatal("bad glob pattern %s", p);
includefile(char *file)
{
Pattern *p, *ep;
-
+
for(p=pattern, ep=p+npattern; p<ep; p++)
if(regexec(p->re, file, nil, 0))
return p->include;
return 1;
}
-
blob - 5555cc0eb287595d50c381434f9c36c3ad132496
blob + 1eca665db061dfa4981b0d1dc7ebf66103e1cf6e
--- src/cmd/vac/pack.c
+++ src/cmd/vac/pack.c
if(*n < 2)
return -1;
-
+
nn = U16GET(*p);
*p += 2;
*n -= 2;
}
p = mb->buf + eo;
-
+
/* make sure entry looks ok and includes an elem name */
if(en < 8 || U32GET(p) != DirMagic || en < 8 + U16GET(p+6)) {
werrstr("corrupted meta block entry");
int oo, o, n, i;
oo = MetaHeaderSize + mb->maxindex*MetaIndexSize;
-
+
for(i=0; i<mb->nindex; i++) {
o = mc[i].offset;
n = mc[i].size;
vdsize(VacDir *dir, int version)
{
int n;
-
+
if(version < 8 || version > 9)
sysfatal("bad version %d in vdpack", version);
sysfatal("bad version %d in vdpack", version);
p = me->p;
-
+
U32PUT(p, DirMagic);
U16PUT(p+4, version); /* version */
p += 6;
U32PUT(p, dir->entry);
p += 4;
-
+
if(version == 9){
U32PUT(p, dir->gen);
U32PUT(p+4, dir->mentry);
p += stringpack(dir->uid, p);
p += stringpack(dir->gid, p);
p += stringpack(dir->mid, p);
-
+
U32PUT(p, dir->mtime);
U32PUT(p+4, dir->mcount);
U32PUT(p+8, dir->ctime);
U64PUT(p+8, dir->qidmax, t32);
p += 16;
}
-
+
if(dir->gen && version < 9) {
U8PUT(p, DirGenEntry);
U16PUT(p+1, 4);
{
int t, nn, n, version;
uchar *p;
-
+
p = me->p;
n = me->size;
if(version < 7 || version > 9)
goto Err;
p += 2;
- n -= 2;
+ n -= 2;
/* elem */
if(stringunpack(&dir->elem, &p, &n) < 0)
p += VtScoreSize;
n -= VtScoreSize;
}
-
+
/* uid */
if(stringunpack(&dir->uid, &p, &n) < 0)
goto Err;
*ri = i;
return 1;
}
-
+
if(x < 0)
b = i+1;
else /* x > 0 */
}
assert(b == t);
-
+
*ri = b; /* b is the index to insert this entry */
memset(me, 0, sizeof(*me));
blob - 0cd431434a80438995760e2410611d4b4d8b163e
blob + 3049e34b2a1cfcb8453511e76e89f08472e23656
--- src/cmd/vac/testinc.c
+++ src/cmd/vac/testinc.c
default:
goto usage;
}ARGEND
-
+
if(argc != 1){
usage:
fprint(2, "usage: testinc includefile\n");
threadexitsall("usage");
}
-
+
loadexcludefile(argv[0]);
Binit(&b, 0, OREAD);
while((p = Brdline(&b, '\n')) != nil){
blob - 594a6a2e8b44c9a17944d3b9abcc7a255021d16e
blob + a265893fc7e1d4304c3637b4dfdb865ea5ec8c0d
--- src/cmd/vac/unvac.c
+++ src/cmd/vac/unvac.c
fmtinstall('F', vtfcallfmt);
fmtinstall('t', mtimefmt);
fmtinstall('M', dirmodefmt);
-
+
host = nil;
printstats = 0;
if((f = vacfsgetroot(fs)) == nil)
sysfatal("vacfsgetroot: %r");
-
+
unvac(f, nil, nil);
for(i=0; i<nwant; i++){
if(want[i] && !found[i]){
{
int m;
int oldn;
-
+
oldn = n;
while(n > 0){
m = write(fd, buf, n);
wantfile(char *name)
{
int i, namelen, n;
-
+
if(nwant == 0)
return 1;
fprint(2, "warning: ignoring %s %s\n", what, name);
return;
}
-
+
if(mode&ModeDir){
if((vde = vdeopen(f)) == nil){
fprint(2, "vdeopen %s: %r", name);
mtimefmt(Fmt *f)
{
Tm *tm;
-
+
tm = localtime(va_arg(f->args, ulong));
fmtprint(f, "%04d-%02d-%02d %02d:%02d",
tm->year+1900, tm->mon+1, tm->mday,
blob - b54503e4ed378094c276fca84c9cf6d8c3b11153
blob + 7e441482567310f04584059c05dea5445421f72b
--- src/cmd/vac/vac.c
+++ src/cmd/vac/vac.c
#ifdef PLAN9PORT
/*
* We're between a rock and a hard place here.
- * The pw library (getpwnam, etc.) reads the
+ * The pw library (getpwnam, etc.) reads the
* password and group files into an on-stack buffer,
* so if you have some huge groups, you overflow
* the stack. Because of this, the thread library turns
default:
usage();
}ARGEND
-
+
if(argc == 0 && !stdinname)
usage();
-
+
if(archivefile && (vacfile || diffvac)){
fprint(2, "cannot use -a with -f, -d\n");
usage();
}
if(fdiff)
vacfiledecref(fdiff);
-
+
/*
* Record the maximum qid so that vacs can be merged
* without introducing overlapping qids. Older versions
char buf[10];
int year, mmdd, nn, n, n1;
char *p;
-
+
fp = vacfsgetroot(fs);
de = vdeopen(fp);
year = 0;
return nil;
}
fp = f;
-
+
de = vdeopen(fp);
mmdd = 0;
nn = 0;
/*
* Archive the file named name, which has stat info d,
- * into the vac directory fp (p = parent).
+ * into the vac directory fp (p = parent).
*
* If we're doing a vac -d against another archive, the
* equivalent directory to fp in that archive is diffp.
if(merge && vacmerge(fp, name) >= 0)
return;
-
+
if(verbose)
fprint(2, "%s%s\n", name, (d->mode&DMDIR) ? "/" : "");
if(vacfilegetentries(fdiff, &e, nil) >= 0)
if(vacfilesetentries(f, &e, nil) >= 0){
bsize = e.dsize;
-
+
/*
* Or if -q is set, and the metadata looks the same,
* don't even bother reading the file.
vdcleanup(&vddiff);
goto Out;
}
-
+
/*
* Skip over presumably-unchanged prefix
* of an append-only file.
warn("vacfilecreate %s: %r", name);
return;
}
-
+
off = 0;
while((n = read(0, buf, sizeof buf)) > 0){
if(vacfilewrite(f, buf, n, off) < 0){
VtEntry ed, em;
VacFile *mf;
VacFile *f;
-
+
mf = vacfilewalk(mp, d->elem);
if(mf == nil){
warn("could not walk %s in %s", d->elem, vacfile);
vacfiledecref(mf);
return -1;
}
-
+
if((f = vacfilecreate(fp, d->elem, d->mode)) == nil){
warn("vacfilecreate %s: %r", d->elem);
vacfiledecref(mf);
vacfiledecref(f);
return -1;
}
-
+
vacfiledecref(mf);
vacfiledecref(f);
return 0;
fprint(2, "\n");
va_end(arg);
}
-
blob - 0edd41e40bf5b7b126863825f0dfec50f197f5c5
blob + bbed4931cd631ccfd26473002bbdcd2083bee25a
--- src/cmd/vac/vac.h
+++ src/cmd/vac/vac.h
*/
enum
{
- ModeOtherExec = (1<<0),
+ ModeOtherExec = (1<<0),
ModeOtherWrite = (1<<1),
ModeOtherRead = (1<<2),
ModeGroupExec = (1<<3),
ulong mgen; /* generation of meta entry */
uvlong size; /* size of file */
uvlong qid; /* unique file id */
-
+
char *uid; /* owner id */
char *gid; /* group id */
char *mid; /* last modified by */
int vacfiledsize(VacFile *f);
int sha1matches(VacFile *f, ulong b, uchar *buf, int n);
-
blob - b45257294f77db8a3b126f89d27b0396b689a6da
blob + 05baf66ea2dc95bfb2a2c061de238140117ec880
--- src/cmd/vac/vacfs.c
+++ src/cmd/vac/vacfs.c
fmtinstall('H', encodefmt);
fmtinstall('V', vtscorefmt);
fmtinstall('F', vtfcallfmt);
-
+
defmnt = nil;
defsrv = nil;
ARGBEGIN{
VacDir dir;
static uchar statbuf[1024];
VacFile *parent;
-
+
if(!f->busy)
return vtstrdup(Enotexist);
parent = vacfilegetparent(f->file);
dir.qid.type |= QTDIR;
dir.mode |= DMDIR;
}
-
+
#ifdef PLAN9PORT
if(vd->mode & (ModeLink|ModeDevice|ModeNamedPipe)){
vf = vacfilewalk(parent, vd->elem);
dir.mode |= DMNAMEDPIPE;
}
#endif
-
+
dir.atime = vd->atime;
dir.mtime = vd->mtime;
dir.length = vd->size;
vacfsclose(fs);
vthangup(conn);
}
-
blob - 1b5b404a55f7455e763afae78b872f6ae5938faa
blob + 288e34340f1b7c9d1f2d5bf6cdbc78b602a03c45
--- src/cmd/vbackup/config.c
+++ src/cmd/vbackup/config.c
if((dir = dirstat(name)) == nil)
return nil;
-
+
if((b = Bopen(name, OREAD)) == nil){
free(dir);
return nil;
freeconfig(c);
return nil;
}
-
+
return c;
}
blob - b51d0a3b8dbefbeef135b7f96d955e047280e889
blob + b7798db8d5d16772a75424deda2541f4a0c96478
--- src/cmd/vbackup/disknfs.c
+++ src/cmd/vbackup/disknfs.c
{
return fsysreaddir(fsys, au, h, count, cookie, data, pcount, peof);
}
-
blob - b343aa62788eefa8f12c96e44982a44090ecfa16
blob + bfc0e0fdd52df2cc76e984c8b58951da54f2c4f8
--- src/cmd/vbackup/mount-Linux.c
+++ src/cmd/vbackup/mount-Linux.c
if(mount("backup:/", mtpt, "nfs", mflag, &nfs) < 0)
sysfatal("mount: %r");
}
-
blob - db8e1e5bc5e5e1d45a324be384081b52cfb0bd0a
blob + 28380e13b69fbc47d8926a616541d36294d8e11e
--- src/cmd/vbackup/mount-none.c
+++ src/cmd/vbackup/mount-none.c
{
sysfatal("mountnfs not implemented");
}
-
blob - c3fc780badc27cc1cba4417d25edd7a7db588a55
blob + 532f7e6c7805bde8a9e99ff1c78bc83cbe3df95d
--- src/cmd/vbackup/nfs3srv.c
+++ src/cmd/vbackup/nfs3srv.c
NfsMount3RUmnt rx;
/* ignore */
-
+
memset(&rx, 0, sizeof rx);
return sunmsgreply(m, &rx.call);
}
memset(buf, 0, sizeof buf);
return senderror(m, (SunCall*)buf, Nfs3ErrRoFs);
}
-
+
static void
rnfs3(void *v)
{
while((m = recvp(c)) != nil)
threadcreate(rnfs3, m, SunStackSize);
}
-
blob - f96be9850daa11f3d9ee376407eccbff9132adac
blob + 6d72c1e60fd568f86ac5da21c50fb1e8dc6e3b96
--- src/cmd/vbackup/nfs3srv.h
+++ src/cmd/vbackup/nfs3srv.h
{
MaxDataSize = 8192
};
-
blob - 353ff610626039f1ceb339e0c0a4bbbe039675c7
blob + df68abe2303025454c04068d52a011c72c1b90da
--- src/cmd/vbackup/vbackup.c
+++ src/cmd/vbackup/vbackup.c
* -s print status updates
* -v print debugging trace
* -w write parallelism
- *
+ *
* If score is given on the command line, it should be the
* score from a previous vbackup on this fspartition.
* In this mode, only the new blocks are stored to Venti.
* by buffered queues:
*
* fsysproc | cmpproc | ventiproc
- *
+ *
* Fsysproc reads the disk and queues the blocks.
* Cmpproc compares the blocks against the SHA1 hashes
* in the old image, if any. It discards the unchanged blocks
* and queues the changed ones. Ventiproc writes blocks to Venti.
- *
+ *
* There is a fourth proc, statusproc, which prints status
* updates about how the various procs are progressing.
*/
tmpnam = smprint("%s/vbackup.XXXXXX", tmp);
if(tmpnam == nil)
sysfatal("smprint: %r");
-
+
if((fd = opentemp(tmpnam, ORDWR|ORCLOSE)) < 0)
sysfatal("opentemp %s: %r", tmpnam);
if(statustime)
print("# %T reading scores into %s\n", tmpnam);
if(verbose)
fprint(2, "read scores into %s...\n", tmpnam);
-
+
Binit(&bscores, fd, OWRITE);
for(i=0; i<fsys->nblock; i++){
if(vtfileblockscore(vfile, i, score) < 0)
}
Bterm(&bscores);
vtfileunlock(vfile);
-
+
/*
* prep scores for rereading
*/
}
/*
- * start the main processes
+ * start the main processes
*/
if(statustime)
print("# %T starting procs\n");
* wait for processes to finish
*/
wlock(&endlk);
-
+
qfree(qcmp);
qfree(qventi);
if(mountplace == nil)
mountplace = guessmountplace(argv[0]);
print("mount /%s/%d/%02d%02d%s %s:%V %d/%02d%02d/%02d%02d\n",
- mountname, tm.year, tm.mon, tm.mday,
+ mountname, tm.year, tm.mon, tm.mday,
mountplace,
root.type, b->score,
tm.year, tm.mon, tm.mday, tm.hour, tm.min);
sysfatal("vtsync: %r");
if(statustime)
print("# %T synced\n");
-
+
fsysclose(fsys);
diskclose(disk);
vtcachefree(zcache);
nrecv++;
if(wr.p == nil)
break;
-
+
if(fastwrites && vtread(z, wr.score, wr.type, nil, 0) < 0){
rerrstr(err, sizeof err);
if(strstr(err, "read too small")){ /* already exists */
Tm tm;
ns = nsec();
tm = *localtime(time(0));
- return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d.%03d",
+ return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d.%03d",
tm.year+1900, tm.mon+1, tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}
char *cmd, *q;
int p[2], fd[3], n;
char buf[100];
-
+
if(pipe(p) < 0)
sysfatal("pipe: %r");
*--q = 0;
return strdup(buf);
}
-
blob - c413af42dd9c06940897d480d5a7a1f8f3d028cc
blob + 84ac3df87888cea00c961e5f5bc6bdf48d6b2b3b
--- src/cmd/vbackup/vftp.c
+++ src/cmd/vbackup/vftp.c
char *help;
};
-Cmd cmdtab[] =
+Cmd cmdtab[] =
{
"cd", cmdcd, "cd dir - change directory",
"ls", cmdls, "ls [-d] path... - list file",
ebuf(void)
{
static char buf[ERRMAX];
-
+
rerrstr(buf, sizeof buf);
return buf;
}
estrdup(char *s)
{
char *t;
-
+
t = emalloc(strlen(s)+1);
strcpy(t, s);
return t;
char *p, *q;
Nfs3Handle h;
Nfs3Status ok;
-
+
path = estrdup(path); /* writable */
if(path[0] == '/')
h = root;
cmdhelp(int argc, char **argv)
{
int i;
-
+
for(i=0; i<nelem(cmdtab); i++)
print("%s\n", cmdtab[i].help);
return nil;
Nfs3Attr attr;
Nfs3Status ok;
Nfs3Handle h;
-
+
if(argc != 2)
return "usage: cd dir";
-
+
if((err = walk(argv[1], &h)) != nil)
return err;
if((ok = fsysgetattr(fsys, auth, &h, &attr)) != Nfs3Ok){
ls(char *dir, char *elem, Nfs3Attr *attr)
{
char c;
-
+
c = ' '; /* use attr->type */
Bprint(&bout, "%s%s%s", dir ? dir : "", dir && elem ? "/" : "", elem ? elem : "");
Bprint(&bout, " %c%luo %1d %4d %4d", c, attr->mode, attr->nlink, attr->uid, attr->gid);
u1int eof;
Nfs3Status ok;
u64int cookie;
-
+
cookie = 0;
for(;;){
ok = fsysreaddir(fsys, auth, h, 8192, cookie, &data, &count, &eof);
continue;
}
ls(dir, e.name, &attr);
- }
+ }
free(data);
if(eof)
break;
Nfs3Handle h;
Nfs3Attr attr;
Nfs3Status ok;
-
+
dflag = 0;
ARGBEGIN{
case 'd':
Bflush(&bout);
return nil;
}
-
+
for(i=0; i<argc; i++){
if((e = walk(argv[i], &h)) != nil){
fprint(2, "%s: %s\n", argv[i], e);
Nfs3Attr attr;
Nfs3Status ok;
vlong o;
-
+
dflag = 0;
ARGBEGIN{
default:
if(argc != 1 && argc != 2)
goto usage;
-
+
if((e = walk(argv[0], &h)) != nil){
fprint(2, "%s: %s\n", argv[0], e);
return nil;
char *e;
Nfs3Handle h;
u64int bno;
-
+
ARGBEGIN{
default:
return "usage: block path offset";
}ARGEND
-
+
if(argc != 2)
return "usage: block path offset";
int delta, count, i;
u64int offset;
uchar *p;
-
+
ARGBEGIN{
default:
return "usage: disk offset count";
}ARGEND
-
+
if(argc != 2)
return "usage: disk offset count";
offset = strtoull(argv[0], 0, 0);
count = atoi(argv[1]);
delta = offset%fsys->blocksize;
-
+
b = diskread(disk, fsys->blocksize, offset-delta);
if(b == nil){
fprint(2, "diskread: %r\n");
int i, nf;
uchar score[VtScoreSize];
Nfs3Status ok;
-
+
allowall = 1;
ARGBEGIN{
case 'V':
default:
usage();
}ARGEND
-
+
if(argc != 1)
usage();
fmtinstall('F', vtfcallfmt);
fmtinstall('H', encodefmt);
fmtinstall('V', vtscorefmt);
-
+
if(access(argv[0], AEXIST) >= 0 || strchr(argv[0], '/')){
if((disk = diskopenfile(argv[0])) == nil)
sysfatal("diskopen: %r");
cwd = root;
Binit(&bin, 0, OREAD);
Binit(&bout, 1, OWRITE);
-
+
while(fprint(2, "vftp> "), (p = Brdstr(&bin, '\n', 1)) != nil){
if(p[0] == '#')
continue;
}
threadexitsall(nil);
}
-
blob - d4319c8651704ed88eb8cb37ed18bde10191bec5
blob + f78d4886c47de39608e010d7c3ac7cde8a4b62bd
--- src/cmd/vbackup/vnfs.c
+++ src/cmd/vbackup/vnfs.c
nfschan = chancreate(sizeof(SunMsg*), 0);
mountchan = chancreate(sizeof(SunMsg*), 0);
timerchan = chancreate(sizeof(void*), 0);
-
+
if(sunsrvudp(srv, addr) < 0)
sysfatal("starting server: %r");
sunsrvthreadcreate(srv, mount3proc, mountchan);
sunsrvthreadcreate(srv, timerthread, nil);
proccreate(timerproc, nil, 32768);
-
+
sunsrvprog(srv, &nfs3prog, nfschan);
sunsrvprog(srv, &nfsmount3prog, mountchan);
/*
* Handles.
- *
+ *
* We store all the state about which file a client is accessing in
* the handle, so that we don't have to maintain any per-client state
- * ourselves. In order to avoid leaking handles or letting clients
+ * ourselves. In order to avoid leaking handles or letting clients
* create arbitrary handles, we sign and encrypt each handle with
* AES using a key selected randomly when the server starts.
- * Thus, handles cannot be used across sessions.
+ * Thus, handles cannot be used across sessions.
*
* The decrypted handles begin with the following header:
*
*
* If we're pressed for space in the rest of the handle, we could
* probably reduce the amount of sessid bytes. Note that the sessid
- * bytes must be consistent during a run of vnfs, or else some
+ * bytes must be consistent during a run of vnfs, or else some
* clients (e.g., Linux 2.4) eventually notice that successive TLookups
* return different handles, and they return "Stale NFS file handle"
* errors to system calls in response (even though we never sent
* and the handles need to be stable across changes in the config file
* (though not across server restarts since encryption screws
* that up nicely).
- *
- * We encode each of the first two as a 10-byte hash that is
- * the first half of a SHA1 hash.
+ *
+ * We encode each of the first two as a 10-byte hash that is
+ * the first half of a SHA1 hash.
*/
enum
hdecrypt(Nfs3Handle *h)
{
AESstate aes;
-
+
if(h->len == 1 && h->h[0] == 0){ /* single 0 byte is root */
*h = root;
return Nfs3Ok;
uchar key[32], ivec[AESbsize];
int i;
u32int u32;
-
+
u32 = truerand();
memmove(sessid, &u32, 4);
for(i=0; i<nelem(key); i+=4) {
Cnode *nextsib; /* in tree */
Cnode *kidlist; /* in tree */
Cnode *nexthash; /* in hash list */
-
+
Nfs3Status (*read)(Cnode*, u32int, u64int, uchar**, u32int*, u1int*); /* synthesized read fn */
uchar handle[VtScoreSize]; /* sha1(path to here) */
ulong mtime; /* mtime for this directory entry */
-
+
/* fsys overlay on this node */
Fsys *fsys; /* cache of memory structure */
Nfs3Handle fsyshandle;
char *fsysimage; /* raw disk image */
Fsys *mfsys; /* mounted file system (nil until walked) */
Nfs3Handle mfsyshandle; /* handle to root of mounted fsys */
-
+
int mark; /* gc */
};
{
uint h;
Cnode *n;
-
+
n = emalloc(sizeof *n + elen+1);
n->name = (char*)(n+1);
memmove(n->name, elem, elen);
h = dumbhash(n->handle);
n->nexthash = t->hash[h];
t->hash[h] = n;
-
+
return n;
}
int i;
Cnode *n;
Ctree *t;
-
+
t = config.ctree;
for(i=0; i<nelem(t->hash); i++)
for(n=t->hash[i]; n; n=n->nexthash){
cnodewalk(Cnode *n, char *name, uint len, int markokay)
{
Cnode *nn;
-
+
for(nn=n->kidlist; nn; nn=nn->nextsib)
if(strncmp(nn->name, name, len) == 0 && nn->name[len] == 0)
if(!nn->mark || markokay)
{
Cnode *n, *nn;
char *p, *nextp;
-
+
n = t->root;
p = name;
for(; *p; p=nextp){
mkctree(void)
{
Ctree *t;
-
+
t = emalloc(sizeof *t);
t->root = mkcnode(t, nil, "", 0, "", 0);
-
+
ctreewalkpath(t, "/+log", time(0))->read = logread;
ctreewalkpath(t, "/+refreshdisk", time(0))->read = refreshdiskread;
ctreewalkpath(t, "/+refreshconfig", time(0))->read = refreshconfigread;
ctreemountfsys(Ctree *t, char *path, ulong time, uchar *score, char *file)
{
Cnode *n;
-
+
if(time == 0)
time = 1;
n = ctreewalkpath(t, path, time);
{
int h;
Cnode *n;
-
+
h = dumbhash(p);
for(n=t->hash[h]; n; n=n->nexthash)
if(memcmp(n->handle, p, CnodeHandleSize) == 0)
parseipandmask(char *s, uchar *ip, uchar *mask)
{
char *p, *q;
-
+
p = strchr(s, '/');
if(p)
*p++ = 0;
char *p;
int i;
Tm tm;
-
+
/* decimal integer is seconds since 1970 */
x = strtoul(s, &p, 10);
if(x > 0 && *p == 0){
*time = x;
return 0;
}
-
+
/* otherwise expect yyyy/mmdd/hhmm */
if(strlen(s) != 14 || s[4] != '/' || s[9] != '/')
return -1;
return -1;
tm.mon = (s[5]-'0')*10+s[6]-'0' - 1;
if(tm.mon < 0 || tm.mon > 11)
- return -1;
+ return -1;
tm.mday = (s[7]-'0')*10+s[8]-'0';
if(tm.mday < 0 || tm.mday > 31)
return -1;
free(dir);
if((b = Bopen(name, OREAD)) == nil)
return -1;
-
+
/*
* Reuse old tree, garbage collecting entries that
* are not mentioned in the new config file.
markctree(c.ctree);
c.ok = nil;
c.nok = 0;
-
+
line = 0;
for(; (p=Brdstr(b, '\n', 1)) != nil; free(p)){
line++;
}
if(strcmp(f[0], "allow") == 0 || strcmp(f[0], "deny") == 0){
if(nf != 2){
- werrstr("syntax error: allow|deny ip[/mask]");
+ werrstr("syntax error: allow|deny ip[/mask]");
goto badline;
}
c.ok = erealloc(c.ok, (c.nok+1)*sizeof(c.ok[0]));
{
int i;
uchar ipx[IPaddrlen];
- Ipokay *ok;
-
+ Ipokay *ok;
+
for(i=0; i<config.nok; i++){
ok = &config.ok[i];
maskip(ip, ok->mask, ipx);
cnodelookup(Ctree *t, Cnode **np, char *name)
{
Cnode *n, *nn;
-
+
n = *np;
if(n->isblackhole)
return Nfs3Ok;
u64int c;
u64int u64;
Nfs3Entry ne;
-
+
n = n->kidlist;
c = cookie;
for(; c && n; c--)
*peof = 1;
return Nfs3Ok;
}
-
+
data = emalloc(count);
p = data;
ep = data+count;
}
/*
- * Actually serve the NFS requests. Called from nfs3srv.c.
+ * Actually serve the NFS requests. Called from nfs3srv.c.
* Each request runs in its own thread (coroutine).
*
* Decrypted handles have the form:
* glob[10] - SHA1 hash prefix identifying a glob state
* fsyshandle[<=10] - disk file system handle (usually 4 bytes)
*/
-
+
/*
* A fid represents a point in the file tree.
* There are three components, all derived from the handle:
Fsys *fsys;
Nfs3Status ok;
Nfs3Handle h2, *h, *fh;
-
+
memset(fid, 0, sizeof *fid);
domount = 1;
n->mfsys = fsys;
fsysroot(fsys, &n->mfsyshandle);
}
-
+
/*
* Use inner handle.
*/
* Use fsys handle from tree or from handle.
* This assumes that fsyshandle was set by fidtohandle
* earlier, so it's not okay to reuse handles (except the root)
- * across sessions. The encryption above makes and
+ * across sessions. The encryption above makes and
* enforces the same restriction, so this is okay.
*/
fid->fsys = n->fsys;
_fidtohandle(Fid *fid, Nfs3Handle *h)
{
Cnode *n;
-
+
n = fid->cnode;
/*
* Record fsys handle in n, don't bother sending it to client
setrootfid(void)
{
Fid fid;
-
+
memset(&fid, 0, sizeof fid);
fid.cnode = config.ctree->root;
_fidtohandle(&fid, &root);
Nfs3Status ok;
Nfs3Handle xh;
int mode;
-
+
trace("lookup %.*lH %s\n", h->len, h->h, name);
mode = HWalk;
trace("lookup: handletofid %r\n");
return ok;
}
-
+
if(strcmp(name, ".") == 0){
fidtohandle(&fid, nh);
return Nfs3Ok;
* Walk down file system and cnode simultaneously.
* If dotdot and file system doesn't move, need to walk
* up cnode. Save the corresponding fsys handles in
- * the cnode as we walk down so that we'll have them
+ * the cnode as we walk down so that we'll have them
* for dotdotting back up.
*/
n = fid.cnode;
return ok;
}
fid.fsyshandle = xh;
- }
+ }
}else{
/*
* Walking dotdot. Ick.
/*
* Usually just go to n->parent.
- *
+ *
* If we're in a subtree of the mounted file system that
* isn't represented explicitly by the config tree (instead
* the black hole node represents the entire file tree),
n->parent->fsyshandle.len, n->parent->fsyshandle.h,
xh.len, xh.h);
}
-
+
if(n->isblackhole){
if(handlecmp(&n->parent->mfsyshandle, &xh) == 0)
n = n->parent;
{
Fid fid;
Nfs3Status ok;
-
+
trace("access %.*lH 0x%ux\n", h->len, h->h, want);
if((ok = handletofid(h, &fid, HAccess)) != Nfs3Ok)
return ok;
{
Fid fid;
Nfs3Status ok;
-
+
trace("readlink %.*lH\n", h->len, h->h);
if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
return ok;
{
Fid fid;
Nfs3Status ok;
-
+
trace("readfile %.*lH\n", h->len, h->h);
if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
return ok;
Fid fid;
Nfs3Status ok;
- trace("readdir %.*lH\n", h->len, h->h);
+ trace("readdir %.*lH\n", h->len, h->h);
if((ok = handletofid(h, &fid, HRead)) != Nfs3Ok)
return ok;
if(fid.fsys)
refreshdiskread(Cnode *n, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
{
char buf[128];
-
+
if(offset != 0){
*pcount = 0;
*peof = 1;
refreshconfigread(Cnode *n, u32int count, u64int offset, uchar **data, u32int *pcount, u1int *peof)
{
char buf[128];
-
+
if(offset != 0){
*pcount = 0;
*peof = 1;
*peof = 1;
return Nfs3Ok;
}
-
blob - d6d770bcffae924cab6bf356b0c82a1e98250665
blob + 50d9bb202fbb03a449cc23c87cd1746496f723f1
--- src/cmd/venti/copy.c
+++ src/cmd/venti/copy.c
havevisited(uchar score[VtScoreSize], int type)
{
ScoreTree a;
-
+
if(scoretree == nil)
return 0;
memmove(a.score, score, VtScoreSize);
if(memcmp(score, vtzeroscore, VtScoreSize) == 0 || memcmp(score, zeroscore, VtScoreSize) == 0)
return;
-
+
if(havevisited(score, type)){
nskip++;
return;
continue;
walk(e.score, e.type, e.type&VtTypeBaseMask, depth+1);
/*
- * Don't repack unless we're rewriting -- some old
+ * Don't repack unless we're rewriting -- some old
* vac files have psize==0 and dsize==0, and these
* get rewritten by vtentryunpack to have less strange
* block sizes. So vtentryunpack; vtentrypack does not
sysfatal("writing block %V (type %d): %r", score, type);
}
if(!rewrite && memcmp(score, nscore, VtScoreSize) != 0)
- sysfatal("not rewriting: wrote %V got %V", score, nscore);
+ sysfatal("not rewriting: wrote %V got %V", score, nscore);
if((type !=0 || base !=0) && verbose){
n = vtzerotruncate(type, buf, n);
fprint(2, " ");
fprint(2, "<- %V\n", score);
}
-
+
markvisited(score, type);
free(buf);
}
blob - fdad553e6ba9ebeb818882b912aaf982f7c49cb1
blob + 3bf6cee4e625b29f496d6f538e67a4e737fd8026
--- src/cmd/venti/devnull.c
+++ src/cmd/venti/devnull.c
fmtinstall('V', vtscorefmt);
fmtinstall('F', vtfcallfmt);
-
+
address = "tcp!*!venti";
ARGBEGIN{
}
threadexitsall(nil);
}
-
blob - 352b3cacc792c8d088bac7a7466b8e8286158708
blob + 53ec4bad1c488f96ce9ea6c30baedfb205e49cb3
--- src/cmd/venti/dump.c
+++ src/cmd/venti/dump.c
uchar *buf;
VtEntry e;
VtRoot root;
-
+
if(spaces[0] == 0)
memset(spaces, ' ', sizeof spaces-1);
indent*4, spaces, score, root.name, root.type, root.prev, root.blocksize);
dump(indent+1, root.score, VtDirType);
break;
-
+
case VtDirType:
Bprint(&bout, "%.*s%V dir n=%d\n", indent*4, spaces, score, n);
for(i=0; i*VtEntrySize<n; i++){
dump(indent+2, e.score, e.type);
}
break;
-
+
case VtDataType:
Bprint(&bout, "%.*s%V data n=%d", indent*4, spaces, score, n);
for(i=0; i<n; i++){
break;
}
out:
- free(buf);
+ free(buf);
}
blob - 7d94eef2c898c27e48844fe900700302dbf32cfb
blob + 846279fe7778518138605b68cea3d66bdc8aa9e7
--- src/cmd/venti/randtest.c
+++ src/cmd/venti/randtest.c
return x;
}
-
blob - 0a2018276829379400fc06b303a95a6ce58bf6d5
blob + 04ed8e32fb72240602b04f785c638c8dc8b9ac52
--- src/cmd/venti/readlist.c
+++ src/cmd/venti/readlist.c
if((i & 1) == 0)
c <<= 4;
-
+
score[i>>1] |= c;
}
return 0;
blob - ee954a32bac73877351ef2496153f7e34f1283e0
blob + a499aa1e94ab46a6de41c851e85bb70ed34954db
--- src/cmd/venti/ro.c
+++ src/cmd/venti/ro.c
VtReq *r;
uchar *buf;
int n;
-
+
r = v;
buf = vtmalloc(r->tx.count);
if((n=vtread(z, r->tx.score, r->tx.blocktype, buf, r->tx.count)) < 0){
fmtinstall('F', vtfcallfmt);
fmtinstall('V', vtscorefmt);
-
+
address = "tcp!*!venti";
ventiaddress = nil;
-
+
ARGBEGIN{
case 'v':
verbose++;
}
threadexitsall(nil);
}
-
blob - ddeb3b4c0d46ec8dd446ac2459e12bbfd219a49a
blob + 7df1fc4b483df714f35756b84eb6043f27e41933
--- src/cmd/venti/srv/arena.c
+++ src/cmd/venti/srv/arena.c
return -1;
if(a->used > b->used)
return 1;
-
+
/* suspect tests - why order this way? (no one cares) */
if(a->clumps < b->clumps)
return -1;
return -1;
if(a->sealed > b->sealed)
return 1;
-
+
/* everything matches */
return 0;
}
sha1(b->data, bs-VtScoreSize, nil, &s);
sha1(zeroscore, VtScoreSize, nil, &s);
sha1(nil, 0, score, &s);
-
+
/*
* check for no checksum or the same
*/
|| arena->blocksize != head.blocksize
|| arena->size + 2 * arena->blocksize != head.size){
if(namecmp(arena->name, head.name)!=0)
- logerr(ECorrupt, "arena tail name %s head %s",
+ logerr(ECorrupt, "arena tail name %s head %s",
arena->name, head.name);
else if(arena->clumpmagic != head.clumpmagic)
logerr(ECorrupt, "arena tail clumpmagic 0x%lux head 0x%lux",
/*
- * For index entry readahead purposes, the arenas are
+ * For index entry readahead purposes, the arenas are
* broken into smaller subpieces, called clump info groups
* or cigs. Each cig has ArenaCIGSize clumps (ArenaCIGSize
* is chosen to make the index entries take up about half
* a megabyte). The index entries do not contain enough
* information to determine what the clump index is for
* a given address in an arena. That info is needed both for
- * figuring out which clump group an address belongs to
+ * figuring out which clump group an address belongs to
* and for prefetching a clump group's index entries from
* the arena table of contents. The first time clump groups
* are accessed, we scan the entire arena table of contents
- * (which might be 10s of megabytes), recording the data
+ * (which might be 10s of megabytes), recording the data
* offset of each clump group.
*/
-/*
+/*
* load clump info group information by scanning entire toc.
*/
static void
return;
// fprint(2, "loadcig %s\n", arena->name);
-
+
ncig = (arena->memstats.clumps+ArenaCIGSize-1) / ArenaCIGSize;
if(ncig == 0){
arena->cig = vtmalloc(1);
}
}
vtfree(ci);
-
+
arena->ncig = ncig;
arena->cig = cig;
fprint(2, "asking for too few entries\n");
return -1;
}
-
+
qlock(&arena->lock);
if(arena->cig == nil)
loadcig(arena);
qunlock(&arena->lock);
return -1;
}
-
+
addr = 0;
base = g*ArenaCIGSize;
limit = base + ArenaCIGSize;
blob - 42418d1c93493a1f8b5f369b7ceb71cdf8e2eb4b
blob + d50b1777861ecb8f34eb6d077613b3a7caf77a37
--- src/cmd/venti/srv/bloom.c
+++ src/cmd/venti/srv/bloom.c
/*
* Bloom filter tracking which scores are present in our arenas
- * and (more importantly) which are not.
+ * and (more importantly) which are not.
*/
#include "stdinc.h"
bloominit(Bloom *b, vlong vsize, u8int *data)
{
ulong size;
-
+
size = vsize;
if(size != vsize){ /* truncation */
werrstr("bloom data too big");
return -1;
}
-
+
b->size = size;
b->nhash = 32; /* will be fixed by caller on initialization */
if(data != nil)
if(unpackbloomhead(b, data) < 0)
return -1;
-
+
b->bitmask = (b->size<<3) - 1;
b->data = data;
return 0;
{
uchar buf[512];
Bloom *b;
-
+
b = vtmallocz(sizeof *b);
if(readpart(p, 0, buf, sizeof buf) < 0)
return nil;
resetbloom(Bloom *b)
{
uchar *data;
-
+
data = vtmallocz(b->size);
b->data = data;
if(b->size == MaxBloomSize) /* 2^32 overflows ulong */
uint ones;
uchar *data;
u32int *a;
-
+
data = vtmallocz(b->size);
if(readpart(b->part, 0, data, b->size) < 0){
vtfree(b);
n = b->size/4;
ones = 0;
for(i=0; i<n; i++)
- ones += countbits(a[i]);
+ ones += countbits(a[i]);
addstat(StatBloomOnes, ones);
if(b->size == MaxBloomSize) /* 2^32 overflows ulong */
addstat(StatBloomBits, b->size*8-1);
else
addstat(StatBloomBits, b->size*8);
-
+
return 0;
}
if(ignorebloom)
return 1;
-
+
rlock(&b->lk);
r = _inbloomfilter(b, score);
runlock(&b->lk);
if(b == nil || b->data == nil)
return;
-
+
rlock(&b->lk);
qlock(&b->mod);
for(i=0; i<n; i++)
int ret;
Bloom *b;
- threadsetname("bloomwriteproc");
+ threadsetname("bloomwriteproc");
b = v;
for(;;){
recv(b->writechan, 0);
{
b->writechan = chancreate(sizeof(void*), 0);
b->writedonechan = chancreate(sizeof(ulong), 0);
- vtproc(bloomwriteproc, b);
+ vtproc(bloomwriteproc, b);
}
blob - 95fb74b72eb6c90b455d5867dd76a1e6f715d43b
blob + faf4b41446ee533c175a9682c04fd42a34499ecf
--- src/cmd/venti/srv/buildindex.c
+++ src/cmd/venti/srv/buildindex.c
};
typedef struct IEntryBuf IEntryBuf;
-struct IEntryBuf
+struct IEntryBuf
{
IEntry ie[100];
int nie;
u32int bcmem, imem;
Config conf;
Part *p;
-
+
maxdisks = 100000;
ventifmtinstall();
imem = 256*1024*1024;
close(fd);
}
}
-
+
/*
* need a block for every arena
*/
bcmem = maxblocksize * (mainindex->narenas + 16);
if(0) fprint(2, "initialize %d bytes of disk block cache\n", bcmem);
initdcache(bcmem);
-
+
totalclumps = 0;
for(i=0; i<ix->narenas; i++)
totalclumps += ix->arenas[i]->diskstats.clumps;
-
+
totalbuckets = 0;
for(i=0; i<ix->nsects; i++)
totalbuckets += ix->sects[i]->blocks;
vtproc(isectproc, ix->sects[i]);
}
}
-
+
for(i=0; i<nisect; i++)
if(isect[i])
fprint(2, "warning: did not find index section %s\n", isect[i]);
if(ix->bloom && writebloom(ix->bloom) < 0)
fprint(2, "writing bloom filter: %r\n");
- fprint(2, "%T done arenaentries=%,lld indexed=%,lld (nskip=%,lld)\n",
+ fprint(2, "%T done arenaentries=%,lld indexed=%,lld (nskip=%,lld)\n",
arenaentries, indexentries, skipentries);
threadexitsall(nil);
}
shouldprocess(ISect *is)
{
int i;
-
+
if(nisect == 0)
return 1;
add(u64int *a, u64int n)
{
static Lock l;
-
+
lock(&l);
*a += n;
unlock(&l);
IEntryBuf *buf, *b;
uchar *score;
ScoreBuf sb;
-
+
p = v;
threadsetname("arenaproc %s", p->name);
buf = MKNZ(IEntryBuf, ix->nsects);
if(a->part != p)
continue;
if(a->memstats.clumps)
- fprint(2, "%T arena %s: %d entries\n",
+ fprint(2, "%T arena %s: %d entries\n",
a->name, a->memstats.clumps);
/*
- * Running the loop backwards accesses the
+ * Running the loop backwards accesses the
* clump info blocks forwards, since they are
* stored in reverse order at the end of the arena.
* This speeds things slightly.
}
add(&arenaentries, tot);
add(&skipentries, nskip);
-
+
for(i=0; i<ix->nsects; i++)
if(ix->sects[i]->writechan && buf[i].nie > 0)
send(ix->sects[i]->writechan, &buf[i]);
score2bucket(ISect *is, uchar *score)
{
u32int b;
-
+
b = hashbits(score, 32)/ix->div;
if(b < is->start || b >= is->stop){
fprint(2, "score2bucket: score=%V div=%d b=%ud start=%ud stop=%ud\n",
offset2bucket(ISect *is, u64int offset)
{
u32int b;
-
+
assert(is->blockbase <= offset);
offset -= is->blockbase;
b = offset/is->blocksize;
return is->blockbase + (u64int)b*is->blocksize;
}
-/*
+/*
* IEntry buffers to hold initial round of spraying.
*/
typedef struct Buf Buf;
bflush(Buf *buf)
{
u32int bufsize;
-
+
if(buf->woffset >= buf->eoffset)
sysfatal("buf index chunk overflow - need bigger index");
bufsize = buf->ep - buf->bp;
};
/*
- * Index entry pool. Used when trying to shuffle around
+ * Index entry pool. Used when trying to shuffle around
* the entries in a big buffer into the corresponding M minibuffers.
* Sized to hold M*EntriesPerBlock entries, so that there will always
* either be room in the pool for another block worth of entries
- * or there will be an entire block worth of sorted entries to
+ * or there will be an entire block worth of sorted entries to
* write out.
*/
typedef struct IEntryLink IEntryLink;
{
int i;
u64int n;
-
+
n = 0;
for(i=0; i<p->nmbuf; i++)
n += p->mcount[i];
*/
static IPool*
-mkipool(ISect *isect, Minibuf *mbuf, u32int nmbuf,
+mkipool(ISect *isect, Minibuf *mbuf, u32int nmbuf,
u32int mbufbuckets, u32int bufsize)
{
u32int i, nentry;
uchar *data;
IPool *p;
IEntryLink *l;
-
+
nentry = (nmbuf+1)*bufsize / IEntrySize;
p = ezmalloc(sizeof(IPool)
+nentry*sizeof(IEntry)
+nmbuf*sizeof(IEntryLink*)
+nmbuf*sizeof(u32int)
+3*bufsize);
-
+
p->isect = isect;
p->mbufbuckets = mbufbuckets;
p->bufsize = bufsize;
return p;
}
-/*
+/*
* Add the index entry ie to the pool p.
* Caller must know there is room.
*/
l->next = p->mlist[x];
p->mlist[x] = l;
p->mcount[x]++;
-}
+}
/*
* Pull out a block containing as many
uchar *bp, *ep, *wp;
IEntryLink *l;
u32int n;
-
+
bp = p->wbuf;
ep = p->wbuf + p->bufsize;
n = 0;
ipoolloadblock(IPool *p, Minibuf *mb)
{
u32int i, n;
-
+
assert(mb->nentry > 0);
assert(mb->roffset >= mb->woffset);
assert(mb->roffset < mb->eoffset);
{
u32int bufsize;
Minibuf *mb;
-
+
mb = pool->mbuf+x;
bufsize = pool->bufsize;
mb->nwentry += ipoolgetbuf(pool, x);
if(mb->nentry > 0 && mb->roffset == mb->woffset){
assert(pool->nfree >= pool->bufsize/IEntrySize);
/*
- * There will be room in the pool -- we just
+ * There will be room in the pool -- we just
* removed a block worth.
*/
ipoolloadblock(pool, mb);
ipoolflush(IPool *pool)
{
u32int i;
-
+
for(i=0; i<pool->nmbuf; i++)
while(pool->mlist[i])
ipoolflush0(pool, i);
*/
/*
- * Compare two packed index entries.
+ * Compare two packed index entries.
* Usual ordering except break ties by putting higher
* index addresses first (assumes have duplicates
* due to corruption in the lower addresses).
{
int i;
uchar *a, *b;
-
+
a = (uchar*)va;
b = (uchar*)vb;
i = ientrycmp(a, b);
{
static uchar zero[MaxIoSize];
u32int n;
-
+
for(; o<e; o+=n){
n = sizeof zero;
if(o+n > e)
}
/*
- * Load a minibuffer into memory and write out the
+ * Load a minibuffer into memory and write out the
* corresponding buckets.
*/
static void
u64int o;
IBucket ib;
Part *part;
-
+
part = is->part;
buckdata = emalloc(is->blocksize);
-
+
if(mb->nwentry == 0)
return;
return;
}
assert(*(uint*)buf != 0xa5a5a5a5);
-
+
/*
* remove fragmentation due to IEntrySize
* not evenly dividing Bufsize
ep = buf + mb->nwentry*IEntrySize;
assert(ep <= buf+nbuf);
- /*
+ /*
* sort entries
*/
qsort(buf, mb->nwentry, IEntrySize, ientrycmpaddr);
IPool *ipool;
ISect *is;
Minibuf *mbuf, *mb;
-
+
is = v;
blocksize = is->blocksize;
nbucket = is->stop - is->start;
/*
* Three passes:
- * pass 1 - write index entries from arenas into
+ * pass 1 - write index entries from arenas into
* large sequential sections on index disk.
* requires nbuf * bufsize memory.
*
* requires nminibuf * bufsize memory.
*
* pass 3 - read each minibuf into memory and
- * write buckets out.
+ * write buckets out.
* requires entries/minibuf * IEntrySize memory.
- *
+ *
* The larger we set bufsize the less seeking hurts us.
- *
+ *
* The fewer sections and minibufs we have, the less
* seeking hurts us.
- *
- * The fewer sections and minibufs we have, the
+ *
+ * The fewer sections and minibufs we have, the
* more entries we end up with in each minibuf
- * at the end.
+ * at the end.
*
* Shoot for using half our memory to hold each
- * minibuf. The chance of a random distribution
- * getting off by 2x is quite low.
+ * minibuf. The chance of a random distribution
+ * getting off by 2x is quite low.
*
- * Once that is decided, figure out the smallest
+ * Once that is decided, figure out the smallest
* nminibuf and nsection/biggest bufsize we can use
* and still fit in the memory constraints.
*/
-
+
/* expected number of clump index entries we'll see */
xclump = nbucket * (double)totalclumps/totalbuckets;
-
+
/* number of clumps we want to see in a minibuf */
xminiclump = isectmem/2/IEntrySize;
-
+
/* total number of minibufs we need */
prod = (xclump+xminiclump-1) / xminiclump;
-
+
/* if possible, skip second pass */
if(!dumb && prod*MinBufSize < isectmem){
nbuf = prod;
}
}
add(&indexentries, n);
-
+
nn = 0;
for(i=0; i<nbuf; i++){
bflush(&buf[i]);
}
if(n != nn)
fprint(2, "isectproc bug: n=%ud nn=%ud\n", n, nn);
-
+
free(data);
fprint(2, "%T %s: reordering\n", is->part->name);
-
+
/*
* Rearrange entries into minibuffers and then
* split each minibuffer into buckets.
- * The minibuffer must be sized so that it is
+ * The minibuffer must be sized so that it is
* a multiple of blocksize -- ipoolloadblock assumes
* that each minibuf starts aligned on a blocksize
* boundary.
while(mb->nentry > 0){
if(ipool->nfree < epbuf){
ipoolflush1(ipool);
- /* ipoolflush1 might change mb->nentry */
+ /* ipoolflush1 might change mb->nentry */
continue;
}
assert(ipool->nfree >= epbuf);
}
free(data);
}
-
+
sendp(isectdonechan, is);
}
-
-
-
blob - d2cfe251c3d6697bf886d734761bd964d92e23cd
blob + 1a7e016c2e1e52ebea78559bbde76166cf2f2c0c
--- src/cmd/venti/srv/clumpstats.c
+++ src/cmd/venti/srv/clumpstats.c
initdcache(bcmem);
clumpstats(mainindex);
-
+
threadexitsall(0);
}
blob - 322f16ee165c4d01967f22a24ef73ca8351025ae
blob + 5abf8575f0aef54ed50e8fef9607f10171ccdd0c
--- src/cmd/venti/srv/cmparenas.c
+++ src/cmd/venti/srv/cmparenas.c
Arena arena;
vlong baseoff, lo, hi, off;
int clumpmax;
-
+
off = seek(fd, 0, 1);
seek(fd, off + head->size - head->blocksize, 0);
if(readblock(fd, data, head->blocksize) < 0){
lo = hi;
fprint(2, "\t%llx-%llx: clumps (%llx)\n", lo, hi, hi - lo);
fprint(2, "\t%llx-%llx: tail\n", hi, hi + head->blocksize);
-
+
fprint(2, "arena:\n");
printarena(2, &arena);
return 0;
if(printheader(name, &head, fd) < 0)
return;
-
+
/*
* now we know how much to read
* read everything but the last block, which is special
shouldcheck(char *name, char **s, int n)
{
int i;
-
+
if(n == 0)
return 1;
readap(int fd, ArenaPart *ap)
{
char *table;
-
+
if(preadblock(fd, data, 8192, PartBlank) < 0)
sysfatal("read arena part header: %r");
if(unpackarenapart(ap, data) < 0)
vlong start, stop;
ArenaPart ap;
ArenaPart ap1;
-
+
ventifmtinstall();
blocksize = MaxIoSize;
ARGBEGIN{
blob - 8c29fe95f8654fdfe5f9a81e65ac044b67b761df
blob + e7dde3e4d86fc0fb45cf4cb7447359c7a919a92f
--- src/cmd/venti/srv/config.c
+++ src/cmd/venti/srv/config.c
{
Part *part;
ISect *is;
-
+
if(0) fprint(2, "configure index section in %s\n", file);
part = initpart(file, ORDWR|ODIRECT);
needmainindex(void)
{
}
-
blob - e6a6cbfe1f3aece6537af789d75b16a085142289
blob + 90aefbecd13c0700e12055a4d7549935f7a8b879
--- src/cmd/venti/srv/conv.c
+++ src/cmd/venti/srv/conv.c
* all the existing version 4 arenas too.
*
* To maintain backwards compatibility with existing venti
- * installations using the older format, we define that if
+ * installations using the older format, we define that if
* memstats == diskstats, then the extension fields are not
* included (see packarena below). That is, only partially
* indexed arenas have these fields. Fully indexed arenas
p += U64Size;
arena->memstats.sealed = U8GET(p);
p += U8Size;
-
+
/*
* 2008/4/2
* Packarena (below) used to have a bug in which it would
p += U64Size;
U8PUT(p, arena->diskstats.sealed);
p += U8Size;
-
+
/*
* Extension fields; see above.
*/
p += U32Size;
U32PUT(p, arena->memstats.cclumps);
p += U32Size;
- U64PUT(p, arena->memstats.used, t32);
+ U64PUT(p, arena->memstats.used, t32);
p += U64Size;
U64PUT(p, arena->memstats.uncsize, t32);
p += U64Size;
b->data = buf + IBucketSize;
if(magic && magic != U32GET(buf+U16Size))
b->n = 0;
-}
+}
void
packibucket(IBucket *b, u8int *buf, u32int magic)
return -1;
}
p += U32Size;
-
+
m = U32GET(p);
if(m != BloomVersion){
seterr(ECorrupt, "bloom filter has wrong version %ud expected %ud", (uint)m, (uint)BloomVersion);
blob - f47d01a12f60382bd877ba126295f7a2496cc021
blob + 68e6c8f5ab7ca7f5d8bc86c6ac94435769aedf70
--- src/cmd/venti/srv/dat.h
+++ src/cmd/venti/srv/dat.h
ArenaPartMagic = 0xa9e4a5e7U, /* arena partition header */
ArenaMagic = 0xf2a14eadU, /* arena trailer */
ArenaHeadMagic = 0xd15c4eadU, /* arena header */
-
+
BloomMagic = 0xb1004eadU, /* bloom filter header */
BloomMaxHash = 32,
IEntryAddrOff = VtScoreSize + U32Size + U16Size,
MaxClumpBlocks = (VtMaxLumpSize + ClumpSize + (1 << ABlockLog) - 1) >> ABlockLog,
-
+
IcacheFrac = 1000000, /* denominator */
SleepForever = 1000000000, /* magic value for sleep time */
DirtyArenaCib,
DirtyArenaTrailer,
DirtyMax,
-
+
ArenaCIGSize = 10*1024, // about 0.5 MB worth of IEntry.
VentiZZZZZZZZ
u32int used2;
u32int ref; /* reference count */
RWLock lock; /* for access to data only */
- Channel *writedonechan;
+ Channel *writedonechan;
void* chanbuf[1]; /* buffer for the chan! */
};
};
/*
- * Statistics kept in the tail.
+ * Statistics kept in the tail.
*/
struct ATailStats
{
u32int ctime; /* first time a block was written */
u32int wtime; /* last time a block was written */
u32int clumpmagic;
-
+
ArenaCIG *cig;
int ncig;
};
Bloom *bloom; /* bloom filter */
/*
- * fields stored in config file
+ * fields stored in config file
*/
u32int version;
char name[ANameSize]; /* text label */
AMap *smap; /* mapping of buckets to index sections */
int narenas;
AMap *amap; /* mapping from index addesses to arenas */
-
+
QLock writing;
};
/* on disk data - 32 bytes*/
u8int score[VtScoreSize];
IAddr ia;
-
+
IEntry *nexthash;
IEntry *nextdirty;
IEntry *next;
StatSumRead,
StatSumReadBytes,
-
+
StatCigLoad,
StatCigLoadTime,
#pragma varargck type "V" uchar*
#define ODIRECT 0
#endif
-
blob - a50ef0c5c2bbc4b71eae3778d0e25c71316f430f
blob + f4f008988cf91db052073a01987498deb7de1624
--- src/cmd/venti/srv/dcache.c
+++ src/cmd/venti/srv/dcache.c
/*
* Disk cache.
- *
+ *
* Caches raw disk blocks. Getdblock() gets a block, putdblock puts it back.
* Getdblock has a mode parameter that determines i/o and access to a block:
* if mode is OREAD or ORDWR, it is read from disk if not already in memory.
* If mode is ORDWR or OWRITE, it is locked for exclusive use before being returned.
* It is *not* marked dirty -- once changes have been made, they should be noted
- * by using dirtydblock() before putdblock().
+ * by using dirtydblock() before putdblock().
*
- * There is a global cache lock as well as a lock on each block.
+ * There is a global cache lock as well as a lock on each block.
* Within a thread, the cache lock can be acquired while holding a block lock,
* but not vice versa; and a block cannot be locked if you already hold the lock
* on another block.
- *
+ *
* The flush proc writes out dirty blocks in batches, one batch per dirty tag.
* For example, the DirtyArena blocks are all written to disk before any of the
* DirtyArenaCib blocks.
*
- * This code used to be in charge of flushing the dirty index blocks out to
+ * This code used to be in charge of flushing the dirty index blocks out to
* disk, but updating the index turned out to benefit from extra care.
* Now cached index blocks are never marked dirty. The index.c code takes
* care of updating them behind our back, and uses _getdblock to update any
getdblock(Part *part, u64int addr, int mode)
{
DBlock *b;
-
+
b = _getdblock(part, addr, mode, 1);
if(mode == OREAD || mode == ORDWR)
addstat(StatDcacheRead, 1);
unchain(DBlock *b)
{
ulong h;
-
+
/*
* unchain the block
*/
emptydcache(void)
{
DBlock *b;
-
+
qlock(&dcache.lock);
while(dcache.nheap > 0){
b = dcache.heap[0];
assert(b<=p && p<eb);
recvp((*p)->writedonechan);
}
-
+
/*
* Flush the partitions that have been written to.
*/
blob - d43b64c7fe21698d033c2a2c9e44e2bede1ebe09
blob + 0315425c4ace0a243675924f7d32e598dbcb4667
--- src/cmd/venti/srv/disksched.c
+++ src/cmd/venti/srv/disksched.c
ulong t;
vlong cflush;
Stats *prev;
-
+
/*
* no locks because all the data accesses are atomic.
*/
/* # entries written to index cache */
nwrite = stats.n[StatIcacheWrite] - prev->n[StatIcacheWrite];
-
+
/* # dirty entries in index cache */
ndirty = stats.n[StatIcacheDirty] - prev->n[StatIcacheDirty];
-
+
/* # entries flushed to disk */
nflush = nwrite - ndirty;
-
+
/* want to stay around 70% dirty */
tdirty = (vlong)stats.n[StatIcacheSize]*700/1000;
-
+
/* assume nflush*icachesleeptime is a constant */
cflush = (vlong)nflush*(icachesleeptime+1);
-
+
/* computer number entries to write in next minute */
toflush = nwrite + (stats.n[StatIcacheDirty] - tdirty);
-
+
/* schedule for that many */
if(toflush <= 0 || cflush/toflush > 100000)
icachesleeptime = SleepForever;
}
lasttime[level] = time(0);
}
-
blob - d7ae41d39d43e5e306c88f3f20174ed80064918b
blob + 8fc4f55db31b5f2ea9c4d340837676d171c31039
--- src/cmd/venti/srv/fixarenas.c
+++ src/cmd/venti/srv/fixarenas.c
*
* The rule here (hopefully followed!) is that block corruption
* only ever has a local effect -- there are no blocks that you
- * can wipe out that will cause large portions of
+ * can wipe out that will cause large portions of
* uncorrupted data blocks to be useless.
*/
K = 1024,
M = 1024*1024,
G = 1024*1024*1024,
-
+
Block = 4096,
};
zfmt(Fmt *fmt)
{
vlong x;
-
+
x = va_arg(fmt->args, vlong);
if(x == 0)
return fmtstrcpy(fmt, "0");
{
uint t;
char buf[30];
-
+
t = va_arg(fmt->args, uint);
strcpy(buf, ctime(t));
buf[28] = 0;
memset(buf, 0xFB, len);
return buf;
}
-
+
if(offset+len > partend){
memset(buf, 0xFB, len);
len = partend - offset;
if(readpart(part, offset, buf, len) >= 0)
return buf;
-
+
/*
* The read failed. Clear the buffer to nonsense, and
* then try reading in smaller pieces. If that fails,
sbdebug(Shabuf *sb, char *file)
{
int fd;
-
+
if(sb->fd > 0){
close(sb->fd);
sb->fd = 0;
len -= x;
}
assert(sb->offset == offset);
-
+
if(sb->fd > 0)
pwrite(sb->fd, p, len, offset - sb->r0);
sb->offset += len;
return;
}
-
+
/* save state every 4M so we can roll back quickly */
o = offset - sb->r0;
while(len > 0){
}
sb->hist[x] = sb->state;
}
- }
+ }
}
void
{
static uchar dbuf[4*M];
int n;
-
+
while(sb->offset < eoffset){
n = sizeof dbuf;
if(sb->offset+n > eoffset)
int x;
vlong o;
Dir d;
-
+
if(!sb->rollback || !sb->r0){
print("cannot rollback sha\n");
return;
sb->state = sb->hist[x];
sb->offset = sb->r0 + x*4*M;
assert(sb->offset <= offset);
-
+
if(sb->fd > 0){
nulldir(&d);
d.length = sb->offset - sb->r0;
/*
* If we're fixing arenas, then editing this memory edits the disk!
- * It will be written back out as new data is paged in.
+ * It will be written back out as new data is paged in.
*/
uchar buf[4*M];
uchar sbuf[4*M];
memset(buf, 0xFB, sizeof buf);
return buf;
}
-
+
if(offset+len > partend){
memset(buf, 0xFB, sizeof buf);
len = partend - offset;
vlong ooff;
int olen;
enum { MinBlock = 4*K, MaxBlock = 8*K };
-
+
if(0)
if(bufoffset <= offset && offset+len <= bufoffset+buflen){
memset(buf+(offset-bufoffset), 0, len);
return;
}
-
+
ooff = bufoffset;
olen = buflen;
-
+
i = offset%MinBlock;
if(i+len < MaxBlock){
pagein(offset-i, (len+MinBlock-1)&~(MinBlock-1));
vlongcmp(const void *va, const void *vb)
{
vlong a, b;
-
+
a = *(vlong*)va;
b = *(vlong*)vb;
if(a < b)
1, "sealed",
0
};
-
+
Info tailinfo4a[] = {
/* tailinfo 4 */
4, "magic",
1, "mem.sealed",
0
};
-
+
Info tailinfo5[] = {
4, "magic",
D|4, "version",
1, "mem.sealed",
0
};
-
+
void
showdiffs(uchar *want, uchar *have, int len, Info *info)
{
int n;
-
+
while(len > 0 && (n=info->len&N) > 0){
if(memcmp(have, want, n) != 0){
switch(info->len){
break;
case S|ANameSize:
print("\t%s: correct=%s disk=%.*s\n",
- info->name, (char*)want,
+ info->name, (char*)want,
utfnlen((char*)have, ANameSize-1),
(char*)have);
break;
uchar *p, *ep, *sp;
u64int diff[100], head[20], tail[20];
u64int offset, bestdiff;
-
+
ap.version = ArenaPartVersion;
if(arenasize == 0 || ap.blocksize == 0){
}
if(nhead < 3 && ntail < 3)
sysfatal("too few intact arenas: %d heads, %d tails", nhead, ntail);
-
- /*
+
+ /*
* Arena size is likely the most common
* inter-head or inter-tail spacing.
*/
}
}
p = pagein(ap.arenabase, Block);
- print("arena base likely %z%s\n", (vlong)ap.arenabase,
+ print("arena base likely %z%s\n", (vlong)ap.arenabase,
u32(p)!=ArenaHeadMagic ? " (but no arena head there)" : "");
ap.tabsize = ap.arenabase - ap.tabbase;
uchar score[VtScoreSize], *bp;
Unwhack uw;
uchar ubuf[70*1024];
-
+
bp = p;
magic = u32(p);
if(magic == 0)
return 0;
}
p += cl->info.size;
-
+
/* it all worked out in the end */
*pmagic = magic;
return p - bp;
ltreewalk(int *p, uchar *score)
{
int i;
-
+
for(;;){
if(*p == -1)
return p;
addcibuf(ClumpInfo *ci, vlong corrupt)
{
Cit *cit;
-
+
if(ncibuf == mcibuf){
mcibuf += 131072;
cibuf = vtrealloc(cibuf, mcibuf*sizeof cibuf[0]);
addcicorrupt(vlong len)
{
static ClumpInfo zci;
-
+
addcibuf(&zci, len);
}
{
int i;
int p;
-
+
p = ciroot;
for(;;){
if(p == -1)
sealedarena(uchar *p, int blocksize)
{
int v, n;
-
+
v = u32(p+4);
switch(v){
default:
okayname(char *name, int n)
{
char buf[20];
-
+
if(nameok(name) < 0)
return 0;
sprint(buf, "%d", n);
if(n == 0)
buf[0] = 0;
- if(strlen(name) < strlen(buf)
+ if(strlen(name) < strlen(buf)
|| strcmp(name+strlen(name)-strlen(buf), buf) != 0)
return 0;
return 1;
int i, j, per;
uchar *p, *sp;
ClumpInfo *bci, *ci;
-
+
per = arena->blocksize/ClumpInfoSize;
bci = vtmalloc(nci*sizeof bci[0]);
ci = bci;
{
int i, j, per;
uchar *p, *sp;
-
+
per = arena->blocksize/ClumpInfoSize;
offset += arena->size - arena->blocksize;
p = sp = nil;
if(offset0+arena->size > partend)
arena->size = partend - offset0;
head->size = arena->size;
-
+
arena->blocksize = ap.blocksize;
head->blocksize = arena->blocksize;
-
- /*
+
+ /*
* Look for clump magic and name in head/tail blocks.
* All the other info we will reconstruct just in case.
*/
strcpy(head->name, ohead.name);
}
- p = pagein(offset0+arena->size-arena->blocksize,
+ p = pagein(offset0+arena->size-arena->blocksize,
arena->blocksize);
memset(&oarena, 0, sizeof oarena);
if(unpackarena(&oarena, p) >= 0){
strcpy(lastbase, arena->name);
sprint(dname, "%d", anum);
lastbase[strlen(lastbase)-strlen(dname)] = 0;
-
+
/* Was working in arena, now copy to head. */
head->version = arena->version;
memmove(head->name, arena->name, sizeof head->name);
shahead(Shabuf *sb, vlong offset0, ArenaHead *head)
{
uchar headbuf[MaxDiskBlock];
-
+
sb->offset = offset0;
memset(headbuf, 0, sizeof headbuf);
packarenahead(head, headbuf);
newclumpmagic(int version)
{
u32int m;
-
+
if(version == ArenaVersion4)
return _ClumpMagic;
do{
ClumpInfo *bci, *ci, *eci, *xci;
Cit *bcit, *cit, *ecit;
Shabuf oldsha, newsha;
-
+
/*
* We expect to find an arena, with data, between offset
* and offset+arenasize. With any luck, the data starts at
loadarenabasics(offset0, anum, head, arena);
/* start the clump hunt */
-
+
clumps = 0;
totalcorrupt = 0;
sealing = 1;
* grow clump info blocks if needed.
*/
if(verbose > 1)
- print("\tclump %d: %d %V at %#llux+%#ux (%d)\n",
+ print("\tclump %d: %d %V at %#llux+%#ux (%d)\n",
clumps, cl.info.type, cl.info.score, offset, n, n);
addcibuf(&cl.info, 0);
if(minclumps%ncib == 0)
arena->diskstats.cclumps++;
arena->diskstats.uncsize += cl.info.uncsize;
arena->wtime = cl.time;
-
+
/*
* Move to next clump.
*/
pageout();
if(verbose)
- print("readable clumps: %d; min. directory entries: %d\n",
+ print("readable clumps: %d; min. directory entries: %d\n",
clumps, minclumps);
arena->diskstats.used = lastclumpend - boffset;
leaked = eoffset - lastclumpend;
sbupdate(&oldsha, dbuf, toffset, arena->blocksize);
sbscore(&oldsha, oldscore);
}
-
+
/*
* If we still don't know the clump magic, the arena
- * must be empty. It still needs a value, so make
+ * must be empty. It still needs a value, so make
* something up.
*/
if(arena->version == 0)
v = offset0 + arena->size - arena->blocksize;
clumps = (v-lastclumpend)/arena->blocksize * ncib;
}
-
+
if(clumps < minclumps)
print("cannot happen?\n");
* The tricky part is handling the corrupt sections of arena.
* If possible, we remark just the affected directory entries
* rather than slide everything down.
- *
+ *
* Allocate clumps+1 blocks and check that we don't need
* the last one at the end.
*/
eci = bci+clumps+1;
bcit = cibuf;
ecit = cibuf+ncibuf;
-
+
smart = 0; /* Somehow the smart code doesn't do corrupt clumps right. */
Again:
nbad = 0;
if(clumpinfocmp(&cit->ci, ci) != 0){
if(verbose && (smart || verbose>1)){
print("clumpinfo %d\n", (int)(ci-bci));
- print("\twant: %d %d %d %V\n",
+ print("\twant: %d %d %d %V\n",
cit->ci.type, cit->ci.size,
cit->ci.uncsize, cit->ci.score);
- print("\thave: %d %d %d %V\n",
- ci->type, ci->size,
+ print("\thave: %d %d %d %V\n",
+ ci->type, ci->size,
ci->uncsize, ci->score);
}
*ci = cit->ci;
smart = 0;
goto Again;
}
-
+
assert(ci <= eci);
arena->diskstats.clumps = ci-bci;
eoffset = writeci(offset0, arena, bci, ci-bci);
arena->memstats = arena->diskstats;
if(sealing && fix){
uchar tbuf[MaxDiskBlock];
-
+
sbdiskhash(&newsha, toffset);
memset(tbuf, 0, sizeof tbuf);
packarena(arena, tbuf);
char buf[1000];
vlong o, e;
int fd, n;
-
+
snprint(buf, sizeof buf, "%s.%d", dumpbase, anum);
if((fd = create(buf, OWRITE, 0666)) < 0){
fprint(2, "create %s: %r\n", buf);
ArenaHead head;
Info *fmt, *fmta;
int sz;
-
+
print("# arena %d: offset %#llux\n", anum, offset);
if(offset >= partend){
p = pagein(offset, arena.blocksize);
if(memcmp(dbuf, p, arena.blocksize) != 0){
print("on-disk arena header incorrect\n");
- showdiffs(dbuf, p, arena.blocksize,
+ showdiffs(dbuf, p, arena.blocksize,
arena.version==ArenaVersion4 ? headinfo4 : headinfo5);
}
memmove(p, dbuf, arena.blocksize);
-
+
memset(dbuf, 0, sizeof dbuf);
packarena(&arena, dbuf);
if(arena.diskstats.sealed)
print("\t disk=%V\n", p+arena.blocksize-VtScoreSize);
}
if(fix && scorecmp(p+arena.blocksize-VtScoreSize, score) != 0){
- print("%ssealing arena%s: %V\n",
+ print("%ssealing arena%s: %V\n",
oarena.diskstats.sealed ? "re" : "",
- scorecmp(oldscore, score) == 0 ?
+ scorecmp(oldscore, score) == 0 ?
"" : " after changes", score);
}
}
memmove(p, dbuf, arena.blocksize);
-
+
pageout();
}
ArenaHead h;
AMapN *an;
AMap *m;
-
+
an = vtmallocz(sizeof *an);
for(o=ap.arenabase; o<partend; o+=arenasize){
p = pagein(o, Block);
strcpy(m->name, h.name);
}
}
- return an;
+ return an;
}
void
int i, len;
AMapN *an;
Fmt fmt;
-
+
an = buildamap();
fmtstrinit(&fmt);
fmtprint(&fmt, "%ud\n", an->n);
(vlong)len, (vlong)ap.tabsize);
len = ap.tabsize;
}
-
+
if(ap.tabsize >= 4*M){ /* can't happen - max arenas is 2000 */
print("arena partition map *way* too long\n");
return;
threadmain(int argc, char **argv)
{
int mode;
-
+
mode = OREAD;
- readonly = 1;
+ readonly = 1;
ARGBEGIN{
case 'U':
unseal = 1;
default:
usage();
}ARGEND
-
+
if(argc != 1 && argc != 2)
usage();
file = argv[0];
-
+
ventifmtinstall();
fmtinstall('z', zfmt);
fmtinstall('t', tfmt);
quotefmtinstall();
-
+
part = initpart(file, mode|ODIRECT);
if(part == nil)
sysfatal("can't open %s: %r", file);
partend = part->size;
-
+
if(isonearena()){
checkarena(0, -1);
threadexitsall(nil);
checkmap();
threadexitsall(nil);
}
-
blob - 76677871f4d4bffad8bf89afb6c2757fa39813a8
blob + db08b91a1aa98be082579af1ed439d4a9dccdff8
--- src/cmd/venti/srv/fmtbloom.c
+++ src/cmd/venti/srv/fmtbloom.c
vlong bits, size, size2;
int nhash;
vlong nblocks;
-
+
ventifmtinstall();
statsinit();
if(size == 0)
size = part->size;
-
+
if(size < 1024*1024)
sysfatal("bloom filter too small");
}
/*
- * optimal is to use ln 2 times as many hash functions as we have bits per blocks.
+ * optimal is to use ln 2 times as many hash functions as we have bits per blocks.
*/
bits = (8*size)/nblocks;
nhash = bits*7/10;
blob - db12c3d9a98fcf8efb4ee86cff891da6c95647fd
blob + f43363693e42bc5ac7e66e53f2b617e3fa28ccfc
--- src/cmd/venti/srv/graph.c
+++ src/cmd/venti/srv/graph.c
allocrepl(ulong color)
{
Memimage *m;
-
+
m = allocmemimage(Rect(0,0,1,1), RGB24);
memfillcolor(m, color);
m->flags |= Frepl;
{
static int first = 1;
int i;
-
+
if(!first)
return;
-
+
first = 0;
memimageinit();
#ifdef PLAN9PORT
{
char buf[30];
Point w;
-
+
mklabel(buf, n);
w = memsubfontwidth(smallfont, buf);
memimagestring(m, Pt(p.x-5-w.x, p.y), memblack, ZP, smallfont, buf);
Statbin *b, bin[2000]; /* 32 kB, but whack is worse */
needstack(8192); /* double check that bin didn't kill us */
-
+
if(g->wid <= MinWidth)
g->wid = DefaultWidth;
if(g->ht <= MinHeight)
g->fill = ((uint)(uintptr)g->arg>>8)%nelem(lofill);
if(g->fill > nelem(lofill))
g->fill %= nelem(lofill);
-
+
nbin = g->wid - (Left+Right);
binstats(g->fn, g->arg, g->t0, g->t1, bin, nbin);
}
r = Rect(Left, Top, g->wid-Right, g->ht-Bottom);
memfillcolor(m, DTransparent);
-
+
/* x axis */
memimagedraw(m, Rect(r.min.x, r.max.y, r.max.x, r.max.y+1), black, ZP, memopaque, ZP, S);
drawlabel(m, r.min, max);
if(min != 0)
drawlabel(m, Pt(r.min.x, r.max.y-smallfont->height), min);
-
+
/* actual data */
for(i=0; i<nbin; i++){
b = &bin[i];
blob - 8cf937d1b49ee6829f5e43041672bd1773322eda
blob + e477b815c3728a4c80568e8086c67b462daea6c3
--- src/cmd/venti/srv/hdisk.c
+++ src/cmd/venti/srv/hdisk.c
char *disk, *type;
Part *p;
int ret;
-
+
if(hsethtml(c) < 0)
return -1;
return 0;
}
freepart(p);
- return ret;
+ return ret;
}
static int
int i;
Index *ix;
Part *p;
-
+
hprint(&c->hout, "<h1>venti disks</h1>\n");
hprint(&c->hout, "<pre>\n");
ix = mainindex;
{
uchar *blk;
char *table;
-
+
blk = vtmalloc(8192);
if(readpart(p, PartBlank, blk, 8192) != 8192)
return nil;
{
int i, nline;
char *p, *q, *f[4], line[256];
-
+
nline = atoi(table);
p = strchr(table, '\n');
if(p)
hprint(&c->hout, "%r\n");
goto out;
}
-
+
hprint(&c->hout, "<pre>\n");
hprint(&c->hout, "version=%d blocksize=%d base=%d\n",
ap.version, ap.blocksize, ap.arenabase);
diskarenatable(c, disk, table);
goto out;
}
-
+
if(xfindarena(table, arenaname, &start, &end) < 0){
hprint(&c->hout, "no such arena %s\n", arenaname);
goto out;
}
-
+
hprint(&c->hout, "<h2>arena %s</h2>\n", arenaname);
hprint(&c->hout, "<pre>start=%#llx end=%#llx<pre>\n", start, end);
if(end < start || end - start < HeadSize){
hprint(&c->hout, "head:\n<pre>\n");
hprint(&c->hout, "version=%d name=%s blocksize=%d size=%#llx clumpmagic=%#ux\n",
- head.version, head.name, head.blocksize, head.size,
+ head.version, head.name, head.blocksize, head.size,
head.clumpmagic);
hprint(&c->hout, "</pre><br><br>\n");
scorecp(arena.score, blk+head.blocksize - VtScoreSize);
vtfree(blk);
-
+
hprint(&c->hout, "tail:\n<pre>\n");
hprint(&c->hout, "version=%d name=%s\n", arena.version, arena.name);
hprint(&c->hout, "ctime=%d %s\n", arena.ctime, fmttime(tbuf, arena.ctime));
}
unpackclumpinfo(&ci, blk+(i%arena->clumpmax)*ClumpInfoSize);
if(i/arena->clumpmax == cib || i%arena->clumpmax == 0){
- hprint(&c->hout, "%5d %6d %7d %V",
+ hprint(&c->hout, "%5d %6d %7d %V",
ci.type, ci.size, ci.uncsize, ci.score);
if(coff >= 0)
- hprint(&c->hout, " at <a href=\"%s&clump=%#llx&score=%V\">%#llx</a>",
+ hprint(&c->hout, " at <a href=\"%s&clump=%#llx&score=%V\">%#llx</a>",
base, coff, ci.score, coff);
if(i/arena->clumpmax != cib)
hprint(&c->hout, " <font size=-1><a href=\"%s&cib=%d\">more</a></font>", base, i/arena->clumpmax);
uchar xscore[VtScoreSize], score[VtScoreSize];
Unwhack uw;
int n;
-
+
if(scorestr){
if(vtparsescore(scorestr, nil, score) < 0){
hprint(&c->hout, "bad score %s: %r\n", scorestr);
hprint(&c->hout, "bad offset %#llx\n", off);
return -1;
}
-
+
off += arena->base;
blk = vtmalloc(ClumpSize + VtMaxLumpSize);
hprint(&c->hout, "<pre>type=%d size=%d uncsize=%d score=%V\n", cl.info.type, cl.info.size, cl.info.uncsize, cl.info.score);
hprint(&c->hout, "encoding=%d creator=%d time=%d %s</pre>\n", cl.encoding, cl.creator, cl.time, fmttime(err, cl.time));
-
+
if(cl.info.type == VtCorruptType)
hprint(&c->hout, "clump is marked corrupt<br>\n");
-
+
if(cl.info.size >= VtMaxLumpSize){
hprint(&c->hout, "clump too big\n");
goto error;
}
-
+
switch(cl.encoding){
case ClumpECompress:
blk2 = vtmalloc(VtMaxLumpSize);
scoremem(xscore, blk+ClumpSize, cl.info.size);
break;
}
-
+
hprint(&c->hout, "score=%V<br>\n", xscore);
if(scorestr && scorecmp(score, xscore) != 0)
hprint(&c->hout, "score does NOT match expected %V\n", score);
amap = mainindex->amap;
for(i=0; i<mainindex->narenas; i++)
- hprint(&c->hout, "%s %#llx %#llx\n",
+ hprint(&c->hout, "%s %#llx %#llx\n",
amap[i].name, amap[i].start, amap[i].stop);
}
hprint(&c->hout, "zero score\n");
return;
}
-
+
hprint(&c->hout, "<h2>index search %V</h2><pre>\n", score);
if(icachelookup(score, -1, &ia) < 0)
hprint(&c->hout, " icache: not found\n");
else
hprint(&c->hout, " icache: addr=%#llx size=%d type=%d blocks=%d\n",
ia.addr, ia.size, ia.type, ia.blocks);
-
+
if(loadientry(mainindex, score, -1, &ie) < 0)
hprint(&c->hout, " idisk: not found\n");
else
hprint(&c->hout, " idisk: addr=%#llx size=%d type=%d blocks=%d\n",
ie.ia.addr, ie.ia.size, ie.ia.type, ie.ia.blocks);
-
+
hprint(&c->hout, "</pre><h2>lookup %V</h2>\n", score);
hprint(&c->hout, "<pre>\n");
-
+
for(type=0; type < VtMaxType; type++){
hprint(&c->hout, "%V type %d:", score, type);
u = lookuplump(score, type);
else
hprint(&c->hout, " -cache");
putlump(u);
-
+
if(lookupscore(score, type, &ia) < 0){
hprint(&c->hout, " -lookup\n");
continue;
}
hprint(&c->hout, "\n lookupscore: addr=%#llx size=%d blocks=%d\n",
ia.addr, ia.size, ia.blocks);
-
+
arena = amapitoa(mainindex, ia.addr, &aa);
if(arena == nil){
hprint(&c->hout, " amapitoa failed: %r\n");
hprint(&c->hout, " loadclump failed: %r\n");
continue;
}
-
+
hprint(&c->hout, " loadclump: uncsize=%d type=%d score=%V\n",
cl.info.uncsize, cl.info.type, sc);
if(ia.size != cl.info.uncsize || ia.type != cl.info.type || scorecmp(score, sc) != 0){
continue;
}
}
-
+
if(hargstr(c, "brute", "")[0] == 'y'){
hprint(&c->hout, "</pre>\n");
hprint(&c->hout, "<h2>brute force arena search %V</h2>\n", score);
hprint(&c->hout, "<pre>\n");
-
+
for(i=0; i<mainindex->narenas; i++){
arena = mainindex->arenas[i];
hprint(&c->hout, "%s...\n", arena->name);
debugmem(HConnect *c)
{
Index *ix;
-
+
ix = mainindex;
hprint(&c->hout, "<h2>memory</h2>\n");
-
+
hprint(&c->hout, "<pre>\n");
hprint(&c->hout, "ix=%p\n", ix);
hprint(&c->hout, "\tarenas=%p\n", ix->arenas);
{
char *scorestr, *op;
u8int score[VtScoreSize];
-
+
if(hsethtml(c) < 0)
return -1;
hprint(&c->hout, "<h1>venti debug</h1>\n");
hprint(&c->hout, "no op\n");
return 0;
}
-
+
if(strcmp(op, "amap") == 0){
debugamap(c);
return 0;
debugread(c, score);
return 0;
}
-
+
hprint(&c->hout, "unknown op %s", op);
return 0;
}
blob - 42933920aa0f37e4d9e7835ae1b5acd99845327d
blob + 3da217cec571269b8f7e7e6776ade1a87592fc6a
--- src/cmd/venti/srv/hproc.c
+++ src/cmd/venti/srv/hproc.c
hproc(HConnect *c)
{
int r;
-
+
if((r = hsettext(c)) < 0)
return r;
hprint(&c->hout, "/proc only implemented on Plan 9\n");
hflush(&c->hout);
return 0;
}
-
blob - 83d80ca77868ea89ceb80135161a662c36aab1e8
blob + 05896ff4e33cfb6f70b301dcc2191d91e863afa4
--- src/cmd/venti/srv/httpd.c
+++ src/cmd/venti/srv/httpd.c
if(address == nil)
address = "tcp!*!http";
webroot = dir;
-
+
httpdobj("/stats", estats);
httpdobj("/index", dindex);
httpdobj("/storage", sindex);
*/
if(hparsereq(c, 0) < 0)
break;
-
+
for(i = 0; i < MaxObjs && objs[i].name[0]; i++){
n = strlen(objs[i].name);
if((objs[i].name[n-1] == '/' && strncmp(c->req.uri, objs[i].name, n) == 0)
hargstr(HConnect *c, char *name, char *def)
{
HSPairs *p;
-
+
for(p=c->req.searchpairs; p; p=p->next)
if(strcmp(p->s, name) == 0)
return p->t;
hargint(HConnect *c, char *name, vlong def)
{
char *a;
-
+
if((a = hargstr(c, name, nil)) == nil)
return def;
return atoll(a);
{
int n;
Hio *hout;
-
+
hout = &c->hout;
n = snprint(c->xferbuf, HBufSize, "<html><head><title>Error</title></head>\n<body><h1>Error</h1>\n<pre>%r</pre>\n</body></html>");
hprint(hout, "%s %s\r\n", hversion, "400 Bad Request");
return hflush(hout);
}
-
+
int
hnotfound(HConnect *c)
{
char buf[4096], *p, *ext, *type;
int i, fd, n, defaulted;
Dir *d;
-
+
if(webroot == nil || strstr(c->req.uri, ".."))
return hnotfound(c);
snprint(buf, sizeof buf-20, "%s/%s", webroot, c->req.uri+1);
hflush(&c->hout);
return 0;
}
-
+
old = *namedints[i].p;
*namedints[i].p = atoll(value);
hprint(&c->hout, "%s = %d (was %d)\n", name, *namedints[i].p, old);
percent(stats.absorbedwrites, stats.dirtydblocks));
hprint(hout, "disk cache flushes=%,ld\n", stats.dcacheflushes);
- hprint(hout, "disk cache flush writes=%,ld (%,ld per flush)\n",
+ hprint(hout, "disk cache flush writes=%,ld (%,ld per flush)\n",
stats.dcacheflushwrites,
stats.dcacheflushwrites/(stats.dcacheflushes ? stats.dcacheflushes : 1));
ulong *n;
n = s->n;
- return n[StatApartReadBytes]+n[StatApartWriteBytes]
+ return n[StatApartReadBytes]+n[StatApartWriteBytes]
+ n[StatIsectReadBytes]+n[StatIsectWriteBytes]
+ n[StatSumReadBytes];
}
"lcachesize",
"lcachestall",
"lcachelookuptime",
-
+
"dcachehit",
"dcachemiss",
"dcachelookup",
"sumread",
"sumreadbyte",
-
+
"cigload",
"cigloadtime",
};
g.ht = hargint(c, "ht", -1);
dotext = hargstr(c, "text", "")[0] != 0;
g.fill = hargint(c, "fill", -1);
-
+
graph = hargstr(c, "graph", "raw");
if(strcmp(graph, "raw") == 0)
g.fn = rawgraph;
int i;
VtLogChunk *c;
char *name;
-
+
name = l ? l->name : "<nil>";
hprint(h, "<html><head>\n");
hprint(h, "<title>Venti Server Log: %s</title>\n", name);
hprint(h, "</head><body>\n");
hprint(h, "<b>Venti Server Log: %s</b>\n<p>\n", name);
-
+
if(l){
c = l->w;
for(i=0; i<l->nchunk; i++){
{
char **p;
int i, n;
-
+
hprint(h, "<html><head>\n");
hprint(h, "<title>Venti Server Logs</title>\n");
hprint(h, "</head><body>\n");
hprint(h, "<b>Venti Server Logs</b>\n<p>\n");
-
+
p = vtlognames(&n);
qsort(p, n, sizeof(p[0]), strpcmp);
for(i=0; i<n; i++)
blob - 3055b981d586ceb8cbb30e8cff8ae480da9473fc
blob + 3663345de5da03a3206c7c58a325c98bcab1f57b
--- src/cmd/venti/srv/icache.c
+++ src/cmd/venti/srv/icache.c
u32int size;
int bits;
IHash *ih;
-
+
bits = 0;
size = 1;
while(size < size1){
bits++;
size <<= 1;
}
-
+
ih = vtmallocz(sizeof(IHash)+size*sizeof(ih->table[0]));
ih->table = (IEntry**)(ih+1);
ih->bits = bits;
{
u32int h;
IEntry *ie;
-
+
h = hashbits(score, ih->bits);
for(ie=ih->table[h]; ie; ie=ie->nexthash)
if((type == -1 || type == ie->ia.type) && scorecmp(score, ie->score) == 0)
{
u32int h;
IEntry **l;
-
+
h = hashbits(ie->score, ih->bits);
for(l=&ih->table[h]; *l; l=&(*l)->nexthash)
if(*l == ie){
ihashinsert(IHash *ih, IEntry *ie)
{
u32int h;
-
+
h = hashbits(ie->score, ih->bits);
ie->nexthash = ih->table[h];
ih->table[h] = ie;
{
ISum *s;
int i;
-
+
for(i=icache.nsum-1; i>=0; i--){
s = icache.sum[i];
if(canqlock(&s->lock)){
qunlock(&s->lock);
return nil;
}
-
+
return s; /* locked */
}
{
u32int mem;
int i, entries, scache;
-
+
icache.full.l = &icache.lock;
mem = mem0;
icache.clean.prev = icache.clean.next = &icache.clean;
icache.dirty.prev = icache.dirty.next = &icache.dirty;
icache.free.prev = icache.free.next = (IEntry*)&icache.free;
-
+
icache.hash = mkihash(entries);
icache.nentries = entries;
setstat(StatIcacheSize, entries);
evictlru(void)
{
IEntry *ie;
-
+
ie = poplast(&icache.clean);
if(ie == nil)
return nil;
while((ie = poplast(&icache.free)) == nil && (ie = evictlru()) == nil){
// Could safely return here if state == IEClean.
// But if state == IEDirty, have to wait to make
- // sure we don't lose an index write.
+ // sure we don't lose an index write.
// Let's wait all the time.
flushdcache();
kickicache();
scacheload(toload);
qunlock(&toload->lock);
}
-
+
if(icache.ndirty >= icache.maxdirty)
kickicache();
addstat2(StatIcacheRead, 1, StatIcacheReadTime, msec() - ms);
return ret;
}
-
+
u32int
hashbits(u8int *sc, int bits)
{
icacheclean(IEntry *ie)
{
IEntry *next;
-
+
trace(TraceProc, "icacheclean enter");
qlock(&icache.lock);
for(; ie; ie=next){
int i;
IEntry *ie;
ISum *s;
-
+
qlock(&icache.lock);
while((ie = evictlru()) != nil)
pushfirst(&icache.free, ie);
}
qunlock(&icache.lock);
}
-
blob - e1406ef157111b6021d560df53684add317c2587
blob + d2e5a81586a87f1a9b203aea297188c98e16078b
--- src/cmd/venti/srv/icachewrite.c
+++ src/cmd/venti/srv/icachewrite.c
*pnbuf = nbuf;
return iefirst;
}
-
+
static int
icachewritesect(Index *ix, ISect *is, u8int *buf)
{
err = -1;
continue;
}
-
+
addstat(StatIsectWriteBytes, nbuf);
addstat(StatIsectWrite, 1);
icacheclean(chunk);
send(ix->sects[i]->writechan, 0);
if(ix->bloom)
send(ix->bloom->writechan, 0);
-
+
err = 0;
for(i=0; i<ix->nsects; i++)
err |= recvul(ix->sects[i]->writedonechan);
*l = nil;
return sorted;
}
-
blob - 07bf81c8643ab754b9f88ad430933b1c686ddb07
blob + c3baa90599a000eab4ac7084a6ec6b9a01568ad0
--- src/cmd/venti/srv/index.c
+++ src/cmd/venti/srv/index.c
/*
- * Index, mapping scores to log positions.
+ * Index, mapping scores to log positions.
*
* The index is made up of some number of index sections, each of
- * which is typically stored on a different disk. The blocks in all the
- * index sections are logically numbered, with each index section
+ * which is typically stored on a different disk. The blocks in all the
+ * index sections are logically numbered, with each index section
* responsible for a range of blocks. Blocks are typically 8kB.
*
* The N index blocks are treated as a giant hash table. The top 32 bits
* of score are used as the key for a lookup. Each index block holds
* one hash bucket, which is responsible for ceil(2^32 / N) of the key space.
- *
- * The index is sized so that a particular bucket is extraordinarily
- * unlikely to overflow: assuming compressed data blocks are 4kB
+ *
+ * The index is sized so that a particular bucket is extraordinarily
+ * unlikely to overflow: assuming compressed data blocks are 4kB
* on disk, and assuming each block has a 40 byte index entry,
* the index data will be 1% of the total data. Since scores are essentially
* random, all buckets should be about the same fullness.
- * A factor of 5 gives us a wide comfort boundary to account for
+ * A factor of 5 gives us a wide comfort boundary to account for
* random variation. So the index disk space should be 5% of the arena disk space.
*/
v = is->part->size & ~(u64int)(is->blocksize - 1);
if(is->blockbase + (u64int)is->blocks * is->blocksize != v){
seterr(ECorrupt, "invalid blocks in index section %s", is->name);
- /* ZZZ what to do?
+ /* ZZZ what to do?
freeisect(is);
return nil;
*/
{
u64int aa;
Arena *arena;
-
+
arena = amapitoa(ix, a, &aa);
if(arena == nil)
return nil;
{
return loadibucket1(ix, score, pis, pbuck, ib);
}
-
-
blob - cc0a26dc6fe290ae59604f07ea65d19b98f8d53a
blob + 3e66068a8472617a5bd56bb2d8f96c834d22fb10
--- src/cmd/venti/srv/lump.c
+++ src/cmd/venti/srv/lump.c
insertlump(u, p);
else
packetfree(p);
-
+
if(syncwrites){
flushdcache();
flushicache();
blob - 93fed6d1af6e5afbc1c26cbb05d63910bf3da659
blob + 0fdc0102c960f0d3f61c60e6154508fc147fb5b3
--- src/cmd/venti/srv/lumpcache.c
+++ src/cmd/venti/srv/lumpcache.c
ms = 0;
trace(TraceLump, "lookuplump enter");
-
+
h = hashbits(score, HashLog);
/*
if(lumpcache.nheap + nfree + refed != lumpcache.nblocks)
sysfatal("lc: missing blocks: %d %d %d %d", lumpcache.nheap, refed, nfree, lumpcache.nblocks);
}
-
blob - 869eaeae0caadda9a8bbfe19be74b85bc7f204c0
blob + a312ad1785ec312d48a091a69d71668d5a16137b
--- src/cmd/venti/srv/lumpqueue.c
+++ src/cmd/venti/srv/lumpqueue.c
qunlock(&q->lock);
}
}
-
+
static void
queueproc(void *vq)
{
blob - 9a615b2c01266d12d1835eb722c40814760354f6
blob + 93e87a39394aa541f0f232f63302661767682fd0
--- src/cmd/venti/srv/mgr.c
+++ src/cmd/venti/srv/mgr.c
char *s, *line, *flds[10];
int i, ok;
IFile f;
-
+
if(readifile(&f, file) < 0)
return -1;
memset(conf, 0, sizeof *conf);
}else if(i == 3 && strcmp(flds[1], "verify") == 0) {
if(conf->nverify%64 == 0)
conf->verify = vtrealloc(conf->verify, (conf->nverify+64)*sizeof(conf->verify[0]));
- conf->verify[conf->nverify++] = vtstrdup(flds[2]);
+ conf->verify[conf->nverify++] = vtstrdup(flds[2]);
}else if(i == 3 && strcmp(flds[1], "verifyfreq") == 0) {
conf->verifyfreq = atoi(flds[2]);
}else if(i == 3 && strcmp(flds[1], "httpaddr") == 0){
int i;
char *p;
VtLogChunk *c;
-
+
p = logbuf;
c = l->w;
for(i=0; i<l->nchunk; i++) {
{
return hsettype(c, "text/plain; charset=utf-8");
}
-
+
int
hnotfound(HConnect *c)
{
{
char **p;
int i, n;
-
+
hprint(h, "<html><head>\n");
hprint(h, "<title>Venti Server Logs</title>\n");
hprint(h, "</head><body>\n");
hprint(h, "<b>Venti Server Logs</b>\n<p>\n");
-
+
p = vtlognames(&n);
qsort(p, n, sizeof(p[0]), strpcmp);
for(i=0; i<n; i++)
int i;
VtLogChunk *c;
char *name;
-
+
name = l ? l->name : "<nil>";
hprint(h, "<html><head>\n");
hprint(h, "<title>Venti Server Log: %s</title>\n", name);
hprint(h, "</head><body>\n");
hprint(h, "<b>Venti Server Log: %s</b>\n<p>\n", name);
-
+
if(l){
c = l->w;
for(i=0; i<l->nchunk; i++){
hargstr(HConnect *c, char *name, char *def)
{
HSPairs *p;
-
+
for(p=c->req.searchpairs; p; p=p->next)
if(strcmp(p->s, name) == 0)
return p->t;
*/
if(hparsereq(c, 0) < 0)
break;
-
+
for(i = 0; i < MaxObjs && objs[i].name[0]; i++){
n = strlen(objs[i].name);
if((objs[i].name[n-1] == '/' && strncmp(c->req.uri, objs[i].name, n) == 0)
char buf[4096], *p, *ext, *type;
int i, fd, n, defaulted;
Dir *d;
-
+
if(conf.webroot == nil || strstr(c->req.uri, ".."))
return hnotfound(c);
snprint(buf, sizeof buf-20, "%s/%s", conf.webroot, c->req.uri+1);
int fd;
char *p;
int ok;
-
+
j = v;
fd = j->pipe;
l = j->newlog;
}
qlock(&loglk);
p = logtext(l);
- ok = j->ok(p);
+ ok = j->ok(p);
qunlock(&loglk);
j->newok = ok;
close(fd);
int nofork;
char *prog;
Job *j;
-
+
ventilogging = 1;
ventifmtinstall();
#ifdef PLAN9PORT
qp(Biobuf *b, char *p)
{
int n, nspace;
-
- nspace = 0;
+
+ nspace = 0;
n = 0;
for(; *p; p++) {
if(*p == '\n') {
{
char *p, *q;
int n;
-
+
while((p = Brdstr(b, '\n', 1)) != nil) {
n = strtol(p, &q, 10);
if(n == 0 || q != p+3) {
return -1;
}
-
+
void
sendmail(char *content, char *subject, char *msg)
{
int fd;
Biobuf *bin, *bout;
-
+
if((fd = dial(conf.smtp, 0, 0, 0)) < 0) {
vtlogprint(errlog, "dial %s: %r\n", conf.smtp);
return;
Bterm(bout);
return;
}
-
+
Bprint(bout, "HELO venti-mgr\n");
Bflush(bout);
if(smtpread(bin, 250) < 0)
Bflush(bout);
if(smtpread(bin, 250) < 0)
goto error;
-
+
Bprint(bout, "DATA\n");
Bflush(bout);
if(smtpread(bin, 354) < 0)
goto error;
-
+
Bprint(bout, "From: \"venti mgr\" <%s>\n", conf.mailfrom);
Bprint(bout, "To: <%s>\n", conf.mailto);
Bprint(bout, "Subject: %s\n", subject);
Bflush(bout);
if(smtpread(bin, 250) < 0)
goto error;
-
+
Bprint(bout, "QUIT\n");
Bflush(bout);
Bterm(bin);
blob - c0d02e65dfc1253d8c4cb9fd02abc59e80060853
blob + adca4a784b9b440089e154416d7c74c41065aa71
--- src/cmd/venti/srv/mirrorarenas.c
+++ src/cmd/venti/srv/mirrorarenas.c
/*
- * Mirror one arena partition onto another.
+ * Mirror one arena partition onto another.
* Be careful to copy only new data.
*/
tag(int indx, char *name, char *fmt, ...)
{
va_list arg;
-
+
if(tagged){
free(tagged);
tagged = nil;
va_end(arg);
}
-enum
+enum
{
Sealed = 1,
Mirrored = 2,
if(bits < 0) {
startindx = -1;
return;
- }
+ }
}
void
}
return 0;
}
-
+
int
ewritepart(Part *p, u64int offset, u8int *buf, u32int count)
{
writeproc(void *v)
{
Write *w;
-
+
USED(v);
while((w = recvp(writechan)) != nil){
if(w == &wsync)
static uchar *tmp[2];
uchar *p;
Write w[2];
-
+
assert(start <= end);
assert(astart <= start && start < aend);
assert(astart <= end && end <= aend);
int n;
uvlong o;
static uchar tmp[1024*1024];
-
+
assert(start <= end);
assert(astart <= start && start < aend);
assert(astart <= end && end <= aend);
ArenaHead h;
DigestState xds, *ds;
vlong shaoff, base;
-
+
base = sa->base;
blocksize = sa->blocksize;
end = sa->base + sa->size;
-
+
astart = base - blocksize;
aend = end + blocksize;
tag(indx, sa->name, "%T %s (%,llud-%,llud)\n", sa->name, astart, aend);
-
+
if(force){
copy(astart, aend, "all", nil);
return;
if(ewritepart(dst, end, buf, blocksize) < 0)
return;
}
-
+
memset(&h, 0, sizeof h);
h.version = da->version;
strcpy(h.name, da->name);
sha1(buf, blocksize, nil, ds);
shaoff = base;
}
-
+
if(sa->diskstats.used != da->diskstats.used){
di = base+rdown(da->diskstats.used, blocksize);
si = base+rup(sa->diskstats.used, blocksize);
return;
shaoff = si;
}
-
+
clumpmax = sa->clumpmax;
di = end - da->diskstats.clumps/clumpmax * blocksize;
si = end - (sa->diskstats.clumps+clumpmax-1)/clumpmax * blocksize;
if(sa->diskstats.sealed){
/*
- * might be a small hole between the end of the
+ * might be a small hole between the end of the
* data and the beginning of the directory.
*/
v = base+rup(sa->diskstats.used, blocksize);
da->wtime = sa->wtime;
da->diskstats = sa->diskstats;
da->diskstats.sealed = 0;
-
+
/*
* Repack the arena tail information
* and save it for next time...
mirror(i, sa, da);
}
setstatus(-1);
- }
+ }
}
Arena *sa, *da;
ArenaPart *s, *d;
char *ranges;
-
+
ventifmtinstall();
ARGBEGIN{
default:
usage();
}ARGEND
-
+
if(argc != 2 && argc != 3)
usage();
ranges = nil;
sysfatal("loadarenapart %s: %r", argv[1]);
for(i=0; i<d->narenas; i++)
delarena(d->arenas[i]);
-
+
/*
* The arena geometries must match or all bets are off.
*/
if(strcmp(sa->name, da->name) != 0)
sysfatal("arena %d: name mismatch: %s vs %s", i, sa->name, da->name);
}
-
+
/*
* Mirror one arena at a time.
*/
blob - ae0448149a23cc12dfb6d2678993081a91051ba5
blob + c1fb929fd70bc0865f813f95c2009b3c7225e127
--- src/cmd/venti/srv/part.c
+++ src/cmd/venti/srv/part.c
*u = v;
return 0;
}
-
+
static int
parsepart(char *name, char **file, char **subpart, u64int *lo, u64int *hi)
{
* Most Unix systems require that when accessing a block device directly,
* the buffer, offset, and count are all multiples of the device block size,
* making this a lot more complicated than it otherwise would be.
- *
+ *
* Most of our callers will make things easy on us, but for some callers it's best
* if we just do the work here, with only one place to get it right (hopefully).
- *
- * If everything is aligned properly, prwb will try to do big transfers in the main
+ *
+ * If everything is aligned properly, prwb will try to do big transfers in the main
* body of the loop: up to MaxIo bytes at a time. If everything isn't aligned properly,
* we work one block at a time.
*/
int n, try;
u32int blocksize;
- trace(TraceDisk, "%s %s %ud at 0x%llx",
+ trace(TraceDisk, "%s %s %ud at 0x%llx",
isread ? "read" : "write", part->name, count, offset);
if(offset >= part->size || offset+count > part->size){
seterr(EStrange, "out of bounds %s offset 0x%llux count %ud to partition %s size 0x%llux",
/*
* Search for the Plan 9 partition with the given name.
- * This lets you write things like /dev/ad4:arenas
+ * This lets you write things like /dev/ad4:arenas
* if you move a disk from a Plan 9 system to a FreeBSD system.
*
* God I hope I never write this code again.
/* See if this is a Plan 9 partition. */
if(tryplan9part(part, name) >= 0)
return 0;
-
+
/* Otherwise try for an MBR and then narrow to Plan 9 partition. */
if(readpart(part, 0, buf, 512) != 512)
return -1;
}
return -1;
}
-
-
-
-
-
blob - 8805ada42f0c78d2abd7ad85436b04431d865739
blob + 85901a92a210adbd9874ac918472510fde07f4fa
--- src/cmd/venti/srv/png.c
+++ src/cmd/venti/srv/png.c
b[2] = (b[2]*255)/a;
}
}
- }else
+ }else
b += pixwid*pixels;
z->x += pixels;
Memimage *ni;
char buf[32];
ulong dst;
-
+
/*
* [A]BGR because we want R,G,B,[A] in big-endian order. Sigh.
*/
dst = ABGR32;
else
dst = BGR24;
-
+
if(i->chan == dst)
return i;
return -1;
hwrite(io, PNGmagic, sizeof PNGmagic);
-
+
/* IHDR chunk */
h = buf;
put4(h, Dx(m->r)); h += 4;
blob - 9d7cd20e4910e8bdce7853dcf3c7f27eeea5f0b5
blob + 42be56632d0bdea4011b4f3fa3bdb608e6711f83
--- src/cmd/venti/srv/rdarena.c
+++ src/cmd/venti/srv/rdarena.c
if(a + bs > e)
bs = arena->blocksize;
if(readpart(arena->part, a, b->data, bs) < 0)
- fprint(2, "can't copy %s, read at %lld failed: %r\n", arena->name, a);
+ fprint(2, "can't copy %s, read at %lld failed: %r\n", arena->name, a);
if(write(1, b->data, bs) != bs)
sysfatal("can't copy %s, write at %lld failed: %r", arena->name, a);
}
blob - a822a9878c46c7ec96cbe59081dd8ef17a824ffb
blob + ddfef1410cd2c08af8fdb1fcf6ac4d85a7146adf
--- src/cmd/venti/srv/readifile.c
+++ src/cmd/venti/srv/readifile.c
default:
usage();
}ARGEND
-
+
if(argc != 1)
usage();
-
+
if(readifile(&ifile, argv[0]) < 0)
sysfatal("readifile %s: %r", argv[0]);
write(1, ifile.b->data, ifile.b->len);
blob - f7353122e092abdc715b26cf6da5bda3c9349326
blob + 41a53ce106cc830dff6dd8579fa4709f5c16d2ce
--- src/cmd/venti/srv/reseal.c
+++ src/cmd/venti/srv/reseal.c
bs = e - n;
sha1(data, bs, nil, &ds);
}
-
+
/* last block */
if(preadblock(data, arena->blocksize, o + e) < 0){
werrstr("read: %r");
}
fprint(2, "warning: score mismatch %V != %V\n", score, arena->score);
}
-
+
/* prepare new last block */
memset(data, 0, arena->blocksize);
packarena(arena, data);
if(loadheader(name, &head, &arena, off) < 0)
return;
-
+
if(!arena.diskstats.sealed){
fprint(2, "%s: not sealed\n", name);
return;
}
-
+
if(verify(&arena, data, newscore) < 0){
fprint(2, "%s: failed to verify before reseal: %r\n", name);
return;
}
-
+
if(pwriteblock(data, arena.blocksize, arena.base + arena.size) < 0){
fprint(2, "%s: writing new tail: %r\n", name);
return;
shouldcheck(char *name, char **s, int n)
{
int i;
-
+
if(n == 0)
return 1;
readap(ArenaPart *ap)
{
char *table;
-
+
if(preadblock(data, 8192, PartBlank) < 0)
sysfatal("read arena part header: %r");
if(unpackarenapart(ap, data) < 0)
vlong start, stop;
ArenaPart ap;
Part *part;
-
+
ventifmtinstall();
blocksize = MaxIoSize;
ARGBEGIN{
blob - bbf4a478a1276fc07c80b6c98f611cc74ded5a36
blob + 5e01b0bafe2629d43fd94947e0289de7efa1687e
--- src/cmd/venti/srv/round.c
+++ src/cmd/venti/srv/round.c
trace(TraceProc, "finishround 0x%ux", (uint)n);
}
}
-
blob - b8b8e876ca784ed8d5e70fe79d77eacf6e30dc58
blob + e65b99883f4795a084e2dda6281987465410be4e
--- src/cmd/venti/srv/sortientry.c
+++ src/cmd/venti/srv/sortientry.c
if(n == TWID32)
return TWID64;
if(n != ib->bucks[i].total/IEntrySize)
- fprint(2, "bucket %d changed count %d => %d\n",
+ fprint(2, "bucket %d changed count %d => %d\n",
i, (int)(ib->bucks[i].total/IEntrySize), n);
tot += n;
}
blob - bb944760b4e47acd3497bac1c65a6694ecafd600
blob + e2f077be5965641be9a9b1bc24d03cdc9de08e7d
--- src/cmd/venti/srv/stats.c
+++ src/cmd/venti/srv/stats.c
{ "rpc read cached time", },
{ "rpc read uncached", },
{ "rpc read uncached time "},
-
+
{ "rpc writes", },
{ "rpc writes new", },
{ "rpc writes old", },
{ "sum reads", },
{ "sum read bytes", },
-
+
{ "cig loads" },
{ "cig load time" },
};
int i, j, lo, hi, m;
vlong tot;
Statbin *b;
-
+
t = stats.now;
-
+
/* negative times mean relative to now. */
if(t0 <= 0)
t0 += t;
if(t1 <= t0)
t0 = t1 - 60*10;
if(0) fprint(2, "stats %ld-%ld\n", t0, t1);
-
+
/* binary search to find t0-1 or close */
lo = stattime;
hi = stattime+nstathist;
b->avg = tot / b->nsamp;
if(b->nsamp==0 && i>0)
*b = bin[i-1];
- }
+ }
}
blob - be3a2ea064f61a84d45b3acdce4c854b273c4934
blob + 9928ca03fcfbad6371ca8ec937a8670749c2cf30
--- src/cmd/venti/srv/syncindex0.c
+++ src/cmd/venti/srv/syncindex0.c
ClumpInfo ci;
IAddr ia;
AState as;
-
+
if(arena->diskstats.clumps == arena->memstats.clumps)
return 0;
-
+
memset(&as, 0, sizeof as);
as.arena = arena;
as.stats = arena->diskstats;
continue;
}
flushdcache();
-
+
if(arena->memstats.clumps == arena->diskstats.clumps)
continue;
-
+
fprint(2, "%T %s: indexing %d clumps...\n",
arena->name,
arena->memstats.clumps - arena->diskstats.clumps);
blob - 2a3cc66944878a457790942e33b176aa9af24330
blob + 1725537a2bc1838c8d43bd788088f035a596e297
--- src/cmd/venti/srv/venti.c
+++ src/cmd/venti/srv/venti.c
/*
* block cache: need a block for every arena and every process
*/
- minbcmem = maxblocksize *
+ minbcmem = maxblocksize *
(mainindex->narenas + mainindex->nsects*4 + 16);
if(bcmem < minbcmem)
bcmem = minbcmem;
blob - f53d17f2c97af45fad53b415b9b9e4758a6aae5a
blob + 47340dcf62ab559d1d2645f8201aaa632d8880b5
--- src/cmd/venti/srv/verifyarena.c
+++ src/cmd/venti/srv/verifyarena.c
scorecp(arena.score, &data[arena.blocksize - VtScoreSize]);
if(namecmp(arena.name, head.name) != 0){
- fprint(2, "%T %s: wrong name in trailer: %s vs. %s\n",
+ fprint(2, "%T %s: wrong name in trailer: %s vs. %s\n",
name, head.name, arena.name);
return;
}
if(arena.version != head.version){
- fprint(2, "%T %s: wrong version in trailer: %d vs. %d\n",
+ fprint(2, "%T %s: wrong version in trailer: %d vs. %d\n",
name, head.version, arena.version);
return;
}
shouldcheck(char *name, char **s, int n)
{
int i;
-
+
if(n == 0)
return 1;
verifyarena("<stdin>", 0);
threadexitsall(nil);
}
-
+
if((part = initpart(argv[0], OREAD)) == nil)
sysfatal("open partition %s: %r", argv[0]);
fd = part->fd;
if(preadblock((uchar*)table, ap.tabsize, ap.tabbase) < 0)
sysfatal("reading arena part directory: %r");
table[ap.tabsize] = 0;
-
+
nline = atoi(table);
p = strchr(table, '\n');
if(p)
blob - 1e274ca7943048ef996a91e05861239786de7b9d
blob + df8f7fd89bb5e6afe7b3350288c09dfc49c9eaa0
--- src/cmd/venti/srv/wrarena.c
+++ src/cmd/venti/srv/wrarena.c
}
/*
* All the send threads try to exit right when
- * threadmain is calling threadexitsall.
+ * threadmain is calling threadexitsall.
* Either libthread or the Linux NPTL pthreads library
* can't handle this condition (I suspect NPTL but have
* not confirmed this) and we get a seg fault in exit.
blob - e91afa0547fafcc06bbaae1813f028a753944d73
blob + 9538d7782d9ca501f6ee2898c3fc6e6172487095
--- src/cmd/venti/srv/xml.c
+++ src/cmd/venti/srv/xml.c
xmlu64int(hout, s->stop, "stop");
hprint(hout, "/>\n");
}
-
blob - afff0801034208de33871d0b407c0f9225cb964c
blob + 80b240647114d26d1e1fb2e8633b0bc394dcd627
--- src/cmd/venti/srv/zblock.c
+++ src/cmd/venti/srv/zblock.c
packetappend(p, zb->data, size);
return p;
}
-
blob - 9d817a72ebdb9c79e8c4cc0a6ba49e654aeb313d
blob + 965f19ed81f745dfa1f00787976da6dfec1943b1
--- src/cmd/venti/sync.c
+++ src/cmd/venti/sync.c
fmtinstall('V', vtscorefmt);
fmtinstall('F', vtfcallfmt);
-
+
ARGBEGIN{
case 'h':
host = EARGF(usage());
blob - 2111712610830b5aadc8b3f964361ee2294cf791
blob + 3aff69ddca0fd145e5d77de4b7237d1f62960dba
--- src/cmd/venti/writefile.c
+++ src/cmd/venti/writefile.c
if(vtfilegetentry(f, &e) < 0)
sysfatal("vtfilegetentry: %r");
vtfileunlock(f);
-
+
// write directory entry
memset(&root, 0, sizeof root);
vtentrypack(&e, buf, 0);
if(vtwrite(z, root.score, VtDirType, buf, VtEntrySize) < 0)
sysfatal("vtwrite dir: %r");
-
+
// write root
strcpy(root.name, "data");
strcpy(root.type, "file");
vtrootpack(&root, buf);
if(vtwrite(z, score, VtRootType, buf, VtRootSize) < 0)
sysfatal("vtwrite root: %r");
-
+
print("file:%V\n", score);
threadexitsall(0);
}
-
blob - ce6fafeac782fdff559963b14e6d2c9a27906135
blob + 2ff1d53f190876b4ca801e93529093df11a8e2f6
--- src/cmd/zerotrunc.c
+++ src/cmd/zerotrunc.c
}
exits(0);
}
-
blob - b49cd4df1877bd0addd9eeb7517c8fa06034151c
blob + 0fb3410e944f5aaf20a45f03f8a4e464202e2968
--- src/lib9/_p9dir.c
+++ src/lib9/_p9dir.c
disksize(int fd, struct stat *st)
{
off_t mediasize;
-
+
if(ioctl(fd, DIOCGMEDIASIZE, &mediasize) >= 0)
return mediasize;
return 0;
sz += strlen(s)+1;
if(d){
if(*str+strlen(s)+1 > estr)
- d->uid = "oops";
+ d->uid = "oops";
else{
strcpy(*str, s);
d->uid = *str;
sz += strlen(s)+1;
if(d){
if(*str + strlen(s)+1 > estr)
- d->gid = "oops";
+ d->gid = "oops";
else{
strcpy(*str, s);
d->gid = *str;
return sz;
}
-
blob - 84cd65caedb79829a0d3b445b7be553761f47184
blob + 74df43c588a5c4cafc14787c33acc94709c23d3f
--- src/lib9/_p9translate.c
+++ src/lib9/_p9translate.c
/*
* I don't want too many of these,
- * but the ones we have are just too useful.
+ * but the ones we have are just too useful.
*/
static struct {
char *old;
blob - cbf5b07358ab72179bbbca1e663f162f81f7504b
blob + 1587988e5702b5bafd0d195cb0937a3ee14d1dd9
--- src/lib9/announce.c
+++ src/lib9/announce.c
/* need to dup because the listen fd will be closed */
return dup(fd);
}
-
blob - 66ecb4efffd5c6a79e215559afc59458cc355836
blob + c0f7251dd287598ee5fcd623b4bd5c3fd8fb89ae
--- src/lib9/atoi.c
+++ src/lib9/atoi.c
{
return strtol(s, 0, 0);
}
-
blob - d67138342bfa51ee350cf126365917fefb0ef689
blob + 6ead3004c161e59806f8c316e0bfd75c5a5fd7d6
--- src/lib9/atol.c
+++ src/lib9/atol.c
{
return strtol(s, 0, 0);
}
-
blob - 6c345df6632f1dc7349898df644b7c4b07a73669
blob + d4ce0a94cab0c9a6718c86c277644b093ed78452
--- src/lib9/atoll.c
+++ src/lib9/atoll.c
{
return strtoll(s, 0, 0);
}
-
blob - e96055f27d9e3e22ebdbafdeb6b30936c342db54
blob + 8b96865ca4b7caccfe576d822ab0a89a41b718d2
--- src/lib9/await.c
+++ src/lib9/await.c
SIGUSR2, "sys: usr2",
SIGPIPE, "sys: write on closed pipe",
};
-
+
char*
_p9sigstr(int sig, char *tmp)
{
{
return _await(pid, str, n, 0);
}
-
blob - 30c0d496145a15003b4ba6db8e002c67b4b4b7d5
blob + e1ef00c54f97302bff7d0c9226d7370bcd204209
--- src/lib9/convD2M.c
+++ src/lib9/convD2M.c
sv[1] = d->uid;
sv[2] = d->gid;
sv[3] = d->muid;
-
+
fixlen = STATFIXLEN;
nstr = 4;
-
+
ns = 0;
for(i = 0; i < nstr; i++)
if(sv[i])
fixlen = STATFIXLEN;
nstr = 4;
-
+
ns = 0;
for(i = 0; i < nstr; i++){
if(sv[i])
memmove(p, sv[i], ns);
p += ns;
}
-
+
if(ss != p - buf)
return 0;
blob - 504110b2ded3912946f8a22870ec14a5cda01d73
blob + 410fa603727c7e78d1c4d2bd9642907edb48d16c
--- src/lib9/convM2D.c
+++ src/lib9/convM2D.c
int i, ns, nstr;
if(nbuf < STATFIXLEN)
- return 0;
+ return 0;
p = buf;
ebuf = buf + nbuf;
d->muid = nullstring;
d->ext = nullstring;
}
-
+
return p - buf;
}
blob - 0524c94227f75cd65aea786ab7074d52f7eedcb0 (mode 755)
blob + 0524c94227f75cd65aea786ab7074d52f7eedcb0 (mode 644)
blob - 9fcd6200886310d43c3822dc6600626b894b2d9d
blob + 97ebfd2fb6b0f144b80ddbe904cf3bef55cef402
--- src/lib9/ctime.c
+++ src/lib9/ctime.c
cp[0] = (n/10)%10 + '0';
cp[1] = n%10 + '0';
}
-
blob - 8df272196d4eca471b77e75c4aea14f1f214316b
blob + 51a2c61f52ecf52d32fcd4e61e08862d481f774e
--- src/lib9/debugmalloc.c
+++ src/lib9/debugmalloc.c
p = (char*)(u+4)+n;
memmove(p, END, 4);
return u+4;
- }
+ }
}
void
u = mark(v, 0, 0, 0);
u[3] = t;
}
-
+
void*
p9malloc(ulong n)
{
blob - 1ce3a1473c422b2bab3339c0854c4388b025cb3c
blob + c3dd17624fb9a521cdc5b3e044f03a9e8b09b8ec
--- src/lib9/dial.c
+++ src/lib9/dial.c
if((s = socket(ss.ss_family, proto, 0)) < 0)
return -1;
-
+
if(local){
buf = strdup(local);
if(buf == nil){
}
return s;
}
-
blob - d1922bf91e697a4995f2793a61a3e875a06aa5c9
blob + 37b59a0b0f6128f0380c7c59362b07b3a73ef347
--- src/lib9/dirfstat.c
+++ src/lib9/dirfstat.c
_p9dir(&st, &st, tmp, d, &str, str+nstr);
return d;
}
-
blob - 95e184447f56f02f2f7984fefbf792f4aaaf4b9f
blob + 27ed37a8495d8900c06d1e7baa2e5f7ad79942b5
--- src/lib9/dirfwstat.c
+++ src/lib9/dirfwstat.c
}
return ret;
}
-
blob - 40fbe3c744d7b7be27d8b75dd0d4f8379720f419
blob + c232eb8d819deb45820822f2f0bafc6a018fcaa5
--- src/lib9/dirread.c
+++ src/lib9/dirread.c
nn = getdirentries(fd, (void*)buf, n, &off);
return nn;
}
-#elif defined(__APPLE__)
+#elif defined(__APPLE__)
static int
mygetdents(int fd, struct dirent *buf, int n)
{
return -1;
if(fchdir(fd) < 0)
return -1;
-
+
p = buf;
nstr = 0;
blob - 187dea7a5c5120872be8d722899d5a1d0689e958
blob + a644b6b5419d4eda2485de0527d300e09e0861cc
--- src/lib9/dirstat.c
+++ src/lib9/dirstat.c
_p9dir(&lst, &st, file, d, &str, str+nstr);
return d;
}
-
blob - caf7153236c0caffe2c3ad7ceffc3c629c966548
blob + 9493e84212247ef4e0a9b2aa235d4ff61bf14581
--- src/lib9/errstr.c
+++ src/lib9/errstr.c
va_end(arg);
errstr(buf, ERRMAX);
}
-
blob - 988d207238600f42cef5b74f0857d76a8e7c658e
blob + 63b86d6dd791428c58915f354d45e9ecee7a570f
--- src/lib9/execl.c
+++ src/lib9/execl.c
free(argv);
return -1;
}
-
blob - f65836e1f273801e3433119b5b6af5d8934b1d70
blob + 797e9d50cc9a23f43895d092b4d2c88ad356566f
--- src/lib9/exitcode.c
+++ src/lib9/exitcode.c
{
return 1;
}
-
blob - 353c76e37f25e0af8707c5c72199b28bd663eddb
blob + f714f8ff92cd5fc9bb7cc371e44ca157384f2824
--- src/lib9/fmt/dofmt.c
+++ src/lib9/fmt/dofmt.c
if(fl & FmtApost)
__needsep(&ndig, &grouping);
}
-
+
/*
* Zero values don't get 0x.
*/
blob - bfeb7e5096dca9f6b1c81541533b0113d2dd5608
blob + 4045ffd83f63ab23c08933fc6a862518af700a76
--- src/lib9/fmt/fltfmt.c
+++ src/lib9/fmt/fltfmt.c
*/
static double pows10[] =
{
- 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
- 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
- 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
- 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
- 1e40, 1e41, 1e42, 1e43, 1e44, 1e45, 1e46, 1e47, 1e48, 1e49,
- 1e50, 1e51, 1e52, 1e53, 1e54, 1e55, 1e56, 1e57, 1e58, 1e59,
- 1e60, 1e61, 1e62, 1e63, 1e64, 1e65, 1e66, 1e67, 1e68, 1e69,
- 1e70, 1e71, 1e72, 1e73, 1e74, 1e75, 1e76, 1e77, 1e78, 1e79,
- 1e80, 1e81, 1e82, 1e83, 1e84, 1e85, 1e86, 1e87, 1e88, 1e89,
- 1e90, 1e91, 1e92, 1e93, 1e94, 1e95, 1e96, 1e97, 1e98, 1e99,
- 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
- 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,
- 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,
- 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,
- 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,
- 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,
+ 1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9,
+ 1e10, 1e11, 1e12, 1e13, 1e14, 1e15, 1e16, 1e17, 1e18, 1e19,
+ 1e20, 1e21, 1e22, 1e23, 1e24, 1e25, 1e26, 1e27, 1e28, 1e29,
+ 1e30, 1e31, 1e32, 1e33, 1e34, 1e35, 1e36, 1e37, 1e38, 1e39,
+ 1e40, 1e41, 1e42, 1e43, 1e44, 1e45, 1e46, 1e47, 1e48, 1e49,
+ 1e50, 1e51, 1e52, 1e53, 1e54, 1e55, 1e56, 1e57, 1e58, 1e59,
+ 1e60, 1e61, 1e62, 1e63, 1e64, 1e65, 1e66, 1e67, 1e68, 1e69,
+ 1e70, 1e71, 1e72, 1e73, 1e74, 1e75, 1e76, 1e77, 1e78, 1e79,
+ 1e80, 1e81, 1e82, 1e83, 1e84, 1e85, 1e86, 1e87, 1e88, 1e89,
+ 1e90, 1e91, 1e92, 1e93, 1e94, 1e95, 1e96, 1e97, 1e98, 1e99,
+ 1e100, 1e101, 1e102, 1e103, 1e104, 1e105, 1e106, 1e107, 1e108, 1e109,
+ 1e110, 1e111, 1e112, 1e113, 1e114, 1e115, 1e116, 1e117, 1e118, 1e119,
+ 1e120, 1e121, 1e122, 1e123, 1e124, 1e125, 1e126, 1e127, 1e128, 1e129,
+ 1e130, 1e131, 1e132, 1e133, 1e134, 1e135, 1e136, 1e137, 1e138, 1e139,
+ 1e140, 1e141, 1e142, 1e143, 1e144, 1e145, 1e146, 1e147, 1e148, 1e149,
+ 1e150, 1e151, 1e152, 1e153, 1e154, 1e155, 1e156, 1e157, 1e158, 1e159,
};
#define npows10 ((int)(sizeof(pows10)/sizeof(pows10[0])))
#define pow10(x) fmtpow10(x)
/*
* subtract 1 from the decimal integer string a.
* if 10000 underflows into 09999, make it 99999
- * and return 1 to tell caller to move the virtual
+ * and return 1 to tell caller to move the virtual
* decimal point. this way, xsub1 is inverse of xadd1.
*/
static int
*ns = 1;
return;
}
-
+
/*
* find g,e such that f = g*10^e.
* guess 10-exponent using 2-exponent, then fine tune.
e = ee;
}
}
-
+
/*
* bump last few digits down to 0 as we can.
*/
int c, chr, dotwid, e, exp, fl, ndigits, neg, newndigits;
int pad, point, prec, realchr, sign, sufwid, ucase, wid, z1, z2;
Rune r, *rs, *rt;
-
+
if(fmt->flags&FmtLong)
f = va_arg(fmt->args, long double);
else
f = va_arg(fmt->args, double);
-
- /*
+
+ /*
* extract formatting flags
*/
fl = fmt->flags;
exp += ndigits-prec;
ndigits = prec;
}
-
+
/*
* extra rules for %g (implemented below):
* trailing zeros removed after decimal unless FmtSharp.
/* fall through to %e */
default:
case 'e':
- /*
+ /*
* one significant digit before decimal, no leading zeros.
*/
point = 1;
z1 = 0;
-
+
/*
* decimal point is after ndigits digits right now.
* slide to be after first.
}
z2 = 0;
ndigits = newndigits;
- }
+ }
sufwid = 0;
break;
}
-
+
/*
* if %g is given without FmtSharp, remove trailing zeros.
* must do after truncation, so that e.g. print %.3g 1.001
}
return 0;
}
-
blob - 1519ea42dd89e4ebb8c7f2642c1c41498aac79a6
blob + 5c8eb2cbdc3f02692d3dc65cdf667a18924f3ffe
--- src/lib9/fmt/fmtdef.h
+++ src/lib9/fmt/fmtdef.h
# define VA_COPY(a,b) (a) = (b)
# define VA_END(a)
#endif
-
blob - 9ebdced389b8010bfe149b69f88842324910e56e
blob + 33ca4011aff0fe05369921ba6cb90548a3667d0a
--- src/lib9/fmt/fmtlocale.c
+++ src/lib9/fmt/fmtlocale.c
__needsep(int *ndig, char **grouping)
{
int group;
-
+
(*ndig)++;
group = *(unsigned char*)*grouping;
/* CHAR_MAX means no further grouping. \0 means we got the empty string */
}
return 0;
}
-
blob - aa5124a5c43f25812eaf9ea82a266b8178201016
blob + 22ac078f70fccd1fc3534776813fefcb144562b9
--- src/lib9/fmt/fmtnull.c
+++ src/lib9/fmt/fmtnull.c
fmtlocaleinit(f, nil, nil, nil);
return 0;
}
-
blob - 868127e0a7c048bb6135449e9ef912075a61b683
blob + 41fc8332a51ca8fa9683822a37fa1cbe4bd51ab5
--- src/lib9/fmt/fmtprint.c
+++ src/lib9/fmt/fmtprint.c
return 0;
return n;
}
-
blob - 66d3929f005ad52580328112cfd6d470916dd4e7
blob + 694a6cf88dfe164444329cd4cabe1d733b3efa4c
--- src/lib9/fmt/fmtvprint.c
+++ src/lib9/fmt/fmtvprint.c
return 0;
return n;
}
-
blob - d408695d5251601725cbea78603060598d300d56
blob + 78c3fde389daa54f00cedfaee513557502abc32a
--- src/lib9/fmt/nan64.c
+++ src/lib9/fmt/nan64.c
/*
* 64-bit IEEE not-a-number routines.
- * This is big/little-endian portable assuming that
+ * This is big/little-endian portable assuming that
* the 64-bit doubles and 64-bit integers have the
* same byte ordering.
*/
__isNaN(double d)
{
uvlong x;
-
+
x = d2u(d);
/* IEEE 754: exponent bits 0x7FF and non-zero mantissa */
return (x&uvinf) == uvinf && (x&~uvneginf) != 0;
__isInf(double d, int sign)
{
uvlong x;
-
+
x = d2u(d);
if(sign == 0)
return x==uvinf || x==uvneginf;
blob - 0872ac71ab4d18391746bf9d661fe12dce394436
blob + 0de44f148665eda0a549b2f6f928691eee65ef91
--- src/lib9/fmt/plan9.h
+++ src/lib9/fmt/plan9.h
#undef nelem
#define nelem(x) (sizeof (x)/sizeof (x)[0])
-
blob - 50b4813d528b3d981c05bf48a3cdf53160edf3bc
blob + afc3f506b9a5562f2340f6dd33fa551a53c5cf5e
--- src/lib9/fmt/runesnprint.c
+++ src/lib9/fmt/runesnprint.c
va_end(args);
return n;
}
-
blob - 24e2f178f505f714266de6b689cb176826639ff4
blob + 213351ab8dc3b746927036aa0b6e7d12597fe51e
--- src/lib9/fmt/runevseprint.c
+++ src/lib9/fmt/runevseprint.c
*(Rune*)f.to = '\0';
return (Rune*)f.to;
}
-
blob - ef273752afa7917e44bed93bfe7f75ba2c52dc9b
blob + de29d2c3d8f5f63458a93aff360d8e7402ddef12
--- src/lib9/fmt/runevsmprint.c
+++ src/lib9/fmt/runevsmprint.c
/* Copyright (c) 2002-2006 Lucent Technologies; see LICENSE */
/*
- * Plan 9 port version must include libc.h in order to
+ * Plan 9 port version must include libc.h in order to
* get Plan 9 debugging malloc, which sometimes returns
- * different pointers than the standard malloc.
+ * different pointers than the standard malloc.
*/
#ifdef PLAN9PORT
#include <u.h>
blob - 64d2da433d26bbf85c001daee85cef8170f2cbdc
blob + d019b456ad8e4622aba68a8c885d10a9f3d14ee7
--- src/lib9/fmt/snprint.c
+++ src/lib9/fmt/snprint.c
va_end(args);
return n;
}
-
blob - 1b92d2a9b2c12f204885b68342807ad4cfa39ce3
blob + 8266c65d524b1999e353d8f3157289a9555937fb
--- src/lib9/fmt/vseprint.c
+++ src/lib9/fmt/vseprint.c
*(char*)f.to = '\0';
return (char*)f.to;
}
-
blob - 9576f8003037c2d9df319309926ccb5236c13491
blob + 0a88e98fab1a22c18af32935ee7d082caf4cf7dc
--- src/lib9/fmt/vsmprint.c
+++ src/lib9/fmt/vsmprint.c
/* Copyright (c) 2002-2006 Lucent Technologies; see LICENSE */
/*
- * Plan 9 port version must include libc.h in order to
+ * Plan 9 port version must include libc.h in order to
* get Plan 9 debugging malloc, which sometimes returns
- * different pointers than the standard malloc.
+ * different pointers than the standard malloc.
*/
#ifdef PLAN9PORT
#include <u.h>
blob - 3ef704c93d8d18a7dc6f33fe85e2e71d1a1dd162
blob + 07e2872c512d288ea454c0ceb2bedb040e33ddd3
--- src/lib9/get9root.c
+++ src/lib9/get9root.c
s = "/usr/local/plan9";
return s;
}
-
blob - 9fa8a9e0d3ad9cc15c20be0cf7093db74e5d63f1
blob + e88516cf2251ff1b9c2f598e7a9da0b618d777fc
--- src/lib9/getnetconn.c
+++ src/lib9/getnetconn.c
socklen_t sn;
int n;
char *net;
-
+
switch(sa->sa_family){
case AF_INET:
sin = (void*)sa;
xfree(nci->raddr);
free(nci);
}
-
blob - 2421a649896d4f6a6a3eda1cb863d03c338311af
blob + 35bbeebd3f6f992ee48559baaf398bee0fc9e2fc
--- src/lib9/getns.c
+++ src/lib9/getns.c
if(strcmp(p, ".0") == 0)
*p = 0;
}
-
+
/* turn /tmp/launch/:0 into _tmp_launch_:0 (OS X 10.5) */
for(p=disp; *p; p++)
if(*p == '/')
blob - 6f928bab3caf720b041be0cf47a1874af7df2bdf
blob + 5ec21e7f26b8dfdf1b9e87b40e0eb286a58932af
--- src/lib9/jmp.c
+++ src/lib9/jmp.c
USED(x);
siglongjmp((void*)buf, val);
}
-
blob - 7b6b59dc24435b174f2c2a9dbf763c7eea91aa0c
blob + 33593aa2f1889297ad847a400b8f45888e04dfc1
--- src/lib9/malloc.c
+++ src/lib9/malloc.c
p9malloc(ulong n)
{
void *v;
-
+
if(n == 0)
n++;
lock(&malloclock);
p9calloc(ulong a, ulong b)
{
void *v;
-
+
if(a*b == 0)
a = b = 1;
blob - 832f7e28094146ef6d3fef562bcc70b2718d5d62
blob + 420c2cf8b1b4f9badf6ebeffeab94ad0f4f03948
--- src/lib9/netmkaddr.c
+++ src/lib9/netmkaddr.c
}
/* allow host:service in deference to Unix convention */
if((cp = strchr(linear, ':')) != nil){
- snprint(addr, sizeof(addr), "%s!%.*s!%s",
+ snprint(addr, sizeof(addr), "%s!%.*s!%s",
defnet, utfnlen(linear, cp-linear),
linear, cp+1);
return addr;
blob - c322387579f474f53a3d5e9de10c0f421627b37a
blob + adb3815b7f44233367c8cf8d8977015952e7ae18
--- src/lib9/notify.c
+++ src/lib9/notify.c
/*
- * Signal handling for Plan 9 programs.
- * We stubbornly use the strings from Plan 9 instead
- * of the enumerated Unix constants.
+ * Signal handling for Plan 9 programs.
+ * We stubbornly use the strings from Plan 9 instead
+ * of the enumerated Unix constants.
* There are some weird translations. In particular,
* a "kill" note is the same as SIGTERM in Unix.
* There is no equivalent note to Unix's SIGKILL, since
static void noteinit(void);
/*
- * Actual signal handler.
+ * Actual signal handler.
*/
static void (*notifyf)(void*, char*); /* Plan 9 handler */
sigemptyset(&mask);
sigaddset(&mask, sig);
sigprocmask(enabled ? SIG_UNBLOCK : SIG_BLOCK, &mask, &omask);
- return !sigismember(&omask, sig);
+ return !sigismember(&omask, sig);
}
int
notifyseton(sig->sig, !(sig->flags&NoNotify));
}
}
-
blob - 9d4e2d077235c8b6f56a1d0c30837543c1dc6659
blob + c999f49c15746137278d5f033f90a0cec1ff2c80
--- src/lib9/opentemp.c
+++ src/lib9/opentemp.c
close(fd);
return fd1;
}
-
blob - 3b15d3b8aa4fb259ed7e21e02f3eb4d4a9a77bdd
blob + c50587fc0041de61a57ca347469905486df17246
--- src/lib9/pin.c
+++ src/lib9/pin.c
void (*_pin)(void) = nop;
void (*_unpin)(void) = nop;
-
blob - b8ef94278fc8595269192e85bbf9f8219bdc4d6c
blob + 68e6d2f669fc7ef180e18ccded9257ec368bedad
--- src/lib9/postnote.c
+++ src/lib9/postnote.c
return killpg(pid, sig);
}
}
-
-
blob - e64e9194f3ce007722cd24b76e3e4b2059f7c5b1
blob + fb493c721704775f8ffd9419b58e149c01f60b70
--- src/lib9/priv.c
+++ src/lib9/priv.c
up = _p9uproc(0);
return &up->priv[i];
}
-
blob - f850009ad003122a0ff59286d6d0f67ff564f662
blob + 8ab6592328bd700a385d1accd6d1104573c54a8b
--- src/lib9/quote.c
+++ src/lib9/quote.c
if(__needsquotes(s, "elen) == 0)
return strdup(s);
-
+
ret = malloc(quotelen+1);
if(ret == nil)
return nil;
if(__runeneedsquotes(s, "elen) == 0)
return runestrdup(s);
-
+
ret = malloc((quotelen+1)*sizeof(Rune));
if(ret == nil)
return nil;
blob - bbd08b0ac0bc6b9fa999cb1d3c90344a4e0eb6fc
blob + c737b49ddfb823a18814320932e4d93497f2cedf
--- src/lib9/rfork.c
+++ src/lib9/rfork.c
pid = strtol(buf, &q, 0);
}else{
/*
- * Child - fork a new child whose wait message can't
+ * Child - fork a new child whose wait message can't
* get back to the parent because we're going to exit!
*/
signal(SIGCHLD, SIG_IGN);
blob - 3b8e7daab10700c8c723a0f24479cc5f99df4cb6
blob + 75e0695fc9835b3baf5f27aa2e63c2df29d93f13
--- src/lib9/searchpath.c
+++ src/lib9/searchpath.c
free(path);
return nil;
}
-
blob - e2abb75993d7c334d6295b24f27edd5dfcf787f4
blob + e73225e2da7332c626685e92a29ae0f52a6a6324
--- src/lib9/sendfd.c
+++ src/lib9/sendfd.c
struct cmsghdr *cmsg;
int n;
char cms[CMSG_SPACE(sizeof(int))];
-
+
buf[0] = 0;
iov.iov_base = buf;
iov.iov_len = 1;
blob - 5ca31866fedf265fcf534e508e5be2a6e7107a47
blob + 5c67f0b60f428adc931babf5b95007db8c7b67dd
--- src/lib9/strdup.c
+++ src/lib9/strdup.c
memmove(t, s, l+1);
return t;
}
-
blob - 00229db0490f5480adf3cb2da57900db995aeab9
blob + 11f4234c6a9aedf74a3f463893a99e7be57756bd
--- src/lib9/sysfatal.c
+++ src/lib9/sysfatal.c
fprint(2, "%s: %s\n", argv0 ? argv0 : "<prog>", buf);
exits("fatal");
}
-
blob - 06ab5a6036f2357464351485e3fc57411d4b4191
blob + c602ce452a889301ea7e80ec622ea481dc2a784a
--- src/lib9/testfltfmt.c
+++ src/lib9/testfltfmt.c
&& !numclose(ref, buf)) {
d1 = fmtstrtod(ref, 0);
d2 = fmtstrtod(buf, 0);
- fprintf(stderr, "%s: ref='%s'%s fmt='%s'%s\n",
- format,
- ref, d1==fmtvals[i] ? "" : " (ref is inexact!)",
+ fprintf(stderr, "%s: ref='%s'%s fmt='%s'%s\n",
+ format,
+ ref, d1==fmtvals[i] ? "" : " (ref is inexact!)",
buf, d2==fmtvals[i] ? "" : " (fmt is inexact!)");
// exits("oops");
}
&& !numclose(ref, buf)) {
d1 = fmtstrtod(ref, 0);
d2 = fmtstrtod(buf, 0);
- fprintf(stderr, "%s: ref='%s'%s fmt='%s'%s\n",
- format,
- ref, d1==fmtvals[i] ? "" : " (ref is inexact!)",
+ fprintf(stderr, "%s: ref='%s'%s fmt='%s'%s\n",
+ format,
+ ref, d1==fmtvals[i] ? "" : " (ref is inexact!)",
buf, d2==fmtvals[i] ? "" : " (fmt is inexact!)");
// exits("oops");
}
blob - fd2b7039f2736575a425add24a78a6ff86fe86c2
blob + 11708ba30233ddf000753eab739f7aa2428262c4
--- src/lib9/testfmt.c
+++ src/lib9/testfmt.c
verify(smprint("%d", 23), "23");
verify(smprint("%i", 23), "23");
verify(smprint("%Zi", 1234, 23), "23");
-
+
/* ANSI and their wacky corner cases */
verify(smprint("%.0d", 0), "");
verify(smprint("%.0o", 0), "");
verify(smprint("%.0x", 0), "");
verify(smprint("%#.0o", 0), "0");
verify(smprint("%#.0x", 0), "");
-
+
/* difficult floating point tests that many libraries get wrong */
verify(smprint("%.100f", 1.0), "1.0000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000");
verify(smprint("%.100g", 1.0), "1");
verify(smprint("%3$d %4$*5$06d %2$d %1$d", 444, 333, 111, 222, 20), "111 000222 333 444");
verify(smprint("%3$hd %4$*5$06d %2$d %1$d", 444, 333, (short)111, 222, 20), "111 000222 333 444");
verify(smprint("%3$\xe2\x98\xba""d %5$06d %2$d %1$d", 444, 333, 555, 111, 222), "111 000222 333 444");
-
+
/* test %'d formats */
verify(smprint("%'d %'d %'d", 1, 2222, 33333333), "1 2,222 33,333,333");
verify(smprint("%'019d", 0), "000,000,000,000,000");
blob - 242befb4ef956597bacea3e142410c81d230ebf5
blob + b2c04208f96c3a4e2bc1aea68ae48cf1a91fcc28
--- src/lib9/testprint.c
+++ src/lib9/testprint.c
main(int argc, char **argv)
{
char c;
-
+
c = argv[1][strlen(argv[1])-1];
if(c == 'f' || c == 'e' || c == 'g' || c == 'F' || c == 'E' || c == 'G')
print(argv[1], atof(argv[2]));
blob - 367063678baf5c1e46c9ae06145dea695f5a1f7a
blob + 92ad2ca4725a45900aa6d2d36cd2b12bb744f7ef
--- src/lib9/time.c
+++ src/lib9/time.c
*tt = t;
return t;
}
-
blob - 5edf439d1a5a882081b293f64a78aa71d1a1a61e
blob + 58bbe992705c9e362f93099c2a9b9127c09d0e16
--- src/lib9/tm2sec.c
+++ src/lib9/tm2sec.c
secs -= ti->tzoff;
}
}
-
+
if(secs < 0)
secs = 0;
return secs;
blob - a17bdf1d579df9fb8367b7d2d7c0e667966dfe90
blob + 84e5fe0edd71d908ede2ed2a1586c16726af7f85
--- src/lib9/u64.c
+++ src/lib9/u64.c
b24 = 0;
i = 0;
while(n-- > 0){
-
+
c = t64d[*(uchar*)in++];
if(c == INVAL)
continue;
blob - a11647236b0b6ae9ea55486e0dca057041d030cd
blob + a9c4cb6867d16ed8f4194da42dd55afd9e0997db
--- src/lib9/udp.c
+++ src/lib9/udp.c
*(u16int*)&sin.sin_port = *(u16int*)hdr->rport;
return sendto(fd, buf, n, 0, (struct sockaddr*)&sin, sizeof sin);
}
-
blob - b7db700c0e85744e4768bbb06a29b973a4c92fdd
blob + 251cae5d9a4b7d66a8fee735c46bdbbf9d85aa6d
--- src/lib9/unsharp.c
+++ src/lib9/unsharp.c
/*
* I don't want too many of these,
- * but the ones we have are just too useful.
+ * but the ones we have are just too useful.
*/
static struct {
char *old;
blob - e6128ae4daa3902aa0780f84cf8224454bc838c9
blob + 450f28f084c82855d723b0f342c1e03062213bd4
--- src/lib9/utf/lib9.h
+++ src/lib9/utf/lib9.h
typedef unsigned short ushort;
typedef unsigned int uint;
typedef unsigned long ulong;
-
blob - e40e33eb60f3a7311edad7475ae7180531bc6c4c
blob + 1ca8ace72e7834d6c0d901822136f9c9bbdfee6b
--- src/lib9/utf/plan9.h
+++ src/lib9/utf/plan9.h
#undef nelem
#define nelem(x) (sizeof (x)/sizeof (x)[0])
-
blob - f5944806f28d457c6d0875524ca20b338733e440
blob + bb2d82cb55ab7e19622cf7366922701033ac3bb4
--- src/lib9/utf/rune.c
+++ src/lib9/utf/rune.c
str[2] = Tx | (c & Maskx);
return 3;
}
-
+
/*
* four character sequence
* 010000-1FFFFF => T4 Tx Tx Tx
blob - 8170e7bcb811ec66ce1fc8e262ab9fba38c649c5
blob + 4f9d6f424e5563677c7df8a0dcfc44146f8e8131
--- src/lib9/utf/runestrdup.c
+++ src/lib9/utf/runestrdup.c
#include "utf.h"
Rune*
-runestrdup(Rune *s)
-{
+runestrdup(Rune *s)
+{
Rune *ns;
ns = malloc(sizeof(Rune)*(runestrlen(s) + 1));
blob - 1ff41813b86d48e39d7e8d9258c5a894018e3025
blob + 1db7076d5772664229d465aa935cf11228bee065
--- src/lib9/utf/utfdef.h
+++ src/lib9/utf/utfdef.h
#undef nelem
#define nelem ((void*)0)
-
blob - 31d8c02af7aba63d3944c8837a6c7a3cf5c1ae2e
blob + 17d767865cc351772407f48f99a88a66b9c84578
--- src/lib9/wait.c
+++ src/lib9/wait.c
return _wait(awaitfor(pid, buf, sizeof buf-1), buf);
}
-
blob - 3df8ef89cda2c503373c8212112314f279ea0f29
blob + 4c90bb7861642e573f34e7e642eac8bf4815048f
--- src/lib9/waitpid.c
+++ src/lib9/waitpid.c
}
return atoi(fld[0]);
}
-
blob - 91f1885a85236e1dc5b360d747feefff870dedef
blob + f8ae442dd3348d6557aad37fe694a052c7aee08a
--- src/lib9/zoneinfo.c
+++ src/lib9/zoneinfo.c
/*
* Access local time entries of zoneinfo files.
* Formats 0 and 2 are supported, and 4-byte timestamps
- *
+ *
* Copyright © 2008 M. Teichgräber
* Contributed under the terms of the Lucent Public License 1.02.
*/
blob - 55e60df9f1f3558a65169463a895278dab698fda
blob + e2ea963d5a362ac9ca4902995c7d2f392b0b281f
--- src/lib9/zoneinfo.h
+++ src/lib9/zoneinfo.h
extern int zonelookuptinfo(Tinfo*, tlong);
extern int zonetinfo(Tinfo*, int);
extern void zonedump(int fd);
-
blob - 151e45ffa36d994a575a4126fbffeae72cccd279
blob + 56f614fe61e3161d7ea0014891a93e3de136629b
--- src/lib9p/_post.c
+++ src/lib9p/_post.c
close(p->s->srvfd);
free(p);
}
-
blob - a18b09236243038e74b8fa4c3ed2ef52298d9039
blob + ea083993baa57f1fb743750730d9d60246b59a1c
--- src/lib9p/file.c
+++ src/lib9p/file.c
{
File *fp;
Filelist *fl;
-
+
fp = f->parent;
if(fp == nil){
werrstr("no parent");
return q;
}
-
+
Tree*
alloctree(char *uid, char *gid, ulong mode, void (*destroy)(File*))
{
blob - 1be11ce0fbd74853ab7d5869e68c88f07194252c
blob + 152493a3141099277a376feb7995941b8f23c859
--- src/lib9p/intmap.c
+++ src/lib9p/intmap.c
free(p);
}
}
-
+
free(map);
}
for(lf=&map->hash[hashid(id)]; *lf; lf=&(*lf)->link)
if((*lf)->id == id)
break;
- return lf;
+ return lf;
}
/*
ov = nil;
}
wunlock(&map->rwlock);
- return ov;
+ return ov;
}
int
rv = 1;
}
wunlock(&map->rwlock);
- return rv;
+ return rv;
}
void*
blob - 397bca0f12c90c88dab35689d9c1fad3b0561544
blob + 88d24cd43e6b91886c932a56560f4556d194b7bd
--- src/lib9p/mem.c
+++ src/lib9p/mem.c
setmalloctag(t, getcallerpc(&s));
return t;
}
-
blob - 753ae79db404da55f8ae9c85d4db067aa4522b9f
blob + b8dff3d37b2643cd5e370343f37a81ca6c36d778
--- src/lib9p/parse.c
+++ src/lib9p/parse.c
va_list arg;
char *p, *e;
char err[ERRMAX];
-
+
e = err+ERRMAX-10;
va_start(arg, fmt);
p = vseprint(err, e, fmt, arg);
blob - 09296a8899338c6a412742afeb4e53e61e67ae49
blob + 4ee99bc8df69deb2f6179dbe1f3dc8ddfce7e697
--- src/lib9p/post.c
+++ src/lib9p/post.c
_post3(p);
}
}
-
blob - 83347050b96c8b3aecfba0998c5a4ff10da3dc32
blob + 9acbcdc5bce27610c2e85a657567b217dfc2f19e
--- src/lib9p/req.c
+++ src/lib9p/req.c
{
freemap(p->map, (void(*)(void*))p->destroy);
free(p);
-}
+}
Req*
allocreq(Reqpool *pool, ulong tag)
blob - d12e35223f1a06411f4f886feaca3810a0de2bbd
blob + c3d654793091f5976a2ee3b6d5f0c01c9c9bc14e
--- src/lib9p/srv.c
+++ src/lib9p/srv.c
if(chatty9p)
if(r->error)
fprint(2, "<-%d- %F: %s\n", s->infd, &r->ifcall, r->error);
- else
+ else
fprint(2, "<-%d- %F\n", s->infd, &r->ifcall);
return r;
default:
assert(0);
case OREAD:
- p = AREAD;
+ p = AREAD;
break;
case OWRITE:
p = AWRITE;
p = AREAD|AWRITE;
break;
case OEXEC:
- p = AEXEC;
+ p = AEXEC;
break;
}
if(r->ifcall.mode&OTRUNC)
return;
if(r->fid->file){
if(removefile(r->fid->file) < 0){
- snprint(errbuf, ERRMAX, "remove %s: %r",
+ snprint(errbuf, ERRMAX, "remove %s: %r",
r->fid->file->dir.name);
r->error = errbuf;
}
if(r->d.muid)
r->d.muid = estrdup9p(r->d.muid);
}
- if(srv->stat)
- srv->stat(r);
+ if(srv->stat)
+ srv->stat(r);
else if(r->fid->file)
respond(r, nil);
else
while(r = getreq(srv)){
if(r->error){
respond(r, r->error);
- continue;
+ continue;
}
switch(r->ifcall.type){
default:
assert(r->pool);
goto free;
}
-
+
assert(r->responded == 0);
r->error = error;
* There is a race here - we must remove the entry before
* the write, so that if the client is very fast and reuses the
* tag, the read loop won't think it is still in use.
- *
- * By removing the entry before the write, we open up a
+ *
+ * By removing the entry before the write, we open up a
* race with incoming Tflush messages. Specifically, an
* incoming Tflush might not see r even though it has not
* yet been responded to. It would then send an Rflush
* There are no references other than in our r->flush array,
* so no one else should be accessing r concurrently.
* Close the fid now, before responding to the message.
- *
+ *
* If the client is behaving (there are no outstanding T-messages
* that reference r->fid) and the message is a Tclunk or Tremove,
- * then this closefid will call destroyfid.
- *
- * This means destroyfid can't piddle around
+ * then this closefid will call destroyfid.
+ *
+ * This means destroyfid can't piddle around
* indefinitely (we're holding srv->wlock!), but it provides
* for tighter semantics as to when destroyfid is called.
*
fprint(2, "postfd successful\n");
return 0;
}
-
blob - 210b16849df20ae241a8a6332af511415c29a6e6 (mode 755)
blob + 210b16849df20ae241a8a6332af511415c29a6e6 (mode 644)
blob - 9303b17dd209afd77ed044c3e2f088c9d46d40f8
blob + 34737b31baf5d38160c06c1ba029630759b9d77f
--- src/lib9pclient/close.c
+++ src/lib9pclient/close.c
{
int n;
Fcall tx, rx;
-
+
tx.type = Tremove;
tx.fid = fid->fid;
n = _fsrpc(fid->fs, &tx, &rx, 0);
blob - 62e26b2293455200a8bddd08b19d65b8d7901b57
blob + f18b6547eeeb42312e0e4bb547769e782059eb28
--- src/lib9pclient/create.c
+++ src/lib9pclient/create.c
{
CFid *fid;
char *p, *dir, *elem;
-
+
p = strrchr(name, '/');
if(p == nil){
dir = "";
blob - c6b1c3e92b016ce44aefa50b19848bf2e98879bf
blob + f1b9b0857998c749b891ca439bdaefd86bac0aed
--- src/lib9pclient/fs.c
+++ src/lib9pclient/fs.c
{
CFsys *fs;
int n;
-
+
fmtinstall('F', fcallfmt);
fmtinstall('D', dirfmt);
fmtinstall('M', dirmodefmt);
fs->iorecv = ioproc();
fs->iosend = ioproc();
muxinit(&fs->mux);
-
+
strcpy(fs->version, "9P2000");
if((n = fsversion(fs, 8192, fs->version, sizeof fs->version)) < 0){
werrstr("fsversion: %r");
blob - a9cc29e6611b3e4039fdc2ec463bdf33774bde6b
blob + 65225ecbc19d4b0e917fa0ef6aeedf14ba4fa1e6
--- src/lib9pclient/ns.c
+++ src/lib9pclient/ns.c
fsunmount(fs);
return fid;
}
-
blob - 7ed44450300690a2bae59b222b8820979374906f
blob + 5effa78b1e271b78e187b2350ece1128e4962ab1
--- src/lib9pclient/print.c
+++ src/lib9pclient/print.c
return -1;
return n;
}
-
blob - 605372884cd371b0f3f41476c76e5a98f1e49aa8
blob + ea94e9aa406e1798a7f760edd51b4386e499ca9c
--- src/lib9pclient/read.c
+++ src/lib9pclient/read.c
}
}
free(freep);
-
+
return rx.count;
}
}
return tot;
}
-
-
blob - b0ce2da8d01897ce22817faa9afad4452e344441
blob + 4f0e85c8ae686e9d86f9282d875e64df140f253a
--- src/lib9pclient/remove.c
+++ src/lib9pclient/remove.c
return -1;
return fsfremove(fid);
}
-
blob - 9c69446aa74e2705649db85b7a7d0cffc508c062
blob + 96450fbd4068294e958a50c79ef2f8c17f6262dc
--- src/lib9pclient/stat.c
+++ src/lib9pclient/stat.c
if((fid = fswalk(fs->root, name)) == nil)
return nil;
-
+
d = fsdirfstat(fid);
fsclose(fid);
return d;
}
return d;
}
-
blob - 26e44f8e86cdb3926b4149378640caccba8a9774
blob + 633f39e390bbb7d68c75d464e1b677406bcc7eb4
--- src/lib9pclient/wstat.c
+++ src/lib9pclient/wstat.c
if((fid = fswalk(fs->root, name)) == nil)
return -1;
-
+
n = fsdirfwstat(fid, d);
fsclose(fid);
return n;
blob - 86c9bf0c91a4e6f3c89e9437eb6e9d3efa4b148f
blob + 38252a736f97e6d26d048a14498a2df6f7747549
--- src/libString/s_getline.c
+++ src/libString/s_getline.c
* Leading whitespace and newlines are removed.
*
* Empty lines and lines starting with '#' are ignored.
- */
+ */
extern char *
s_getline(Biobuf *fp, String *to)
{
blob - 5cf2a1414ceb01f50e3e2e2990ce7df75d15bc26
blob + 62cda996c1972cc0208bef0397b80bcb3e1091cf
--- src/libString/s_grow.c
+++ src/libString/s_grow.c
/* grow a String's allocation by at least `incr' bytes */
extern String*
-s_grow(String *s, int incr)
+s_grow(String *s, int incr)
{
char *cp;
int size;
return s;
}
-
blob - 27b69850ea0f1ba3dd17a159884e75933dcfb112
blob + 8cbacd185fed8a36982a6064dce672d28e0c1a45
--- src/libString/s_memappend.c
+++ src/libString/s_memappend.c
s_terminate(to);
return to;
}
-
blob - fb41f9328c3576c47a6330c2b747ec205e0fee18
blob + 32470a9e420b20ed75123165dea2b711968b259d
--- src/libString/s_nappend.c
+++ src/libString/s_nappend.c
s_terminate(to);
return to;
}
-
blob - bcf2aef9dcecc7a19cdf3b9c033281a385de624e
blob + 6691356f0709aa03efcdde3683c2a8fea22b076f
--- src/libString/s_parse.c
+++ src/libString/s_parse.c
from->ptr++;
for (;*from->ptr != '\'' && *from->ptr != '\0'; from->ptr++)
s_putc(to, *from->ptr);
- if (*from->ptr == '\'')
+ if (*from->ptr == '\'')
from->ptr++;
} else if (*from->ptr == '"') {
from->ptr++;
for (;*from->ptr != '"' && *from->ptr != '\0'; from->ptr++)
s_putc(to, *from->ptr);
- if (*from->ptr == '"')
+ if (*from->ptr == '"')
from->ptr++;
} else {
for (;!isspace(*from->ptr) && *from->ptr != '\0'; from->ptr++)
blob - 520f16a68749966fb3490d9f6bd8e51da1b2fefb
blob + c859b2c518ec3927f79270f36860586f3422801c
--- src/libString/s_rdinstack.c
+++ src/libString/s_rdinstack.c
* Leading whitespace and newlines are removed.
* Lines starting with #include cause us to descend into the new file.
* Empty lines and other lines starting with '#' are ignored.
- */
+ */
extern char *
s_rdinstack(Sinstack *sp, String *to)
{
blob - 7745d677a0d5afea8b4e843acf60fa5afa8c1a7f
blob + 20583ef2590585b51a16067b3394eb1a474a7c69
--- src/libString/s_read.c
+++ src/libString/s_read.c
/* Append up to 'len' input bytes to the string 'to'.
*
* Returns the number of characters read.
- */
+ */
extern int
s_read(Biobuf *fp, String *to, int len)
{
blob - b1de5ac458fd24092c55a3751b5b62c5749e2ac3
blob + e5e2a1d93136185029135987ba139e297895855f
--- src/libString/s_read_line.c
+++ src/libString/s_read_line.c
*
* Returns a pointer to the character string (or 0).
* Trailing newline is left on.
- */
+ */
extern char *
s_read_line(Biobuf *fp, String *to)
{
blob - 8904b4c20e2dc84364868ddab5e1076617cd6839
blob + 3fd9d4fc030e7949e50707578f73a075792dc989
--- src/libacme/acme.c
+++ src/libacme/acme.c
{
char buf[100];
Win *w;
-
+
mountacme();
if(ctl == nil){
snprint(buf, sizeof buf, "%d/ctl", id);
winopenfd(Win *w, char *name, int mode)
{
char buf[100];
-
+
snprint(buf, sizeof buf, "%d/%s", w->id, name);
return fsopenfd(acmefs, buf, mode);
}
char buf[40], *p;
uint q0;
int n;
-
+
n = fspread(wfid(w, "addr"), buf, sizeof buf-1, 0);
if(n <= 0)
return -1;
{
char *buf;
int n, tot, m;
-
+
m = 128;
buf = emalloc(m+1);
tot = 0;
Event e[2];
Win *w;
int i;
-
+
w = v;
i = 0;
for(;;){
blob - 8adeefe6c7841135c880ed70607085d44909c088
blob + be8d1ad31bbd372a7d332c0b514a1114e7bcf4bd
--- src/libauth/attr.c
+++ src/libauth/attr.c
return nil;
return a->val;
}
-
blob - 257bafe76e5526b308de60971599c7440c495d83
blob + a5fe4411719bba5bfce246dd060d7c1ce7e7b71a
--- src/libauth/auth_proxy.c
+++ src/libauth/auth_proxy.c
#include <9pclient.h>
#include "authlocal.h"
-enum {
+enum {
ARgiveup = 100
};
auth_freerpc(rpc);
return ai;
}
-
blob - b3cf6665f16a877f6e0899d81066a83c45a2c31a
blob + 4e27190037a9b57aaef511f73c05157c43edc60a
--- src/libauth/auth_respond.c
+++ src/libauth/auth_respond.c
_freeattr(a);
auth_freerpc(rpc);
- return nresp;
+ return nresp;
}
blob - bece208a305d138dab08ab0d1d4c5026fa3acc2f
blob + 4cb33bbd1fd0bf158c468cd7ef027e179da3aa8c
--- src/libauth/fsamount.c
+++ src/libauth/fsamount.c
CFid *afid, *fid;
AuthInfo *ai;
CFsys *fs;
-
+
fs = fsinit(fd);
if(fs == nil)
return nil;
fssetroot(fs, fid);
return fs;
}
-
blob - 1447904ac733cc5d26a386cca9e4f16e04bc987d
blob + 4e9b827afc8366215fd869b16f3935bfbaf7d012
--- src/libauth/nsamount.c
+++ src/libauth/nsamount.c
CFid *afid, *fid;
AuthInfo *ai;
CFsys *fs;
-
+
fs = nsinit(name);
if(fs == nil)
return nil;
fssetroot(fs, fid);
return fs;
}
-
blob - 372825a872ac39dc29500518363db2bc11bf1e6b
blob + 427520a535c632a54688c948f96266fefaa1a2d2
--- src/libauthsrv/convM2T.c
+++ src/libauthsrv/convM2T.c
STRING(key, DESKEYLEN);
USED(p);
}
-
blob - 8b2422f1b5e2064e6655b777972a2547f9bdc2a6
blob + 7efc0b2dd878dea8caab0c1fde54939643c19e51
--- src/libauthsrv/convPR2M.c
+++ src/libauthsrv/convPR2M.c
encrypt(key, ap, n);
return n;
}
-
blob - 3a7610a713808d3e0c72a95e4d6519a3564fb1a3
blob + 04000aad4b368a49f21e997c2a552b4e0e00817a
--- src/libauthsrv/convTR2M.c
+++ src/libauthsrv/convTR2M.c
n = p - (uchar*)ap;
return n;
}
-
blob - f65db9846139ccfc7f88c8c8ea37f94252c2400a
blob + 337203f78d7dfd9fd6e5f267dc635b8e4ceac2a7
--- src/libauthsrv/readnvram.c
+++ src/libauthsrv/readnvram.c
xreadcons(char *prompt, char *def, int secret, char *buf, int nbuf)
{
char *p;
-
+
p = readcons(prompt, def, secret);
if(p == nil)
return nil;
if(rootsects <= 0 || rootsects > 64)
return -1;
- /*
+ /*
* read root. it is contiguous to make stuff like
* this easier
*/
*/
return rootoff + rootsects*sectsize + (n-2)*sectsize*b->clustsize;
}
-
blob - 7c9b39e9325fb6d422448fca06aed9a86a23bd1c
blob + cc8e53d828bc8e2a6a88deabfd1838129b80f5e3
--- src/libbio/bcat.c
+++ src/libbio/bcat.c
fprint(2, "writing during %s: %r\n", name);
}
if(n < 0)
- fprint(2, "reading %s: %r\n", name);
+ fprint(2, "reading %s: %r\n", name);
}
int
blob - 52baf517178584aa36f24c7b397f00f420b53fc8
blob + 30d40db4c224e2056531f63445a931e1f96908f9
--- src/libbio/brdstr.c
+++ src/libbio/brdstr.c
}
ip += j;
}
-
+
/*
* full buffer without finding; add to user string and continue
*/
blob - 60b105fa5092c5cbfb0a8a11248bd24eb706a40c
blob + 0b1aaf6b928c25b8f90ab4438e3995115db9e558
--- src/libbio/bvprint.c
+++ src/libbio/bvprint.c
#include "lib9.h"
#include <bio.h>
-static int
+static int
fmtBflush(Fmt *f)
{
Biobuf *bp;
blob - 180471e16c78f0e1e559670b2be3083d2640958f
blob + e4897023a988b7f01f375bf51f7cdf2096ec078d
--- src/libbio/lib9.std.h
+++ src/libbio/lib9.std.h
#define seek(fd, offset, whence) lseek(fd, offset, whence)
#define create(name, mode, perm) creat(name, perm)
-
blob - 3428c46758a9a14264e6263070145bec124a9f69
blob + 0230d3290356a006e04e61955f278e166e0c658c
--- src/libdisk/disk.c
+++ src/libdisk/disk.c
/*
* Discover the disk geometry by various sleazeful means.
- *
+ *
* First, if there is a partition table in sector 0,
* see if all the partitions have the same end head
- * and sector; if so, we'll assume that that's the
+ * and sector; if so, we'll assume that that's the
* right count.
- *
+ *
* If that fails, we'll try looking at the geometry that the ATA
* driver supplied, if any, and translate that as a
- * BIOS might.
- *
+ * BIOS might.
+ *
* If that too fails, which should only happen on a SCSI
* disk with no currently defined partitions, we'll try
* various common (h, s) pairs used by BIOSes when faking
}
}
-
+
disk->size = disk->secs * disk->secsize;
if(disk->size <= 0) {
strcpy(disk->part, "");
d->type = Tfile;
return openfile(d);
}
-
blob - ee30fc92a5d278e9aaaebad58aaba5c8f05b78f8
blob + 43e3d9c49d11f39b4e1d5e54cd9b9617189d9d41
--- src/libdisk/proto.c
+++ src/libdisk/proto.c
#undef warn
#define warn protowarn
-#undef getmode
+#undef getmode
#define getmode protogetmode
typedef struct File File;
static void
setnames(Mkaux *mkaux, File *f)
{
-
+
if(f->old){
if(f->old[0] == '/')
setname(mkaux, &mkaux->oldfile, f->old, "");
blob - 3f351053a369d74a85114140d68a959b905961f2
blob + b790ef3b0756310c8755aee8efa7b3aa1e94fb84
--- src/libdisk/scsi.c
+++ src/libdisk/scsi.c
/*
* Now thread-safe.
*
- * The codeqlock guarantees that once codes != nil, that pointer will never
+ * The codeqlock guarantees that once codes != nil, that pointer will never
* change nor become invalid.
*
* The QLock in the Scsi structure moderates access to the raw device.
codes[n] = '\0';
qunlock(&codeqlock);
}
-
+
char*
scsierror(int asc, int ascq)
{
if((n=_scsicmd(s, req, sizeof(req), sense, sizeof(sense), Sread, 0)) < 14)
if(scsiverbose)
fprint(2, "reqsense scsicmd %d: %r\n", n);
-
+
if(_scsiready(s, 0) < 0)
if(scsiverbose)
fprint(2, "unit not ready\n");
-
+
key = sense[2];
code = sense[12];
if(code == 0x17 || code == 0x18) { /* recovered errors */
s->rawfd = rawfd;
s->inquire = p;
s->changetime = time(0);
-
+
if(scsiready(s) < 0)
goto Error1;
blob - 94ea511163f17741c45dfe03a861743ab0082188
blob + 552078a9e5ecda28fd5421273ba24ab3248d51ca
--- src/libdiskfs/block.c
+++ src/libdiskfs/block.c
return;
if(!b->_close){
fprint(2, "no blockPut\n");
- abort();
+ abort();
}
(*b->_close)(b);
}
blob - 7b06fa4f3e0235809ca35e3c2012d54bd9364d02
blob + 2888ae8369eacda90185446424cbfddedf30f798
--- src/libdiskfs/cache.c
+++ src/libdiskfs/cache.c
#include <diskfs.h>
/*
- * Disk cache. Caches by offset, so higher levels have
+ * Disk cache. Caches by offset, so higher levels have
* to deal with alignment issues (if we get asked for the
* blocks at offsets 0 and 1, we'll do two reads).
*/
if(b->offset != ~(u64int)0){
fprint(2, "bad offset in addtohash\n");
- return;
+ return;
}
b->offset = offset;
h = offset % d->nhash;
return b;
}
-/*
- * It's okay to remove these from the hash table.
+/*
+ * It's okay to remove these from the hash table.
* Either the block is in use by someone or it is on
* the lru list. If it's in use it will get put on the lru
* list once the refs go away.
blockput(b->subblock);
free(d);
}
-
+
/* needn't be fast */
static int
isprime(int n)
blob - b55f1eb3dadc4d18291f14212b1d1b77af23ffac
blob + ce16f37d3d8e9b3858f89ed0d890b88d14849aac
--- src/libdiskfs/ext2.c
+++ src/libdiskfs/ext2.c
if(bno != vbno)
return nil;
-/*
+/*
if(bno < fs->firstblock)
return diskread(fs->disk, fs->blocksize, (u64int)bno*fs->blocksize);
*/
if((bits[boff>>3] & (1<<(boff&7))) == 0){
if(debug)
fprint(2, "block %d not allocated in group %d: bitblock %d/%lld bits[%d] = %#x\n",
- boff, bno/fs->blockspergroup,
+ boff, bno/fs->blockspergroup,
(int)bitblock,
bitpos,
boff>>3,
obno = bno;
if(bno < NDIRBLOCKS){
if(debug)
- fprint(2, "fileblock %d -> %d...",
+ fprint(2, "fileblock %d -> %d...",
bno, ino->block[bno]);
return ext2datablock(fs, ino->block[bno], size);
}
if((ok = inoperm(&ino, au, AREAD)) != Nfs3Ok)
return ok;
- if(debug) print("readdir cookie %#llux ino.size %#llux\n",
+ if(debug) print("readdir cookie %#llux ino.size %#llux\n",
(u64int)cookie, (u64int)ino.size);
if(cookie >= ino.size){
blob - 7ddd400a94457930b7e37d45a6a32d297edb3bb6
blob + f4c32ce3a9d1aa297927965769f1ef2d92a97243
--- src/libdiskfs/ext2.h
+++ src/libdiskfs/ext2.h
u32int revlevel; /* Revision level */
u16int defresuid; /* Default uid for reserved blocks */
u16int defresgid; /* Default gid for reserved blocks */
-
+
/* the following are only available with revlevel = 1 */
u32int firstino; /* First non-reserved inode */
u16int inosize; /* size of inode structure */
Disk *disk;
Fsys *fsys;
};
-
blob - 4d12512c832090dafb8f0d810353305b12b676de
blob + 0eb1c995e962ddf0c13cff235606a7b3c6d34ae2
--- src/libdiskfs/fat.c
+++ src/libdiskfs/fat.c
USED(disk);
return nil;
}
-
blob - d8e2339245c284d54173c45f8d837f9ad958519c
blob + 70552e492fa1a9202f06656f9e5ee48de82a27a2
--- src/libdiskfs/ffs.c
+++ src/libdiskfs/ffs.c
fs->nfrag = fsblk->nfrag;
fs->ndfrag = fsblk->ndfrag;
/*
- * used to use
- * fs->blockspergroup = (u64int)fsblk->_cylspergroup *
+ * used to use
+ * fs->blockspergroup = (u64int)fsblk->_cylspergroup *
* fsblk->secspercyl * BYTESPERSEC / fsblk->blocksize;
* for UFS1, but this should work for both UFS1 and UFS2
*/
free(fs);
free(fsys);
}
-
+
static int
checkfsblk(Fsblk *super)
{
blockput(b);
return nil;
}
-
+
return b;
}
ifetch(Ffs *fs, u64int bno, u32int off)
{
Block *b;
-
+
if(bno == BADBNO)
return BADBNO;
b = ffsdatablock(fs, bno, fs->blocksize);
if(bno < ppb*ppb)
return ifetch(fs, ifetch(fs, ino->ib[1], bno/ppb), bno%ppb);
bno -= ppb*ppb;
-
+
if(bno/ppb/ppb/ppb == 0) /* bno < ppb*ppb*ppb w/o overflow */
return ifetch(fs, ifetch(fs, ifetch(fs, ino->ib[2], bno/ppb/ppb), (bno/ppb)%ppb), bno%ppb);
-
+
fprint(2, "ffsfileblock %llud: way too big\n", bno+NDADDR+ppb+ppb*ppb);
return BADBNO;
}
ffsfileblock(Ffs *fs, Inode *ino, u64int bno, int size)
{
u64int b;
-
+
b = ffsfileblockno(fs, ino, bno);
if(b == ~0)
return nil;
inode1to2(Inode1 *i1, Inode *i2)
{
int i;
-
+
memset(i2, 0, sizeof *i2);
i2->mode = i1->mode;
i2->nlink = i1->nlink;
Inode ino;
Nfs3Status ok;
Ffs *fs;
-
+
fs = fsys->priv;
if((ok = handle2ino(fs, h, nil, &ino)) != Nfs3Ok){
nfs3errstr(ok);
blob - 6a5a387d3c6fc2ed3101a92603b0fe90c62d37bc
blob + d7881f15f8d03d6537286fdc2bd7a218ff75dccb
--- src/libdiskfs/ffs.h
+++ src/libdiskfs/ffs.h
FSMAGIC = 0x011954,
FSMAGIC2 = 0x19540119,
FSCHECKSUM = 0x7c269d38,
-
+
/* Fsblk.inodefmt */
FS42INODEFMT = -1,
FS44INODEFMT = 2,
Disk *disk;
};
-
blob - 6784dab4009c0225a1f63056587202ab9a60e5e6
blob + 03e97a15a4bc14acee8a2a7881344e64761be733
--- src/libdiskfs/hfs.c
+++ src/libdiskfs/hfs.c
fsys->_readdir = hfsreaddir;
fsys->_close = hfsclose;
fsys->disk = disk;
-
+
if(hfswrapper(fsys) < 0 || hfssync(fsys) < 0)
goto error;
int magic, hfsstart, subsig, substart, subnblocks;
u32int hfsblocksize;
u64int offset, size;
-
+
fs = fsys->priv;
disk = fsys->disk;
if((b = diskread(disk, 162, 1024)) == nil)
substart = get16(mdb+126);
subnblocks = get16(mdb+128);
blockput(b);
-
+
if(magic != Hfssig)
return 0;
if(subsig != Hfsplussig && subsig != Hfsxsig)
return 0;
-
+
offset = hfsstart*512 + substart*hfsblocksize;
size = subnblocks*hfsblocksize;
if(ino.u.nentries>>31)
return Nfs3ErrIo;
nentries = ino.u.nentries*2; /* even data, odd resource */
-
+
i = cookie>>32;
cnid = cookie&0xFFFFFFFF;
if(debug) print("readdir %ud %ud %ud...", cnid, i, nentries);
goto badparent;
i++;
}
-
+
memset(&e, 0, sizeof e);
for(; i<nentries; i++){
rsrc = i&1;
blob - 662c33895eda4c70f41827bb7112f9f2fb829832
blob + bf5ebc9fe7016ed478385d2f492e9de5a76e4f5d
--- src/libdiskfs/hfs.h
+++ src/libdiskfs/hfs.h
wrapper.
Apple technical note 1150 documents the file system:
-
+
http://developer.apple.com/technotes/tn/tn1150.html
-
+
Briefly an hfs file system comprises a volume header, an
optional journal, and a set of forks.
-
+
Most fs metadata resides in forks including a block allocation
bitmap, a tree storing extents (q.v.) for forks and bad disk
blocks, and a tree storing catalog (file and directory)
NAMELEN = 255,
UTFNAMELEN = NAMELEN*UTFmax,
-
+
NEXTENTS = 8,
-
+
Dfork = 0, Rfork = 255,
-
+
/* fixed cnids */
RootpId = 1, RootId, ExtentsId, CatalogId,
BadblockId, AllocId, MinuserId = 16,
/* values in Node.type */
LeafNode = -1, IndexNode, HeaderNode, MapNode,
-
+
/* catalog record types */
Folder = 1, File, FolderThread, FileThread,
{
Tree *tree;
u32int cnid; /* tree->fork->cnid, for debugging prints */
-
+
Block *block; /* a node in the tree */
u32int nno;
Node node;
-
+
int rno; /* a record in the node */
int klen;
- uchar *key;
+ uchar *key;
int dlen;
uchar *data;
};
blob - 51d7c5e30b3ed61e35e17a56bceee1e1747a6953
blob + 216ad2775ee446b7724104af82e9bd707d5aaac4
--- src/libdiskfs/kfs.c
+++ src/libdiskfs/kfs.c
USED(disk);
return nil;
}
-
blob - dc5d171f877e0bf0692e6526c895e5a606506146
blob + 0da5a2346cc67cc9fd90a64ce72f791e60e2dd09
--- src/libdiskfs/part.c
+++ src/libdiskfs/part.c
diskpartsync(Disk *dd)
{
DiskPart *d = (DiskPart*)dd;
-
+
if(d->subdisk)
return disksync(d->subdisk);
return 0;
diskpartclose(Disk *dd)
{
DiskPart *d = (DiskPart*)dd;
-
+
if(d->subdisk)
diskclose(d->subdisk);
free(d);
diskpart(Disk *subdisk, u64int offset, u64int size)
{
DiskPart *d;
-
+
d = mallocz(sizeof(DiskPart), 1);
if(d == nil)
return nil;
-
+
d->subdisk = subdisk;
d->offset = offset;
d->size = size;
d->disk._read = diskpartread;
d->disk._sync = diskpartsync;
d->disk._close = diskpartclose;
-
+
return &d->disk;
}
blob - a497d5e06d3034168c026fed54a04eac78f29b67
blob + c6f15cae1e66d9c22c766eb4a0fc0cb07b93390e
--- src/libdiskfs/venti.c
+++ src/libdiskfs/venti.c
_nfilereads_darwin_sucks(); /* force Darwin ld to pull in file.o */
return nil;
}
-
blob - 72ca0446c71c73aff19c60236211b6e2613321ec
blob + d9be4b123e8b18b2898e4cbd97550e1e8c2fb76f
--- src/libdiskfs/vfile.c
+++ src/libdiskfs/vfile.c
walk down blocks
return the one
}
-
-
blob - 09d60ec9cb3b19f17fdb87ee56bff20dbfa48d8f
blob + 6d2b2d1567835232c0049ef5b0cb8f77d73d4d50
--- src/libdraw/allocimagemix.c
+++ src/libdraw/allocimagemix.c
if(qmask == nil)
qmask = allocimage(d, Rect(0,0,1,1), GREY8, 1, 0x3F3F3FFF);
-
+
if(d->screenimage->depth <= 8){ /* create a 2×2 texture */
t = allocimage(d, Rect(0,0,1,1), d->screenimage->chan, 0, color1);
if(t == nil)
blob - 1b19fc1c42a98bf81368b1a519134304a3175651
blob + d7c067a3fb6d8a588da2c72d922e6fcad1b8483a
--- src/libdraw/arith.c
+++ src/libdraw/arith.c
p = va_arg(f->args, Point);
return fmtprint(f, "[%d %d]", p.x, p.y);
}
-
blob - 02d976e1745ada42bc9355bb669a3e138847fd0a
blob + 5425ad44685c37f9a70fb51af60b7982c40b137d
--- src/libdraw/buildfont.c
+++ src/libdraw/buildfont.c
f->display->firstfont = f->next;
}
- if(f->lodpi != f)
+ if(f->lodpi != f)
freefont(f->lodpi);
if(f->hidpi != f)
freefont(f->hidpi);
blob - 5e94b016145ca11d827a7880b971137304833ab3
blob + 0cf2b668e36bd444259a06de61fbac156d0d6723
--- src/libdraw/chan.c
+++ src/libdraw/chan.c
p++;
while(*p && !isspace((uchar)*p)){
- if((q = strchr(channames, p[0])) == nil)
+ if((q = strchr(channames, p[0])) == nil)
return 0;
t = q-channames;
if(p[1] < '0' || p[1] > '9')
blob - 30a3d11e63e9a969b03993229f875643fd99d50b
blob + b1dc2999b9d2145a4d9a17fb7f882fbf18dfe99c
--- src/libdraw/computil.c
+++ src/libdraw/computil.c
#include <draw.h>
/*
- * compressed data are seuences of byte codes.
+ * compressed data are seuences of byte codes.
* if the first byte b has the 0x80 bit set, the next (b^0x80)+1 bytes
* are data. otherwise, it's two bytes specifying a previous string to repeat.
*/
blob - d3f83e8859975294320676ee3b302c1438c17581
blob + f72d35dff1f2db87d72a5e18b8e2282253472e8b
--- src/libdraw/draw.c
+++ src/libdraw/draw.c
a[1] = op;
}
}
-
+
static void
draw1(Image *dst, Rectangle *r, Image *src, Point *p0, Image *mask, Point *p1, Drawop op)
{
blob - f0b1d388a4d15be9ff5a93a5077754944d396f94
blob + ef0356b8b0d2c38ef83d7b4372f689dd8b68f5fc
--- src/libdraw/drawclient.c
+++ src/libdraw/drawclient.c
_displayconnect(Display *d)
{
int pid, p[2];
-
+
fmtinstall('W', drawfcallfmt);
fmtinstall('H', encodefmt);
-
+
if(pipe(p) < 0)
return -1;
if((pid=fork()) < 0){
d->mux->settag = drawsettag;
d->mux->aux = d;
muxinit(d->mux);
-
+
return 0;
}
int n;
uchar *msg;
Display *d;
-
+
msg = vmsg;
GET(msg, n);
d = mux->aux;
{
uchar *msg;
USED(mux);
-
+
msg = vmsg;
return msg[4];
}
{
uchar *msg;
USED(mux);
-
+
msg = vmsg;
msg[4] = tag;
return 0;
{
int n, nn;
void *tpkt, *rpkt;
-
+
n = sizeW2M(tx);
tpkt = malloc(n);
if(freep)
_displaycursor(Display *d, Cursor *c, Cursor2 *c2)
{
Wsysmsg tx, rx;
-
+
tx.type = Tcursor2;
if(c == nil){
memset(&tx.cursor, 0, sizeof tx.cursor);
_displaybouncemouse(Display *d, Mouse *m)
{
Wsysmsg tx, rx;
-
+
tx.type = Tbouncemouse;
tx.mouse = *m;
return displayrpc(d, &tx, &rx, nil);
_displaylabel(Display *d, char *label)
{
Wsysmsg tx, rx;
-
+
tx.type = Tlabel;
tx.label = label;
return displayrpc(d, &tx, &rx, nil);
void *p;
char *s;
Wsysmsg tx, rx;
-
+
tx.type = Trdsnarf;
if(displayrpc(d, &tx, &rx, &p) < 0)
return nil;
_displaywrsnarf(Display *d, char *snarf)
{
Wsysmsg tx, rx;
-
+
tx.type = Twrsnarf;
tx.snarf = snarf;
return displayrpc(d, &tx, &rx, nil);
{
void *p;
Wsysmsg tx, rx;
-
+
tx.type = Trddraw;
tx.count = n;
if(displayrpc(d, &tx, &rx, &p) < 0)
_displaywrdraw(Display *d, void *v, int n)
{
Wsysmsg tx, rx;
-
+
tx.type = Twrdraw;
tx.count = n;
tx.data = v;
_displayresize(Display *d, Rectangle r)
{
Wsysmsg tx, rx;
-
+
tx.type = Tresize;
tx.rect = r;
return displayrpc(d, &tx, &rx, nil);
{
fd_set rs, ws, xs;
struct timeval tv;
-
+
FD_ZERO(&rs);
FD_ZERO(&ws);
FD_ZERO(&xs);
return 1;
return 0;
}
-
blob - 09051bbc00861fdefabdcac15498f6c39190dfb1
blob + c74b3fafb6d22d56d621fee72a74ade97db7ce87
--- src/libdraw/drawfcall.c
+++ src/libdraw/drawfcall.c
PUTSTRING(uchar *p, char *s)
{
int n;
-
+
if(s == nil)
s = "";
n = strlen(s);
GETSTRING(uchar *p, char **s)
{
int n;
-
+
GET(p, n);
memmove(p, p+4, n);
*s = (char*)p;
p[n] = 0;
return n+4;
}
-
+
uint
sizeW2M(Wsysmsg *m)
{
convW2M(Wsysmsg *m, uchar *p, uint n)
{
int nn;
-
+
nn = sizeW2M(m);
if(n < nn || nn == 0 || n < 6)
return 0;
PUT(p+14, m->rect.max.x);
PUT(p+18, m->rect.max.y);
break;
- }
+ }
return nn;
}
convM2W(uchar *p, uint n, Wsysmsg *m)
{
int nn;
-
+
if(n < 6)
return 0;
GET(p, nn);
GET(p+14, m->rect.max.x);
GET(p+18, m->rect.max.y);
break;
- }
+ }
return nn;
}
drawfcallfmt(Fmt *fmt)
{
Wsysmsg *m;
-
+
m = va_arg(fmt->args, Wsysmsg*);
fmtprint(fmt, "tag=%d ", m->tag);
switch(m->type){
return fmtprint(fmt, "Trdmouse");
case Rrdmouse:
return fmtprint(fmt, "Rrdmouse x=%d y=%d buttons=%d msec=%d resized=%d",
- m->mouse.xy.x, m->mouse.xy.y,
+ m->mouse.xy.x, m->mouse.xy.y,
m->mouse.buttons, m->mouse.msec, m->resized);
case Tbouncemouse:
return fmtprint(fmt, "Tbouncemouse x=%d y=%d buttons=%d",
blob - c72fee26a737325752a67b228fd5d68887e39ad7
blob + 77c20d43aefd143a7f63055b4d239b19e7223c5f
--- src/libdraw/drawrepl.c
+++ src/libdraw/drawrepl.c
p.y = drawreplxy(r.min.y, r.max.y, p.y);
return p;
}
-
blob - b369c020020e51491281414351844e949b17e169
blob + 9d7e10c23607cf5f624ed3368150ce72bf128064
--- src/libdraw/event.c
+++ src/libdraw/event.c
newebuf(Slave *s, int n)
{
Ebuf *eb;
-
+
eb = malloc(sizeof(*eb) - sizeof(eb->u.buf) + n);
if(eb == nil)
drawerror(display, "events: out of memory");
{
uchar buf[100];
Wsysmsg w;
-
+
w.type = type;
convW2M(&w, buf, sizeof buf);
return muxrpcstart(display->mux, buf);
uchar *p;
void *v;
int n;
-
+
if(!muxrpccanfinish(r, &v))
return 0;
p = v;
* Also make sure that we don't interfere with app-specific locking.
*/
if(display->locking){
- /*
- * if locking is being done by program,
- * this means it can't depend on automatic
+ /*
+ * if locking is being done by program,
+ * this means it can't depend on automatic
* flush in emouse() etc.
*/
if(canqlock(&display->qlock)){
max = eslave[i].fd;
}
}
-
+
if(!canblock){
tv.tv_sec = 0;
tv.tv_usec = 0;
eresized(1);
return 1;
}
-
blob - c0235c4b3a57b5e5cd59f8d71a4276aa6f784e84
blob + 34121aafac7ea8c15d5c3b2e96f93b563a6ed21f
--- src/libdraw/font.c
+++ src/libdraw/font.c
c++;
h++;
}
-
+
/*
* Not found; toss out oldest entry
*/
break;
}
c = &f->cache[h]; /* may have reallocated f->cache */
-
+
Found:
wid += c->width;
c->age = f->age;
blob - ba6753909402e8e7eb505c6d685c4dd287227884
blob + ec4ccfe3ed7fe2f1dbc59f9b912352d90f42ef0b
--- src/libdraw/getsubfont.c
+++ src/libdraw/getsubfont.c
int y, x, x2, j;
uchar *src, *dst;
int srcn, dstn, n, mask, v, pack;
-
+
r = f->bits->r;
r2 = r;
r2.min.x *= scale;
r2.min.y *= scale;
r2.max.x *= scale;
r2.max.y *= scale;
-
+
srcn = bytesperline(r, f->bits->depth);
src = malloc(srcn);
dstn = bytesperline(r2, f->bits->depth);
f->bits = i;
f->height *= scale;
f->ascent *= scale;
-
+
for(j=0; j<f->n; j++) {
f->info[j].x *= scale;
f->info[j].top *= scale;
blob - aa864e1a3050599564fb79adb38752f49114c815
blob + c8cfebc806d5f8e9db49d31ccb89358b93c951e5
--- src/libdraw/icossin2.c
+++ src/libdraw/icossin2.c
#include <draw.h>
/*
- * Sine and Cosine of arctangents, calculated by
+ * Sine and Cosine of arctangents, calculated by
* (sin(atan(index/100.0))*1024.+0.5)
* (cos(atan(index/100.0))*1024.+0.5)
* To use, get rational tangent between 0<=tan<=1, scale by 100,
blob - 350365fe186e8045950b6714a65fada1b5a68bd1
blob + 31d90144052863c023906b70accbc823dcf77c88
--- src/libdraw/init.c
+++ src/libdraw/init.c
visibleclicks = p != nil && *p == '1';
if(visibleclicks) {
Font *f;
-
+
f = display->defaultfont;
mousebuttons = allocimage(display, Rect(0,0,64,22), screen->chan, 0, DWhite);
border(mousebuttons, mousebuttons->r, 1, display->black, ZP);
/*
* If there's an old screen, it has id 0. The 'J' request below
- * will try to install the new screen as id 0, so the old one
+ * will try to install the new screen as id 0, so the old one
* must be freed first.
*/
if(image){
image->clipr.min.y = atoi(info+9*12);
image->clipr.max.x = atoi(info+10*12);
image->clipr.max.y = atoi(info+11*12);
-
+
a = bufimage(d, 3);
a[0] = 'q';
a[1] = 1;
{
Image *i, *oi;
Font *f;
-
+
/* XXX check for destroyed? */
-
+
/*
* Libdraw promises not to change the value of "screen",
* so we have to reuse the image structure
free(disp->buf);
goto Error2;
}
-
+
if(_displaymux(disp) < 0
|| _displayconnect(disp) < 0
|| _displayinit(disp, label, winsize) < 0)
image = getimage0(disp, nil);
if(image == nil)
goto Error4;
-
+
disp->image = image;
disp->white = allocimage(disp, Rect(0, 0, 1, 1), GREY1, 1, DWhite);
disp->black = allocimage(disp, Rect(0, 0, 1, 1), GREY1, 1, DBlack);
free(disp->black);
goto Error4;
}
-
+
disp->opaque = disp->white;
disp->transparent = disp->black;
r = rectaddpt(r, _drawmouse.xy);
r = rectaddpt(r, Pt(-Dx(mousebuttons->r)/2, -Dy(mousebuttons->r)-3));
drawop(mousesave, mousesave->r, screen, nil, r.min, S);
-
+
r1 = rectaddpt(Rect(0, 0, 22, 22), r.min);
if(_drawmouse.buttons & 1)
drawop(screen, r1, mousebuttons, nil, ZP, S);
drawop(screen, r, mousesave, nil, ZP, S);
return ret;
}
-
+
if(visible){
*d->bufp++ = 'v'; /* five bytes always reserved for this */
if(d->_isnewdisplay){
blob - 206044e7fb48e6bed8e586f630257be54e9bbd71
blob + 58654868a39af6da6cae2d51c350b06f726644c9
--- src/libdraw/iprint.c
+++ src/libdraw/iprint.c
int
iprint(char *fmt, ...)
-{
+{
va_list arg;
va_start(arg, fmt);
blob - 755ffbd327361a61847c9dbeb9f40b5c856af88b
blob + ef7b5802215f0f6d8f58772ae546aabeab02d146
--- src/libdraw/keyboard.c
+++ src/libdraw/keyboard.c
{
Rune r;
Keyboardctl *kc;
-
+
kc = arg;
threadsetname("kbdproc");
for(;;){
proccreate(_ioproc, kc, 32*1024);
return kc;
}
-
blob - fc486be4367e1da2a069e1b3376eadc74438f331
blob + 64a7f73dae90f1582687b523ca8b70277ff568b3
--- src/libdraw/mouse.c
+++ src/libdraw/mouse.c
{
_displaycursor(mc->display, c, c2);
}
-
blob - 88784adf50aff453b0b380e8b9375fd44fc98846
blob + e77b54dbfa757d19ec4402d2aa0ede9c339a8a41
--- src/libdraw/newwindow.c
+++ src/libdraw/newwindow.c
strcpy(buf, "new");
return mount(fd, -1, "/dev", MBEFORE, buf);
}
-
blob - 366664ae9c53c2efc8d78b7e3a36747aaba1f1ed
blob + 9312eb437f801f3057af39072757655d60258eaa
--- src/libdraw/openfont.c
+++ src/libdraw/openfont.c
{
char *p;
int scale;
-
+
p = name;
scale = 0;
while('0' <= *p && *p <= '9') {
scale = 1;
}
return scale;
-}
+}
extern char _defontfile[];
if(targ != *oldp)
sysfatal("bad swapfont %p %p %p", targ, *oldp, *newp);
-
+
old = *oldp;
new = *newp;
{
char *p, *q;
int size;
-
+
// If font name has form x,y return y.
p = strchr(f->namespec, ',');
if(p != nil)
return strdup(p+1);
-
+
// If font name is /mnt/font/Name/Size/font, scale Size.
if(strncmp(f->name, "/mnt/font/", 10) == 0) {
p = strchr(f->name+10, '/');
while('0' <= *q && *q <= '9')
size = size*10 + *q++ - '0';
return smprint("%.*s%d%s", utfnlen(f->name, p-f->name), f->name, size*2, q);
- }
+ }
- // Otherwise use pixel doubling.
+ // Otherwise use pixel doubling.
scale:
return smprint("%d*%s", f->scale*2, f->name);
}
swapfont(f, &f->lodpi, &f->hidpi);
return;
}
-
+
name = hidpiname(f);
fnew = openfont1(f->display, name);
if(fnew == nil)
Font *f;
char *p;
char *namespec;
-
+
// If font name has form x,y use x for lodpi, y for hidpi.
name = strdup(name);
namespec = strdup(name);
f->lodpi = f;
free(f->namespec);
f->namespec = namespec;
-
+
/* add to display list for when dpi changes */
/* d can be nil when invoked from mc. */
if(d != nil) {
else
d->firstfont = f;
d->lastfont = f;
-
+
/* if this is a hi-dpi display, find hi-dpi version and swap */
if(d->dpi >= DefaultDPI*3/2)
loadhidpi(f);
}
-
+
free(name);
return f;
char c;
char buf[1024], *argv[10];
int nbuf, pid;
-
+
if(pipe(p) < 0)
return -1;
pid = rfork(RFNOWAIT|RFFDG|RFPROC);
_exit(0);
}
close(p[1]);
-
+
// success marked with leading \001.
// otherwise an error happened.
for(nbuf=0; nbuf<sizeof buf-1; nbuf++) {
blob - e8f7f51b1c44563b1119dc7d343feef8c32ce1fb
blob + b537533d120f5cc08d0f905f54896500cba629f6
--- src/libdraw/rgb.c
+++ src/libdraw/rgb.c
* over the color map looking for the nearest point in RGB
* space. There is no visual psychology reason for that
* criterion, but it's easy to implement and the results are
- * far more pleasing.
+ * far more pleasing.
*
int
rgb2cmap(int cr, int cg, int cb)
blob - ea0aa25c72f9315466207f4fde78645ee8b47989
blob + fa2f3d9f449cc7add972ee5a796444c60533406f
--- src/libdraw/scroll.c
+++ src/libdraw/scroll.c
if(lines)
return lines;
- return pcnt * maxlines/100.0;
+ return pcnt * maxlines/100.0;
}
blob - 392a7e8a7fb3c24cedd503f378569ce6f7ff24ce
blob + 5ba5016a4e87dee7c53a8f6ff282aa3a0f7775af
--- src/libdraw/string.c
+++ src/libdraw/string.c
else
break;
}
- /*
+ /*
* must not free sf until cachechars has found it in the cache
* and picked up its own reference.
*/
blob - 522fbc0115d07609314b5133b5ef1adf11eddbb7
blob + 52d9fd67008047bb4b411c69d8608f533be75a4b
--- src/libdraw/stringwidth.c
+++ src/libdraw/stringwidth.c
else
break;
}
- /*
+ /*
* must not free sf until cachechars has found it in the cache
* and picked up its own reference.
*/
blob - 9630a087fc7c4277877ed2fdbc9cbed7942aac29
blob + 494cd574332c7e7180e597e6a8df7249f2cb1cd9
--- src/libdraw/subfont.c
+++ src/libdraw/subfont.c
f->ref = 1;
if(name){
/*
- * if already caching this subfont, leave older
+ * if already caching this subfont, leave older
* (and hopefully more widely used) copy in cache.
- * this case should not happen -- we got called
+ * this case should not happen -- we got called
* because cachechars needed this subfont and it
* wasn't in the cache.
*/
blob - e6059d0e8fb9552bd768259863433380c121946b
blob + d247cb6166aaba746c22c0371d51f7bacd2890c9
--- src/libdraw/subfontname.c
+++ src/libdraw/subfontname.c
{
char *t, *u, *tmp1, *tmp2, *base;
int i, scale;
-
+
scale = parsefontscale(fname, &base);
t = strdup(cfname); /* t is the return string */
blob - 76bc75d0d618b00e31c3154508f3fd94d9d73de9
blob + be45b75a52950fec9b93e13eb71391ee439e9b26
--- src/libdraw/unix.c
+++ src/libdraw/unix.c
return -1;
return s.st_size;
}
-
blob - d9632503dc848773843c31b8acb6d03ce7f96128
blob + 572bc1d2a48e587ac32eb2abaa05a3cfd9f62c59
--- src/libdraw/wsys.c
+++ src/libdraw/wsys.c
{
_displayresize(display, r);
}
-
blob - e333abd8b65daad8054da55b2f6944d7ffa02527
blob + d7c3f5ea9d24ab8e8db46f196dadd53e47befe6c
--- src/libframe/frdelete.c
+++ src/libframe/frdelete.c
r.max.x += b->wid;
draw(f->b, r, f->b, nil, pt1);
cn1 += b->nrune;
-
+
/* blank remainder of line */
r.min.x = r.max.x;
r.max.x += w0 - b->wid;
blob - 05a45fe2c6ea10893f0cbe608d5f3028d372c55c
blob + 9573b1c8b3268257ccf16ec01fe4e2ac824789f8
--- src/libframe/frdraw.c
+++ src/libframe/frdraw.c
Point qt;
uint p;
char *ptr;
-
+
if(p0 > p1)
sysfatal("libframe: frdrawsel0 p0=%lud > p1=%lud", p0, p1);
blob - 1f920f5a8cd4768fe9352b710aaa00087721e021
blob + 0da221450f52c530d9e8779486c3e93bdb167119
--- src/libgeometry/quaternion.c
+++ src/libgeometry/quaternion.c
* qunit(q) returns a unit quaternion parallel to q
* The following only work on unit quaternions and rotation matrices:
* slerp(q, r, a) returns q*(r*q^-1)^a
- * qmid(q, r) slerp(q, r, .5)
+ * qmid(q, r) slerp(q, r, .5)
* qsqrt(q) qmid(q, (Quaternion){1,0,0,0})
* qtom(m, q) converts a unit quaternion q into a rotation matrix m
* mtoq(m) returns a quaternion equivalent to a rotation matrix m
*/
Quaternion qu;
double tr, s;
-
+
tr = mat[0][0] + mat[1][1] + mat[2][2];
if (tr >= 0.0) {
s = sqrt(tr + mat[3][3]);
blob - bc41c4acfdf0fcfe3af7dd968e9dfd95fcde31d9
blob + a6cea994711b92593faa12f12f739a9f4b507fc1
--- src/libgeometry/tstack.c
+++ src/libgeometry/tstack.c
/*% cc -gpc %
* These transformation routines maintain stacks of transformations
- * and their inverses.
+ * and their inverses.
* t=pushmat(t) push matrix stack
* t=popmat(t) pop matrix stack
* rot(t, a, axis) multiply stack top by rotation
blob - 78b6efff46a62a164ccfd8eb4a5b32efc13d4242
blob + b2387006f534e8ab4547d42513b0c9e17b7367a8
--- src/libhtml/build.c
+++ src/libhtml/build.c
tab = newtable(++is->ntables,
aalign(tok),
adimen(tok, Awidth),
- aflagval(tok, Aborder),
+ aflagval(tok, Aborder),
auintval(tok, Acellspacing, TABSP),
auintval(tok, Acellpadding, TABPAD),
makebackground(nil, acolorval(tok, Abgcolor, ps->curbg.color)),
flags |= TFisth;
c = newtablecell(curtab->cells==nil? 1 : curtab->cells->cellid+1,
auintval(tok, Arowspan, 1),
- auintval(tok, Acolspan, 1),
- aalign(tok),
+ auintval(tok, Acolspan, 1),
+ aalign(tok),
adimen(tok, Awidth),
auintval(tok, Aheight, 0),
makebackground(nil, acolorval(tok, Abgcolor, tr->background.color)),
/* only when parsing is done is t->nrow set > 0 */
if(ok && t->nrow > 0 && t->ncol > 0) {
/* table is "finished" */
- for(i = 0; i < t->nrow && ok; i++)
+ for(i = 0; i < t->nrow && ok; i++)
ok = validtablerow(t->rows+i);
for(j = 0; j < t->ncol && ok; j++)
ok = validtablecol(t->cols+j);
blob - 258807dd09cac49e2ea1bfe058e15c0e373834f4
blob + 49c5f502eb718e559b90b0266774ff127ac1ea35
--- src/libhtml/lex.c
+++ src/libhtml/lex.c
char *_tagnames[] = {
" ",
"!",
- "a",
+ "a",
"abbr",
"acronym",
"address",
- "applet",
+ "applet",
"area",
"b",
"base",
buf[j] = 0;
if(s == nil)
tmp = _Strndup(buf, j);
- else
+ else
tmp = _Strdup2(s, buf);
free(s);
return tmp;
blob - c2419457c18090fdae4860691b522691087bfb91
blob + 3602d8751d6c48f2e86d973ade2272e466fa1d91
--- src/libhttpd/redirected.c
+++ src/libhttpd/redirected.c
*s = '/';
}
- n = snprint(c->xferbuf, HBufSize,
+ n = snprint(c->xferbuf, HBufSize,
"<head><title>Redirection</title></head>\r\n"
"<body><h1>Redirection</h1>\r\n"
"Your selection can be found <a href=\"%U\"> here</a>.<p></body>\r\n", uri);
blob - 9bf2db0c22d2b7b1f996df09b031335b90f60379
blob + 573061634cc8fc4f7473f1e4c164cfce2e58407e
--- src/libip/BSD.c
+++ src/libip/BSD.c
sockaddr2ip(uchar *ip, struct sockaddr *sa)
{
struct sockaddr_in *sin;
-
+
sin = (struct sockaddr_in*)sa;
memmove(ip, v4prefix, IPaddrlen);
memmove(ip+IPv4off, &sin->sin_addr, 4);
mib[3] = 0;
mib[4] = NET_RT_IFLIST;
mib[5] = 0;
-
+
n = 0;
if(sysctl(mib, 6, nil, &n, nil, 0) < 0)
return nil;
continue;
*lastlifc = lifc;
lastlifc = &lifc->next;
- }
+ }
sockaddr2ip(ip, sa);
switch(i){
case RTAX_IFA:
blob - edc67e897b53dddf81565f3fe51a082a4dc67ec3
blob + 3a1411b9d76763bc0b1ba11a53a889917dd671b9
--- src/libip/Linux.c
+++ src/libip/Linux.c
* Thanks to Erik Quanstrom.
*/
static int
-netlinkrequest(int fd, int type, int (*fn)(struct nlmsghdr *h, Ipifc**, int),
+netlinkrequest(int fd, int type, int (*fn)(struct nlmsghdr *h, Ipifc**, int),
Ipifc **ifc, int index)
{
char buf[1024];
/* we couldn't care less which one; just want to talk to the kernel! */
static int dumb[3] = { AF_INET, AF_PACKET, AF_INET6 };
int i, fd;
-
+
for(i=0; i<nelem(dumb); i++)
if((fd = socket(dumb[i], SOCK_DGRAM, 0)) >= 0)
return fd;
{
struct rtattr *src;
int len;
-
+
len = h->nlmsg_len - NLMSG_LENGTH(skip);
if(len < 0 || h->nlmsg_type != type){
werrstr("attrs too short");
rta2ip(int af, uchar *ip, struct rtattr *rta)
{
memset(ip, 0, IPaddrlen);
-
+
switch(af){
case AF_INET:
memmove(ip, v4prefix, IPv4off);
struct rtattr *attr[IFLA_MAX+1];
struct ifinfomsg *ifi;
Ipifc *ifc;
-
+
ifi = (struct ifinfomsg*)NLMSG_DATA(h);
if(index >= 0 && ifi->ifi_index != index)
return 0;
if(ioctl(fd, SIOCGIFHWADDR, &ifr) >= 0
&& ifr.ifr_hwaddr.sa_family == ARPHRD_ETHER)
memmove(ifc->ether, ifr.ifr_hwaddr.sa_data, 6);
-
+
close(fd);
}
return 0;
Iplifc *lifc, **l;
struct ifaddrmsg *ifa;
struct rtattr *attr[IFA_MAX+1];
-
+
USED(index);
ifa = (struct ifaddrmsg*)NLMSG_DATA(h);
return 0;
if(parsertattr(attr, nelem(attr), h, RTM_NEWADDR, sizeof(struct ifaddrmsg)) < 0)
return -1;
-
+
lifc = mallocz(sizeof *lifc, 1);
if(lifc == nil)
return -1;
return 0;
rta2ip(ifa->ifa_family, lifc->ip, attr[IFA_ADDRESS]);
-
+
mask = ifa->ifa_prefixlen/8;
if(ifa->ifa_family == AF_INET)
mask += IPv4off;
memset(lifc->mask, 0xFF, mask);
memmove(lifc->net, lifc->ip, mask);
-
+
if(attr[IFA_CACHEINFO]){
struct ifa_cacheinfo *ci;
USED(net);
freeipifc(ifc);
ifc = nil;
-
+
fd = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
if(fd < 0)
return nil;
close(fd);
return ifc;
}
-
blob - 7899facc041988bc5a0bb5e2eb4a3d1d604948b1
blob + 1b3bf0210e4e2f5c22e5851f35cec9fd3f41d7ed
--- src/libip/freeipifc.c
+++ src/libip/freeipifc.c
free(i);
}
}
-
blob - a6b12def48c7783a6e75fd8be9a7604b503a891e
blob + 3849bfe80ec936e5440270dd11ae2dadeb365d3f
--- src/libip/myetheraddr.c
+++ src/libip/myetheraddr.c
myetheraddr(uchar *to, char *dev)
{
Ipifc *ifclist, *ifc;
-
+
ifclist = readipifc(nil, nil, -1);
for(ifc=ifclist; ifc; ifc=ifc->next){
if(dev && strcmp(ifc->dev, dev) != 0)
werrstr("no ethernet devices");
return -1;
}
-
blob - bbde18f78ed6e4818163ac4d1847a5fa36182d42
blob + 24faf9ffdbadd1147a13050c6e0be40eedb8fc17
--- src/libip/myipaddr.c
+++ src/libip/myipaddr.c
freeipifc(ifc);
return -1;
}
-
blob - 80110a64a15cc242c4b8665924be6f6b1ccfe462
blob + caf5cf8f627267b6507af290244e2b1ccf53c572
--- src/libip/none.c
+++ src/libip/none.c
USED(net);
USED(ipifc);
USED(index);
-
+
werrstr("not implemented");
return nil;
}
blob - c0dd55ccdc549f37abffb024b7926360873dbbe7
blob + dba614ce31b2303a6417131ce645733a42ba013e
--- src/libip/parseip.c
+++ src/libip/parseip.c
*a++ = 0xff;
if(i > 0)
*a = ~((1<<(8-i))-1);
- } else
+ } else
memcpy(mask, defmask(addr), IPv4addrlen);
return p;
}
blob - ae413a248932ed6714c17b6b090c344ca360aff8
blob + 07f6403dad76a4525771fa0fbff94e55d57e2d76
--- src/libip/udp.c
+++ src/libip/udp.c
memmove(&sin.sin_port, hdr->rport, 2);
return sendto(fd, buf, n, 0, (struct sockaddr*)&sin, sizeof sin);
}
-
blob - 92ffdb925df0f73e28dde9e8bd735bb191b177e3
blob + 33bd8e9c6a1d3fbf2ce53e1a14ffddf2240c79e8
--- src/libmach/DragonFly.c
+++ src/libmach/DragonFly.c
for(i=0; i<map->nseg; i++)
while(i<map->nseg && map->seg[i].pid){
map->nseg--;
- memmove(&map->seg[i], &map->seg[i+1],
+ memmove(&map->seg[i], &map->seg[i+1],
(map->nseg-i)*sizeof(map->seg[0]));
}
}
blob - 7cf5c1f44869ca0a8bce621fb746776393d2b64d
blob + 80c8935a30cde2dae1c5b7c2fa0a994d84c8869d
--- src/libmach/FreeBSD.c
+++ src/libmach/FreeBSD.c
for(i=0; i<map->nseg; i++)
while(i<map->nseg && map->seg[i].pid){
map->nseg--;
- memmove(&map->seg[i], &map->seg[i+1],
+ memmove(&map->seg[i], &map->seg[i+1],
(map->nseg-i)*sizeof(map->seg[0]));
}
}
blob - 005d6b38824e83a8523b9efc51b968994e58e56b
blob + 30b40bbf88ec4860757a5318c38d93cb853cb1db
--- src/libmach/Linux.c
+++ src/libmach/Linux.c
/*
* process interface for Linux.
- *
+ *
* Uses ptrace for registers and data,
* /proc for some process status.
* There's not much point to worrying about
werrstr("ptrace attach %d: %r", pid);
return -1;
}
-
+
if(ctlproc(pid, "waitstop") < 0){
fprint(2, "waitstop: %r");
ptrace(PTRACE_DETACH, pid, 0, 0);
for(i=0; i<map->nseg; i++)
while(i<map->nseg && map->seg[i].pid){
map->nseg--;
- memmove(&map->seg[i], &map->seg[i+1],
+ memmove(&map->seg[i], &map->seg[i+1],
(map->nseg-i)*sizeof(map->seg[0]));
}
}
return *p == 'T';
}
-/* /proc/pid/stat contains
+/* /proc/pid/stat contains
pid
command in parens
0. state
return pbuf;
return nil;
}
-
blob - 36d0fb930cc6b353d574c8dda1e734fba1c365ca
blob + 18643e10ecc965f3f24f3cb3edf218d61be0c22f
--- src/libmach/cmdline.c
+++ src/libmach/cmdline.c
mapfile(symhdr, 0, cormap, nil);
}
- if(corpid)
+ if(corpid)
attachproc(corpid);
if(corhdr)
attachcore(corhdr);
elfdl386mapdl(verbose);
return 0;
}
-
blob - 5695b7eb8fc9dab4e5b2d39066b78972917b4c87
blob + a2106f050d0f8e2b44661d632992f33a54507a96
--- src/libmach/crack.c
+++ src/libmach/crack.c
extern Mach mach386;
extern Mach machpower;
-static Mach *machs[] =
+static Mach *machs[] =
{
&mach386,
&machpower,
for(i=0; i<map->nseg; i++){
while(i<map->nseg && map->seg[i].fd == fp->fd){
map->nseg--;
- memmove(&map->seg[i], &map->seg[i+1],
+ memmove(&map->seg[i], &map->seg[i+1],
(map->nseg-i)*sizeof(map->seg[0]));
}
}
werrstr("thread not found");
return nil;
}
-
blob - 22f4307e50275c72d471164dbe4ccded23529726
blob + 1b051eec2aae596b6a48b514c0956a4cb6431ad9
--- src/libmach/crackelf.c
+++ src/libmach/crackelf.c
uint mtype;
Mach *mach;
char *name;
-} mtab[] =
+} mtab[] =
{ /* Font Tab 4 */
ElfMachSparc, MSPARC, nil, "sparc",
ElfMach386, M386, &mach386, "386",
uint etype;
uint atype;
char *aname;
-} atab[] =
+} atab[] =
{ /* Font Tab 4 */
ElfAbiSystemV, ALINUX, "linux", /* [sic] */
ElfAbiLinux, ALINUX, "linux",
uint mtype;
uint atype;
void (*elfcore)(Fhdr*, Elf*, ElfNote*);
-} ctab[] =
+} ctab[] =
{ /* Font Tab 4 */
M386, ALINUX, elfcorelinux386,
M386, ANONE, elfcorelinux386, /* [sic] */
if(addseg(map, s) < 0)
return -1;
}
- }
+ }
}
if(fp->nthread && regs)
*regs = coreregs(fp, fp->thread[0].id);
- return 0;
+ return 0;
}
static int
*pa = a;
return 0;
}
-
blob - 77b0339bb970870979487038b5f79f151515757c
blob + 25d1aa7ab043b9eb8a7bc7c13885f506fdf316b5
--- src/libmach/crackmacho.c
+++ src/libmach/crackmacho.c
Mach *mach;
char *name;
int (*coreregs)(Macho*, uchar**);
-} mtab[] =
+} mtab[] =
{
MachoCpuPower, MPOWER, &machpower, "powerpc", coreregsmachopower,
};
if((r = mallocz(sizeof *r, 1)) == nil)
return -1;
r->r.rw = _uregrw;
- r->ureg = u;
+ r->ureg = u;
*rp = &r->r;
}
noregs:
blob - a2a9b9636ee59ea7d32ea85e9c4747d332cc10f4
blob + c6bb8756b65db4ca354f5e502a1881aee94e3cde
--- src/libmach/demangler.c
+++ src/libmach/demangler.c
Biobuf b, bout;
char *p, *s;
char buf[100000];
-
+
Binit(&b, 0, OREAD);
Binit(&bout, 1, OWRITE);
-
+
while((p = Brdline(&b, '\n')) != nil){
p[Blinelen(&b)-1] = 0;
werrstr("no error");
blob - bd0fe56d905642aaaef296a9604ca5be3a764a95
blob + 31e13900c795bc6f10508b71229fae5ae6072f44
--- src/libmach/dwarf.h
+++ src/libmach/dwarf.h
extern int dwarf386nregs;
extern char *dwarf386regs[];
extern char *dwarf386fp;
-
blob - 3cefeea2f8d1258016466fcf953d50957bcacffa
blob + cd13194c263704dc1f732572822e00a72c2f6467
--- src/libmach/dwarf386.c
+++ src/libmach/dwarf386.c
#include "dwarf.h"
char*
-dwarf386regs[] =
+dwarf386regs[] =
{
"AX",
"CX",
};
int dwarf386nregs = nelem(dwarf386regs);
-
-
blob - 503d51492ae6dc694bdd624d9b35c8797978a267
blob + 24418ef304fdcb9d1faa9c69be02d8fbaa8dbcbb
--- src/libmach/dwarfabbrev.c
+++ src/libmach/dwarfabbrev.c
* Dwarf abbreviation parsing code.
*
* The convention here is that calling dwarfgetabbrevs relinquishes
- * access to any abbrevs returned previously. Will have to add
+ * access to any abbrevs returned previously. Will have to add
* explicit reference counting if this turns out not to be acceptable.
*/
}
return findabbrev(a, na, num);
}
-
blob - 212995881c2e6a6ce4bb31d54080c079ca0b7283
blob + 7e7152d331c80eaffb808850096194ca8c51a696
--- src/libmach/dwarfaranges.c
+++ src/libmach/dwarfaranges.c
werrstr("address 0x%lux is not listed in dwarf debugging symbols", addr);
return -1;
}
-
blob - 4980c2cf0d78f54694d45975bafa45e961420848
blob + ee303009710024cf5dd7f854bffd640e60bd4f81
--- src/libmach/dwarfcfa.c
+++ src/libmach/dwarfcfa.c
/*
* Dwarf call frame unwinding.
*
- * The call frame unwinding values are encoded using a state machine
- * like the pc<->line mapping, but it's a different machine.
- * The expressions to generate the old values are similar in function to the
+ * The call frame unwinding values are encoded using a state machine
+ * like the pc<->line mapping, but it's a different machine.
+ * The expressions to generate the old values are similar in function to the
* ``dwarf expressions'' used for locations in the code, but of course not
- * the same encoding.
+ * the same encoding.
*/
#include <u.h>
#include <libc.h>
/*
* XXX This turns out to be much more expensive than the actual
* running of the machine in dexec. It probably makes sense to
- * cache the last 10 or so fde's we've found, since stack traces
+ * cache the last 10 or so fde's we've found, since stack traces
* will keep asking for the same info over and over.
*/
static int
}
werrstr("cannot find call frame information for pc 0x%lux", pc);
return -1;
-
+
}
static int
if(locstop)
return 0;
continue;
-
+
case 2: /* offset rule */
arg1 = c&0x3F;
arg2 = dwarfget128(b);
s->cfa->offset = arg2;
continue;
- case 0x0D: /* def cfa register */
+ case 0x0D: /* def cfa register */
arg1 = dwarfget128(b);
if(trace) fprint(2, "cfa reg r%ld\n", arg1);
if(s->cfa->type != RuleRegOff){
werrstr("change CFA register but CFA not in register+offset form");
- return -1;
+ return -1;
}
if(checkreg(s, arg1) < 0)
return -1;
return -1;
}
}
- /* not reached */
+ /* not reached */
}
-
blob - 30c227b3f52e2786443e6eb583a68d601b5b3639
blob + 30e68c2d0c5f0d80adfbac5f6646ecc972af64e0
--- src/libmach/dwarfeval.c
+++ src/libmach/dwarfeval.c
OpCall4 = 0x99, /* 4-byte offset of DIE */
OpCallRef = 0x9A, /* 4- or 8- byte offset of DIE */
/* 0xE0-0xFF reserved for user-specific */
-
blob - 3e9fe650659f1f1d39140538afb1adf066aa84e4
blob + fd3ec817273759a0b3568f13368cb92ab509dc1c
--- src/libmach/dwarfget.c
+++ src/libmach/dwarfget.c
}
return v;
}
-
blob - 4c0eacd8bc2d4ff971de02cc1d223a57517f706d
blob + d6c2b79edae0b44677778a4fb7f3b0299c208ea9
--- src/libmach/dwarfinfo.c
+++ src/libmach/dwarfinfo.c
werrstr("symbol '%s' not found", name);
return -1;
}
-
+
int
dwarflookupsubname(Dwarf *d, DwarfSym *parent, char *name, DwarfSym *s)
{
continue;
if(s->attrs.lowpc <= pc && pc < s->attrs.highpc)
return 0;
- }
+ }
werrstr("fn containing pc 0x%lux not found", pc);
return -1;
}
}
/*
- * The funny game with t and s make sure that
+ * The funny game with t and s make sure that
* if we get to the end of a run of a particular
* depth, we leave s so that a call to nextsymat with depth-1
* will actually produce the desired guy. We could change
- * the interface to dwarfnextsym instead, but I'm scared
+ * the interface to dwarfnextsym instead, but I'm scared
* to touch it.
*/
t = *s;
blob - 728944f42a94e33c9f364817c1c28393ea87046e
blob + 27e965a36d178c4bab9b438618054ba35492039a
--- src/libmach/dwarfopen.c
+++ src/libmach/dwarfopen.c
*len = s->size;
return s - elf->sect;
}
-
+
static int
loadsection(Elf *elf, char *name, DwarfBlock *b)
{
blob - 31b6bb41c9dfcb30a4e0fa57736772594da46d51
blob + 628b3eb818ba02ca3ce1a3d8f6af4439b5a466ff
--- src/libmach/dwarfpc.c
+++ src/libmach/dwarfpc.c
/*
* Dwarf pc to source line conversion.
- *
+ *
* Maybe should do the reverse here, but what should the interface look like?
* One possibility is to use the Plan 9 line2addr interface:
*
blob - 5b7494d98c40b53aa98c04053d6fbf4a83975802
blob + b3cb9e8c1956579a7e6174beed7607fade13ac8a
--- src/libmach/elf.c
+++ src/libmach/elf.c
h->e2 = e2;
h->e4 = e4;
h->e8 = e8;
-
+
if(h->class == ElfClass64)
goto b64;
if(h->class == ElfClass32) {
ElfProgBytes *b;
-
+
b = v;
e4 = h->e4;
p->type = e4(b->type);
p->align = e4(b->align);
} else {
ElfProgBytes64 *b;
-
+
b = v;
e4 = h->e4;
e8 = h->e8;
if(h->class == ElfClass32) {
ElfSectBytes *b;
-
+
b = v;
e4 = h->e4;
s->name = (char*)(uintptr)e4(b->name);
s->entsize = e4(b->entsize);
} else {
ElfSectBytes64 *b;
-
+
b = v;
e4 = h->e4;
e8 = h->e8;
werrstr("symbol index out of range");
return -1;
}
-
blob - 0d01d969d6759d2abc75ebfa6120807a1a943d42
blob + bd146784f794cb1221fba0dc4a33e061eb8aaee6
--- src/libmach/elfcorefreebsd386.c
+++ src/libmach/elfcorefreebsd386.c
*pp = t;
return 0;
}
-
blob - fde6514f507c778efa5108a0b8ac22e0642df450
blob + a5fc6ed7993bd4b06107b4a20d15d7d6de219522
--- src/libmach/elfcorefreebsdamd64.c
+++ src/libmach/elfcorefreebsdamd64.c
}
l = &s->reg;
u = malloc(sizeof(Ureg));
-
+
/* no byte order problems - just copying and rearranging */
u->ax = l->rax;
u->bx = l->rbx;
u->r13 = l->r13;
u->r14 = l->r14;
u->r15 = l->r15;
-
+
u->ds = l->ds;
u->es = l->es;
u->fs = l->fs;
u->gs = l->gs;
-
+
u->type = l->trapno;
u->error = l->err;
u->ip = l->rip;
*pp = t;
return 0;
}
-
blob - 6cd0a5f99a9d08f160ae103c0d3f53cad7bcb755
blob + d32932882e2ad07eaa8dd729f9f51f9e10d315cb
--- src/libmach/elfcorelinux386.c
+++ src/libmach/elfcorelinux386.c
typedef struct Psinfo Psinfo;
/*
- * UregLinux386 is 64-bit aligned within status, so we shouldn't
- * have any packing problems.
+ * UregLinux386 is 64-bit aligned within status, so we shouldn't
+ * have any packing problems.
*/
struct Status
{
(uint)m->swap4(st->sighold));
dprint("pid=%ud ppid=%ud pgrp=%ud sid=%ud\n",
(uint)m->swap4(st->pid),
- (uint)m->swap4(st->ppid),
+ (uint)m->swap4(st->ppid),
(uint)m->swap4(st->pgrp),
(uint)m->swap4(st->sid));
dprint("utime=%ud.%06ud stime=%ud.%06ud cutime=%ud.%06ud cstime=%ud.%06ud\n",
dprint("note %d\n", note->type);
}
}
-
blob - fc4e37fbc3c004cb45c2f70eab54a44cb7bcffce
blob + a67ed13cfe8018d464771e3813bb9c67b2f3b70f
--- src/libmach/elfdl386.c
+++ src/libmach/elfdl386.c
fprint(2, "syminit %s: %r\n", buf);
}
}
-
blob - 06bb41a63fb6cf85b97c58b0961068574d028d68
blob + 0f3a974c03edc74ab1e09b45645bf500e17fa56e
--- src/libmach/elfdynsym.c
+++ src/libmach/elfdynsym.c
#include "elf.h"
int
-elfsym(Elf *elf, ElfSect *symtab, ElfSect *strtab, int ndx, ElfSym *
\ No newline at end of file
+elfsym(Elf *elf, ElfSect *symtab, ElfSect *strtab, int ndx, ElfSym *
blob - a94a096a95bccd29de1f9a79496fa3696ccd9466
blob + c76cca3ee7c2465cb89598cd84db2841d5d51723
--- src/libmach/fpformat.c
+++ src/libmach/fpformat.c
if (rp->format == 'F')
return 1;
return 2;
- }
+ }
/* treat it like 'f' */
if (get1(map, rp->offset, (uchar *)reg, 4) < 0)
return -1;
blob - 2b7f8b3041f2f63e7b6692c83921bdd9c384655d
blob + 53450805afbf400d0111a0aca232850440703cfe
--- src/libmach/frame.c
+++ src/libmach/frame.c
next = malloc(mach->nwindreg*sizeof(cur[0]));
if(cur==nil || next==nil)
goto out;
-
+
/*
* Initialize current registers using regs.
*/
if(rget(regs, mach->pc, &pc) < 0){
werrstr("cannot fetch initial pc: %r");
- goto out;
+ goto out;
}
for(i=0; i<mach->nwindreg; i++){
blob - b095e8ffd9269785f5443cb2d51977096e9a3d6f
blob + cf8537ef63a8b093daa01aea64f15533a144887f
--- src/libmach/hexify.c
+++ src/libmach/hexify.c
*buf++ = "0123456789abcdef"[p&0x0f];
return buf;
}
-
blob - 9d5dc85788ce0d766e019046431f226f334272d6
blob + 00ce2e6804bdf8069171def9b8142eb41d8f6759
--- src/libmach/loc.c
+++ src/libmach/loc.c
*newloc = loc;
return 0;
}
-
blob - 336cec352d6d41b22eeea233441e7308cad81467
blob + 109256304b45494b66092a7b4169cbd2bac483f6
--- src/libmach/mach386.c
+++ src/libmach/mach386.c
};
/*
- * The wrapper code around Linux system calls
+ * The wrapper code around Linux system calls
* saves AX on the stack before calling some calls
- * (at least, __libc_nanosleep), when running in
- * threaded programs.
+ * (at least, __libc_nanosleep), when running in
+ * threaded programs.
*/
static void
syscallhack(Map *map, Regs *regs, int *spoff)
return;
if(i386das(map, pc+2, 0, buf, sizeof buf) != 3 || strcmp(buf, "XCHGL\tAX,0(SP)") != 0)
return;
- *spoff += 4;
+ *spoff += 4;
}
int
Symbol s;
char *name;
Loc l, li;
-
+
l.type = LOFFSET;
l.offset = ip->disp;
if(ip->base == SP)
l.reg = "SP";
else
l.reg = "BP";
-
+
li.type = LADDR;
li.addr = ip->addr;
if(findsym(li, CTEXT, &s) < 0)
if(name==nil && findlsym(&s, l, &s) >= 0)
name = s.name;
-
+
if(name)
bprint(ip, "%s+", name);
blob - f220ebcf767899e7d5cb6700390c124a1ae214cd
blob + d10257c83796e7cb74d2ba5076e78141b4c2f2bf
--- src/libmach/machamd64.c
+++ src/libmach/machamd64.c
4, /* szreg */
4, /* szfloat */
8, /* szdouble */
-
+
amd64windregs, /* locations unwound in stack trace */
17,
-
+
{0xCC, 0, 0, 0}, /* break point: INT 3 */
1, /* break point size */
blob - 38cb23745ac3a0e5adb51321cf1ce31ef265aef0
blob + ce74bcbbbd382d7e1478c1f1d98b974483575682
--- src/libmach/macho.c
+++ src/libmach/macho.c
#include "macho.h"
/*
-http://www.channelu.com/NeXT/NeXTStep/3.3/nd/DevTools/14_MachO/MachO.htmld/
+http://www.channelu.com/NeXT/NeXTStep/3.3/nd/DevTools/14_MachO/MachO.htmld/
*/
Macho*
uchar *buf, *p;
int i, n;
uint32 v;
-
+
if(sect->rel != nil || sect->nreloc == 0)
return 0;
rel = mallocz(sect->nreloc * sizeof r[0], 1);
r = &rel[i];
p = buf+i*8;
r->addr = m->e4(p);
-
+
// TODO(rsc): Wrong interpretation for big-endian bitfields?
v = m->e4(p+4);
r->symnum = v & 0xFFFFFF;
return 0;
}
-int
+int
macholoadsym(Macho *m, MachoSymtab *symtab)
{
char *strbuf;
free(strbuf);
return -1;
}
-
+
symsize = 12;
if(m->is64)
symsize = 16;
blob - 2b449f04cdbbaefedecc6e31969c00f143e5f2b7
blob + 3537c0fccf5abfaa28d5f17733d868b6a34047d8
--- src/libmach/macho.h
+++ src/libmach/macho.h
uint32 reloff;
uint32 nreloc;
uint32 flags;
-
+
MachoRel *rel;
};
uint32 nsym;
uint32 stroff;
uint32 strsize;
-
+
char *str;
MachoSym *sym;
};
blob - 9cd06afbac01e22260fdede8570accef567697c0
blob + 89fc564f767008e53e334d07920927f4b5eb5165
--- src/libmach/machocorepower.c
+++ src/libmach/machocorepower.c
*up = (uchar*)u;
return sizeof(*u);
}
-
blob - 2799f37aed5f7f83882f8ae51ba682e3315af5b5
blob + dd26e45a72eeb1a4ebcb4bd16e1d98fd8780b70f
--- src/libmach/machpower.c
+++ src/libmach/machpower.c
{26, "SRR0"},
{27, "SRR1"},
{284, "TBLW"},
- {285, "TBUW"},
+ {285, "TBUW"},
{22, "DEC"},
{282, "EAR"},
{1008, "HID0"},
if(!i.aa)
foll[0] += pc;
break;
-
+
case 16: /* conditional branch */
foll[0] = i.bd;
if(!i.aa)
#define FP_REG(x) (R31+4+8*(x))
#define REGSIZE sizeof(struct Ureg)
-#define FPREGSIZE (8*33)
+#define FPREGSIZE (8*33)
Regdesc powerreglist[] =
{
{ 0 }
};
-static char *powerwindregs[] =
+static char *powerwindregs[] =
{
"PC",
"SP",
powerhexinst, /* print instruction */
powerinstlen, /* instruction size calculation */
};
-
blob - 852a29ea69044ac08dc02220393cb35dce92f1fe
blob + 5bf49c9d4287afa97b4d0aa0dabb95dff08a61a8
--- src/libmach/mangle.c
+++ src/libmach/mangle.c
#include <bio.h>
#include <mach.h>
-static char *(*demanglers[])(char*, char*) =
+static char *(*demanglers[])(char*, char*) =
{
demanglegcc2,
demanglegcc3,
};
-
+
char*
demangle(char *s, char *buf, int strip)
{
char *t;
char *r, *w;
int i, nangle, nparen;
-
+
t = nil;
for(i=0; i<nelem(demanglers); i++){
t = demanglers[i](s, buf);
blob - 9dae425b6bf2dd97410a11b429ca9e772b51da87
blob + 66231637b3644796720132bc82b50eb782812afb
--- src/libmach/manglegcc2.c
+++ src/libmach/manglegcc2.c
'S', "signed", /* means static for member functions */
'U', "unsigned",
'V', "volatile",
-
+
'G', "garbage", /* no idea what this is */
0, 0
};
{
char *name, *os, *p, *t;
int isfn, namelen;
-
+
/*
* Pick off some cases that seem not to fit the pattern.
*/
isfn = 1;
name = gdestructor;
namelen = strlen(name);
- s += 13;
+ s += 13;
}else if(memcmp(s, "_GLOBAL_.D._", 12) == 0){
isfn = 0;
name = gdestructor;
namelen = strlen(name);
- s += 12;
+ s += 12;
}else if(memcmp(s, "_GLOBAL_.I.__", 13) == 0){
isfn = 1;
name = gconstructor;
namelen = strlen(name);
- s += 13;
+ s += 13;
}else if(memcmp(s, "_GLOBAL_.I._", 12) == 0){
isfn = 0;
name = gconstructor;
namelen = strlen(name);
- s += 12;
+ s += 12;
}else{
t = strstr(os, "__");
if(t == nil)
if(strchr(manglestarts, *(s+2)))
break;
}while((t = strstr(s+1, "__")) != nil);
-
+
name = os;
namelen = s - os;
if(namelen == 0){
}
s += 2;
}
-
+
/*
* Now s points at the mangled crap (maybe).
* and name is the final element of the name.
*/
if(strchr(manglestarts, *s) == nil)
return os;
-
+
p = buf;
if(*s == 'F'){
/* global function, no extra name pieces, just types */
fprint(2, "parsename %s: %r\n", s);
return os;
}
-
+
/* if we have a constructor or destructor, try to use the C++ name */
t = nil;
if(name == constructor || name == destructor){
p -= 2;
memmove(p, name, namelen);
p += namelen;
-
+
if(*s == 'F'){
/* might be from above, or might follow name pieces */
s++;
if(*s == '_'){
/* return type (left over from H) */
- }
-
+ }
+
*p = 0;
return buf;
}
demanglegcc2a(char *s, char *buf)
{
char *p;
-
+
if(*s != '_' || strchr(manglestarts, *(s+1)) == nil)
return nil;
p = buf;
{
char *p;
char *t;
-
+
if(memcmp(s, "__ti", 4) == 0){
t = "$typeinfo";
s += 4;
{
char *s;
int n, eatunderscore;
-
+
s = *ps;
eatunderscore = 0;
if(!many && *s == '_'){
{
int i, n, m, val;
char *os, *s, *t, *p, *p0, *p1;
-
+
s = *ps;
os = s;
p = *pp;
p += strlen(t);
goto out;
}
-
+
/* modifiers */
if((t = chartabsearch(modifiertab, *s)) != nil){
s++;
*/
goto out;
}
-
+
switch(*s){
default:
bad:
if(!gccname(&s, &p))
return 0;
break;
-
+
case 'Q': /* qualified name */
s++;
if(!gccnumber(&s, &n, 0))
}
*p++ = '>';
break;
-
+
case 'T': /* once-repeated type */
s++;
if(!gccnumber(&s, &n, 0))
sprint(p, "T%d", n);
p += strlen(p);
break;
-
+
case 'X': /* type parameter in 'H' */
if(!isdigit((uchar)*(s+1)) || !isdigit((uchar)*(s+2)))
goto bad;
USED(p1);
USED(p0);
-out:
+out:
*ps = s;
*pp = p;
return 1;
}
-
blob - eca26eb1b9af3aee17c5d10acfc2e45294649cac
blob + c0e73758c21bec3099f949a85567de8c34db6068
--- src/libmach/manglegcc3.c
+++ src/libmach/manglegcc3.c
{
char *p, *os;
Gccstate state;
-
+
state.nname = 0;
os = s;
/* mangled names always start with _Z */
if(s[0] != '_' || s[1] != 'Z')
return s;
s += 2;
-
+
p = buf;
if(!gccname(&s, &p, &state)){
if(strchr(os, '@') == nil)
"rs", ">>", "rsh",
"st", "sizeof", "sizeoftype",
"sz", "sizeof", "sizeofexpr",
-
+
0,0,0
};
int i, n;
char *os, *s, *t, *p;
Gccstate nstate;
-
+
s = *ps;
os = s;
p = *pp;
goto suffix;
}
}
-
+
/* basic types */
if((t = chartabsearch(typetab, *s)) != nil){
s++;
p += strlen(t);
goto suffix;
}
-
+
switch(*s){
default:
bad:
p -= 2;
s++;
break;
-
+
case 'P': /* pointer to */
s++;
if(!gccname(&s, &p, state))
s += 2;
break;
}
-
+
/* standard name */
if(*s == 't'){
strcpy(p, "std::");
*p++ = *s++;
}
break;
-
+
case 'T': /* previously-seen type??? T0_ also T_*/
t = s;
for(; *s != '_'; s++){
s++;
memmove(p, t, s-t);
p += s-t;
- break;
+ break;
}
-
+
suffix:
if(*s == 'I'){
/* template suffix */
*pp = p;
return 1;
}
-
blob - 392efbeddcbc8f1068cfd037420458008974723e
blob + db8c15fc095d4ea6fbaf1b144a36a8d3ad6dc65e
--- src/libmach/map.c
+++ src/libmach/map.c
else
nn = pwrite(seg->fd, a, n-tot, off+tot);
if(nn < 0)
- return -1;
+ return -1;
if(nn == 0){
werrstr("partial %s at address 0x%lux in %s",
r ? "read" : "write", off+tot, seg->file);
blob - 07616c1fb1a2a2ff770224ff2df61eb191e0b1ed
blob + cdab6108d5ec76b5eb3d4d7aed9beb430470af31
--- src/libmach/regs.c
+++ src/libmach/regs.c
return 0;
}
}
-
blob - 18805a51943d46a64135f10c7a6e0a7e6b523733
blob + 91950657c32c862bd5e04d8104354fd766be54e8
--- src/libmach/stabs.c
+++ src/libmach/stabs.c
sym->value = stabs->e4(p+8);
return 0;
}
-
blob - ad67cfe648162d58a0b604f11fcb2b3ddfb18c1f
blob + 4743f780da1983910db74df4bc2b7c2ce88b0037
--- src/libmach/stabs.h
+++ src/libmach/stabs.h
*/
int stabsym(Stab*, int, StabSym*);
-
blob - 6369cdd1638160cdceee144a72de3fc747026f59
blob + b165e125a001e1ff19712124df0560b57d7c8718
--- src/libmach/sym.c
+++ src/libmach/sym.c
* We want to find the largest index i such that
* a[i] <= loc. This cannot be done with a simple
* binary search. Instead we binary search to find
- * where the location should be.
+ * where the location should be.
*/
lo = 0;
hi = n;
hdr->byname[i] = &hdr->sym[i];
qsort(hdr->byname, hdr->nsym, sizeof(hdr->byname[0]), bynamecmp);
}
-
+
hdr->byxname = malloc(hdr->nsym*sizeof(hdr->byxname[0]));
if(hdr->byxname == nil){
fprint(2, "could not allocate table to sort by xname\n");
*s = *sym;
return s;
}
-
blob - 4552b0347d687be062bf5f1da4b74aaa338605c6
blob + 49a66dad48c38f68cf2f1dc771b4b999b8e0a452
--- src/libmach/symdwarf.c
+++ src/libmach/symdwarf.c
name, unit, tref);
return 0;
}
-
+
if(ds.attrs.have.bytesize)
return ds.attrs.bytesize;
{
DwarfBuf buf;
DwarfBlock b;
-
+
memset(s, 0, sizeof *s);
s->u.dwarf.uoff = ds->uoff;
s->u.dwarf.unit = ds->unit;
if(rget(regs, regname(d, e.reg), &uu) < 0)
return -1;
if(get4(map, uu+e.offset, &u4) < 0)
- return -1;
+ return -1;
*u = u4;
return 0;
case RuleLocation:
free(e);
return -1;
}
-
blob - 40dec1132e6ce9a5c14c2cc5faedc8b8a2a9a1ca
blob + dd1752eb2699bea065eede1eaf77556063567ef6
--- src/libmach/symelf.c
+++ src/libmach/symelf.c
ret = 0;
return ret;
}
-
blob - 674190ffe4e0c63e596bf6476b17a30182344a6d
blob + 89e87fe7bc0cfa2fe7e2a1883f4066ad4fd34420
--- src/libmach/symmacho.c
+++ src/libmach/symmacho.c
}
return ret;
}
-
blob - e253f023be14fd1487827acc9bee60959b4a9fd0
blob + 9afa4c164f9cd9dadc7e40991606bdf7184474e9
--- src/libmach/symstabs.c
+++ src/libmach/symstabs.c
}
break;
}
- return 0;
+ return 0;
}
static int
if(fun->u.stabs.frameptr == -1){
/*
* Try to distinguish functions with a real frame pointer
- * from functions with a virtual frame pointer, based on
+ * from functions with a virtual frame pointer, based on
* whether the first parameter is in the right location and
- * whether the autos have negative offsets.
- *
+ * whether the autos have negative offsets.
+ *
* This heuristic works most of the time. On the 386, we
* cannot distinguish between a v. function with no autos
* but a frame of size 4 and a f.p. function with no autos and
* no frame. Anything else we'll get right.
- *
+ *
* Another way to go about this would be to have
* mach-specific functions to inspect the function
* prologues when we're not sure. What we have
blob - 37d4b505ccb6bd791cfed83b37c21ee2e141e4ec
blob + 0322dc35deb07d965dd3f4f881cabcba57a4106c
--- src/libmach/t.c
+++ src/libmach/t.c
int first = 0;
ulong pc, sp, bp;
- if(0) print("pc=%lux sp=%lux bp=%lux ",
+ if(0) print("pc=%lux sp=%lux bp=%lux ",
(rget(regs, "PC", &pc), pc),
(rget(regs, "SP", &sp), sp),
(rget(regs, "BP", &bp), bp));
if((e = td_thr_get_info(&ts[i], &info)) != TD_OK)
sysfatal("td_thr_get_info: %s", terr(e));
print("%d: startfunc=%lux stkbase=%lux pc=%lux sp=%lux lid=%d\n",
- i, info.ti_startfunc, info.ti_stkbase, info.ti_pc, info.ti_sp, info.ti_lid);
+ i, info.ti_startfunc, info.ti_stkbase, info.ti_pc, info.ti_sp, info.ti_lid);
if((e = td_thr_getgregs(&ts[i], regs)) != TD_OK)
sysfatal("td_thr_getregs: %s", terr(e));
print("%d: pc=%lux sp=%lux gs=%lux\n", i, regs[12], regs[15], regs[10]);
a.a = nil;
a.n = 0;
a.err = 0;
- if((e = td_ta_thr_iter(ta, thritercb, &a,
+ if((e = td_ta_thr_iter(ta, thritercb, &a,
TD_THR_ANY_STATE,
TD_THR_LOWEST_PRIORITY,
TD_SIGNO_MASK,
return a.n;
}
-/*
+/*
td_err_e td_ta_map_id2thr(const td_thragent_t *ta_p, thread_t tid,td_thrhandle_t *th_p);
*/
blob - b2df1fe7e368211955063cd7ac2f64c0a5a827dd
blob + 06770d2d44a68e46326608935cd16b90b32e691a
--- src/libmach/ureg386.c
+++ src/libmach/ureg386.c
l->esp = u->sp;
l->xss = u->ss;
}
-
blob - 2c92f6feefdfeccbbb2f0eadba4a8dc3f07e4871
blob + ea4d1198ef441f0a7b12fe30f95d4d44d83ad808
--- src/libmemdraw/alloc-stub.c
+++ src/libmemdraw/alloc-stub.c
{
_freememimage(m);
}
-
blob - fa23b5e03cd8a5db59d03610494d0c20423e2d35
blob + af7f6d430e083801723690c550a756deb5142202
--- src/libmemdraw/alloc.c
+++ src/libmemdraw/alloc.c
i->X = X;
i->data = md;
i->zero = sizeof(u32int)*l*r.min.y;
-
+
if(r.min.x >= 0)
i->zero += (r.min.x*d)/8;
else
blob - b3a8c21119b67ad4a227fbe2caa4e497b1ed1350
blob + ad7fc326fd4d68c0df58af5910b945705fa1ba82
--- src/libmemdraw/arctest.c
+++ src/libmemdraw/arctest.c
int
iprint(char *fmt, ...)
{
- int n;
+ int n;
va_list va;
char buf[1024];
write(1,buf,n);
return 1;
}
-
blob - 08e46a1c10dee60bc1f6bb68dcbf392e8f889b43
blob + be411011f536aa4922d07653b7502c4217610b73
--- src/libmemdraw/draw-stub.c
+++ src/libmemdraw/draw-stub.c
memimagedraw(Memimage *dst, Rectangle r, Memimage *src, Point sp, Memimage *mask, Point mp, int op)
{
Memdrawparam *par;
-
+
if((par = _memimagedrawsetup(dst, r, src, sp, mask, mp, op)) == nil)
return;
_memimagedraw(par);
{
return _pixelbits(m, p);
}
-
blob - 4b9885863575f2914df65bb6a3fb93521016f799
blob + 4075023ed4125fe35bdc4cfc4334017c7881b4b7
--- src/libmemdraw/draw.c
+++ src/libmemdraw/draw.c
mktables();
_memmkcmap();
- fmtinstall('R', Rfmt);
+ fmtinstall('R', Rfmt);
fmtinstall('P', Pfmt);
fmtinstall('b', __ifmt);
_memimagedraw(Memdrawparam *par)
{
/*
- * Now that we've clipped the parameters down to be consistent, we
+ * Now that we've clipped the parameters down to be consistent, we
* simply try sub-drawing routines in order until we find one that was able
* to handle us. If the sub-drawing routine returns zero, it means it was
* unable to satisfy the request, so we do not return.
#undef DBG
/*
- * Clip the destination rectangle further based on the properties of the
+ * Clip the destination rectangle further based on the properties of the
* source and mask rectangles. Once the destination rectangle is properly
* clipped, adjust the source and mask rectangles to be the same size.
* Then if source or mask is replicated, move its clipped rectangle
a _ _ X _ _ X _ _ X _ _ X _ _ X _,
a _ _ _ X _ _ _ X _ _ _ X _ _ _ X,
a _ _ _ _ X _ _ _ _ X _ _ _ _ X _,
- a _ _ _ _ _ X _ _ _ _ _ X _ _ _ _,
+ a _ _ _ _ _ X _ _ _ _ _ X _ _ _ _,
a _ _ _ _ _ _ X _ _ _ _ _ _ X _ _,
a _ _ _ _ _ _ _ X _ _ _ _ _ _ _ X,
};
mktables(void)
{
int i, j, mask, sh, small;
-
+
if(tablesbuilt)
return;
/* giant rathole to customize functions with */
struct Param {
Readfn *replcall;
- Readfn *greymaskcall;
+ Readfn *greymaskcall;
Readfn *convreadcall;
Writefn *convwritecall;
static Calcfn* boolcopyfn(Memimage*, Memimage*);
static Readfn* convfn(Memimage*, Param*, Memimage*, Param*);
-static Calcfn *alphacalc[Ncomp] =
+static Calcfn *alphacalc[Ncomp] =
{
alphacalc0, /* Clear */
alphacalc14, /* DoutS */
{
int i;
uchar *p;
-
+
print("%s", s);
for(i=0; i<n; i++){
print(" ");
if(p=b.grey){
print(" k%.2uX", *p);
b.grey += b.delta;
- }else{
+ }else{
if(p=b.red){
print(" r%.2uX", *p);
b.red += b.delta;
* If the destination image is grey and the source is not, it is converted using the NTSC
* formula.
*
- * Once we have all the channels, we call either rgbcalc or greycalc, depending on
+ * Once we have all the channels, we call either rgbcalc or greycalc, depending on
* whether the destination image is color. This is allowed to overwrite the dst buffer (perhaps
* the actual data, perhaps a copy) with its result. It should only overwrite the dst buffer
* with the same format (i.e. red bytes with red bytes, etc.) A new buffer is returned from
ndrawbuf = 0;
src = par->src;
- mask = par->mask;
+ mask = par->mask;
dst = par->dst;
sr = par->sr;
mr = par->mr;
isgrey = dst->flags&Fgrey;
/*
- * Buffering when src and dst are the same bitmap is sufficient but not
+ * Buffering when src and dst are the same bitmap is sufficient but not
* necessary. There are stronger conditions we could use. We could
* check to see if the rectangles intersect, and if simply moving in the
* correct y direction can avoid the need to buffer.
chanmatch(Buffer *bdst, Buffer *bsrc)
{
uchar *drgb, *srgb;
-
+
/*
* first, r, g, b must be in the same place
* in the rgba word.
|| bdst->blu - drgb != bsrc->blu - srgb
|| bdst->grn - drgb != bsrc->grn - srgb)
return 0;
-
+
/*
* that implies alpha is in the same place,
* if it is there at all (it might be == &ones).
*/
if(bdst->alpha == &ones)
return 1;
-
+
/*
* if the destination is not ones but the src is,
* then the simultaneous calculation will use
*/
if(bsrc->alpha == &ones)
return 0;
-
+
/*
* otherwise, alphas are in the same place.
*/
int i, dx, delta;
cmap = p->img->cmap->rgb2cmap;
-
+
delta = src.delta;
red= src.red;
grn = src.grn;
if(r == end)
r = begin;
}
-
+
b.alpha = copyalpha ? buf : &ones;
b.rgba = (u32int*)buf;
if(alphaonly){
b.blu = b.grn = b.grey = b.alpha = nil;
b.rgba = (u32int*)buf;
b.delta = 0;
-
+
return b;
}
case CMap:
p = img->cmap->cmap2rgb+3*ov;
r = *p++;
- g = *p++;
+ g = *p++;
b = *p;
break;
}
}
- return (r<<24)|(g<<16)|(b<<8)|a;
+ return (r<<24)|(g<<16)|(b<<8)|a;
}
u32int
dx -= (ppb-np);
nb = 8 - np * dst->depth; /* no. bits used on right side of word */
lm = (1<<nb)-1;
-DBG print("np %d x %d nb %d lm %ux ppb %d m %ux\n", np, par->r.min.x, nb, lm, ppb, m);
+DBG print("np %d x %d nb %d lm %ux ppb %d m %ux\n", np, par->r.min.x, nb, lm, ppb, m);
/* right edge */
np = par->r.max.x&m; /* no. pixels used on left side of word */
dx -= np;
nb = 8 - np * dst->depth; /* no. bits unused on right side of word */
rm = ~((1<<nb)-1);
-DBG print("np %d x %d nb %d rm %ux ppb %d m %ux\n", np, par->r.max.x, nb, rm, ppb, m);
+DBG print("np %d x %d nb %d rm %ux ppb %d m %ux\n", np, par->r.max.x, nb, rm, ppb, m);
DBG print("dx %d Dx %d\n", dx, Dx(par->r));
/* lm, rm are masks that are 1 where we should touch the bits */
* the source is not replicated, memmove suffices.
*/
m = Simplemask|Fullmask;
- if((par->state&(m|Replsrc))==m && src->depth >= 8
+ if((par->state&(m|Replsrc))==m && src->depth >= 8
&& src->chan == dst->chan && !(src->flags&Falpha) && (op == S || op == SoverD)){
uchar *sp, *dp;
long swid, dwid, nb;
* they're all bit aligned, we can just use bit operators. This happens
* when we're manipulating boolean masks, e.g. in the arc code.
*/
- if((par->state&(Simplemask|Simplesrc|Replmask|Replsrc))==0
- && dst->chan==GREY1 && src->chan==GREY1 && par->mask->chan==GREY1
+ if((par->state&(Simplemask|Simplesrc|Replmask|Replsrc))==0
+ && dst->chan==GREY1 && src->chan==GREY1 && par->mask->chan==GREY1
&& (par->r.min.x&7)==(par->sr.min.x&7) && (par->r.min.x&7)==(par->mr.min.x&7)){
uchar *sp, *dp, *mp;
uchar lm, rm;
}
return 1;
}
- return 0;
+ return 0;
}
#undef DBG
} gcc_black_box;
if(0) if(drawdebug) iprint("chardraw? mf %lux md %d sf %lux dxs %d dys %d dd %d ddat %p sdat %p\n",
- par->mask->flags, par->mask->depth, par->src->flags,
+ par->mask->flags, par->mask->depth, par->src->flags,
Dx(par->src->r), Dy(par->src->r), par->dst->depth, par->dst->data, par->src->data);
mask = par->mask;
* for loop counts from bsh to bsh+dx
*
* we want the bottom bits to be the amount
- * to shift the pixels down, so for n≡0 (mod 8) we want
+ * to shift the pixels down, so for n≡0 (mod 8) we want
* bottom bits 7. for n≡1, 6, etc.
* the bits come from -n-1.
*/
}
}
-DBG print("\n");
- return 1;
+DBG print("\n");
+ return 1;
}
#undef DBG
bpp = src->depth;
uc <<= (src->r.min.x&(7/src->depth))*src->depth;
uc &= ~(0xFF>>bpp);
- * pixel value is now in high part of byte. repeat throughout byte
+ * pixel value is now in high part of byte. repeat throughout byte
val = uc;
for(i=bpp; i<8; i<<=1)
val |= val>>i;
return val;
}
- *
+ *
*/
void
break;
}
}
-
blob - 07cda45df25f888ad028fb8ad0fc09c0b11c47cf
blob + fb883d4e3ea940342f1bf92e39eb2a86594331a2
--- src/libmemdraw/drawtest.c
+++ src/libmemdraw/drawtest.c
int
iprint(char *fmt, ...)
{
- int n;
+ int n;
va_list va;
char buf[1024];
}
img->data->bdata = data;
}
-
+
}
/*
drawonepixel(dst, dp, src, sp, mask, mp);
memmove(mask->data->bdata, maskbits, mask->width*sizeof(u32int)*Yrange);
memmove(savedstbits, dst->data->bdata, dst->width*sizeof(u32int)*Yrange);
-
+
memmove(dst->data->bdata, dstbits, dst->width*sizeof(u32int)*Yrange);
memimagedraw(dst, Rect(dp.x, dp.y, dp.x+1, dp.y+1), src, sp, mask, mp, SoverD);
memmove(mask->data->bdata, maskbits, mask->width*sizeof(u32int)*Yrange);
else
r.max.y = r.min.y+3 + nrand(Yrange-(r.min.y+3));
}
- assert(r.min.x >= 0);
+ assert(r.min.x >= 0);
assert(r.max.x <= Xrange);
assert(r.min.y >= 0);
assert(r.max.y <= Yrange);
#define DBG if(0)
/*
* Write a pixel to img at point pt.
- *
+ *
* We do this by reading a 32-bit little endian
* value from p and then writing it back
* after tweaking the appropriate bits. Because
/*
* Sub-byte greyscale pixels. We need to skip the leftmost pt.x%npack pixels,
* which is equivalent to skipping the rightmost npack - pt.x%npack - 1 pixels.
- */
+ */
npack = 8/bpp;
sh = bpp*(npack - pt.x%npack - 1);
bits = RGB2K(r,g,b);
p[0] = v;
p[1] = v>>8;
p[2] = v>>16;
- p[3] = v>>24;
+ p[3] = v>>24;
}
#undef DBG
blob - 7dc45cd6fee3dab9ea799c8b0dcdb62422018e20
blob + a467c248bd5f281d10e7f4b8c1b4a98486296abc
--- src/libmemdraw/ellipse.c
+++ src/libmemdraw/ellipse.c
while(s->x < s->a) {
if(s->ee+s->b2x <= s->c1 || /* e(x+1,y-1/2) <= 0 */
s->ee+s->a2y <= s->c2) { /* e(x+1/2,y) <= 0 (rare) */
- s->dxe += s->d2xe;
- s->ee += s->dxe;
+ s->dxe += s->d2xe;
+ s->ee += s->dxe;
s->b2x += s->b2;
- s->x++;
+ s->x++;
continue;
}
- s->dye += s->d2ye;
- s->ee += s->dye;
+ s->dye += s->d2ye;
+ s->ee += s->dye;
s->a2y -= s->a2;
if(s->ee-s->a2y <= s->c2) { /* e(x+1/2,y-1) <= 0 */
- s->dxe += s->d2xe;
- s->ee += s->dxe;
+ s->dxe += s->d2xe;
+ s->ee += s->dxe;
s->b2x += s->b2;
return s->x++;
}
break;
}
- return s->x;
+ return s->x;
}
void
if(t < 0) {
inb = -1;
newstate(&out, a, y = b);
- } else {
+ } else {
inb = b - t;
newstate(&out, a+t, y = b+t);
}
memdraw(p->dst, r, p->src, addpt(p->sp, r.min), p->disc, p->disc->r.min, p->op);
}
-/*
+/*
* a brushed horizontal or vertical line similarly specified
*/
static
blob - d75459f1780b5ed24f9e690dea080479877b60b7
blob + 37d2635b5f4625c04c389e718f0799b837a55713
--- src/libmemdraw/fill-stub.c
+++ src/libmemdraw/fill-stub.c
{
_memfillcolor(m, val);
}
-
blob - 3f36250f22ec43c8bf6cb3d064bc2cc8e01333e5
blob + 59f63be2fc2a58717340b2c4f3f0010650dbae24
--- src/libmemdraw/hwdraw.c
+++ src/libmemdraw/hwdraw.c
USED(p);
return 0; /* could not satisfy request */
}
-
blob - 923b6b448c8e075b6c258e5777eb21a24de21cdd
blob + 5243970be29b8e5910c8d3e7ec9ea60d2ba8b1ae
--- src/libmemdraw/iprint.c
+++ src/libmemdraw/iprint.c
USED(fmt);
return -1;
}
-
blob - b0d5fcee18d715c9b7f1327dcf6b113bc45328e1
blob + 7cca3a6fd3b2f8522905beae7e55786c2696a456
--- src/libmemdraw/load-stub.c
+++ src/libmemdraw/load-stub.c
{
return _loadmemimage(i, r, data, ndata);
}
-
blob - 6dc6eea68abcc45d45d55902fbdca4bd06ca2f72
blob + 85646abf210b0bd4dedcfcb7edad76dc253888c8
--- src/libmp/port/crt.c
+++ src/libmp/port/crt.c
mpfree(u);
- return crt;
+ return crt;
}
void
blob - ef94813a2f6e849ed00b318e57b52ff7eaf283c9
blob + 213a013071d3543f12feab913503b21da556624c
--- src/libmp/port/mpaux.c
+++ src/libmp/port/mpaux.c
}
return k;
}
-
blob - 712db1706b322d1ffe93fa443b935a1354bbd4bb
blob + 696b16b0987431f79d48e79f65dffb21c5cf06d5
--- src/libmp/port/mpextendedgcd.c
+++ src/libmp/port/mpextendedgcd.c
mpright(A, 1, A);
mpright(B, 1, B);
}
-
+
/* print("%B %B %B %B %B %B\n", u, v, A, B, C, D); */
while(iseven(v)){
mpright(v, 1, v);
mpright(C, 1, C);
mpright(D, 1, D);
}
-
+
/* print("%B %B %B %B %B %B\n", u, v, A, B, C, D); */
if(mpcmp(u, v) >= 0){
mpsub(u, v, u);
blob - 7e34597dd21ae9899d7ab180e04be6d8d51c85ae
blob + 7da82ed76758f36e6d101b65393c252c10c41a13
--- src/libmp/port/mpfmt.c
+++ src/libmp/port/mpfmt.c
return 0;
}
}
-
blob - d49225e9edbc4bd91bfb4ebf111b82c12134d529
blob + a6e4f4579d76be67b308da81baaf8db8178118b0
--- src/libmp/port/mptobe.c
+++ src/libmp/port/mptobe.c
else
return 1;
}
-
+
s = p;
e = s+n;
suppress = 1;
blob - 0b676ef658983b7ede806db51bab06c141146302
blob + ffefd48ed7c9614fd5a2b984d5b06b6b6a927463
--- src/libmp/port/mptole.c
+++ src/libmp/port/mptole.c
else
return 0;
}
-
+
s = p;
e = s+n;
for(i = 0; i < b->top-1; i++){
blob - 9cb74ea468c72f248a418f998dda21b738afe255
blob + b4aff1337f8ed21d6c52bfd125d8d22e7ca5d203
--- src/libmp/port/mptouv.c
+++ src/libmp/port/mptouv.c
for(s = 0; s < VLDIGITS && v != 0; s++){
b->p[s] = v;
/* !@*$&!@$ gcc gives warnings about the >> here
- * when running on 64-bit machines, even though
+ * when running on 64-bit machines, even though
* it's in dead code. fake it out with two shifts.
if(sizeof(mpdigit) == sizeof(uvlong))
v = 0;
blob - b24b8e3e7d1ff271011787c27f87505f8a0e2094
blob + 349bf335e1063ae1442452dfdd77ca7f57f30d6a
--- src/libmp/port/mptov.c
+++ src/libmp/port/mptov.c
for(s = 0; s < VLDIGITS && uv != 0; s++){
b->p[s] = uv;
/* !@*$&!@$ gcc gives warnings about the >> here
- * when running on 64-bit machines, even though
+ * when running on 64-bit machines, even though
* it's in dead code. fake it out with two shifts.
if(sizeof(mpdigit) == sizeof(uvlong))
uv = 0;
blob - dae875d66b2c120295534d274f869e9ad4be3b02
blob + 07a1f976581732cfc565e5e3fbb8ac3cbc9a6784
--- src/libmp/port/os.h
+++ src/libmp/port/os.h
#include <u.h>
#include <libc.h>
-
blob - 3a2a933197b5a0168577476360ec3e0ecf38b915
blob + 644f07de5589e8d2aa53567b7dd0ab117e4acfbc
--- src/libmux/io.c
+++ src/libmux/io.c
/*
* If you fork off two procs running muxrecvproc and muxsendproc,
- * then muxrecv/muxsend (and thus muxrpc) will never block except on
+ * then muxrecv/muxsend (and thus muxrpc) will never block except on
* rendevouses, which is nice when it's running in one thread of many.
*/
void
if(mux->send(mux, p) < 0){
qunlock(&mux->outlk);
/* vthangup(mux); */
- return -1;
+ return -1;
}
qunlock(&mux->outlk);
return 0;
}
-
blob - 8257fb0e7200fc947ade5b2832f97f5b8507ad39
blob + e778607959304e7f361f6df69bffc7f53ea72471
--- src/libmux/mux.c
+++ src/libmux/mux.c
allocmuxrpc(Mux *mux)
{
Muxrpc *r;
-
+
/* must malloc because stack could be private */
r = mallocz(sizeof(Muxrpc), 1);
if(r == nil){
r->mux = mux;
r->r.l = &mux->lk;
r->waiting = 1;
-
+
return r;
}
{
int tag;
Mux *mux;
-
+
mux = r->mux;
/* assign the tag, add selves to response queue */
qlock(&mux->lk);
fprint(2, "%s: bad rpc tag %ux (no one waiting on that tag)\n", argv0, tag);
/* must leak packet! don't know how to free it! */
return;
- }
+ }
r2->p = p;
dequeue(mux, r2);
rwakeup(&r2->r);
r->next = nil;
}
-static int
+static int
gettag(Mux *mux, Muxrpc *r)
{
int i, mw;
blob - 76f3d8e0950f8ef77da2517fb47f02e56acfc8f3
blob + 6ffaf172752e950a2c0155b3cb5b587653b036b6
--- src/libndb/csipinfo.c
+++ src/libndb/csipinfo.c
break;
p = seprint(p, e, " %s", *list++);
}
-
+
if(write(fd, line, strlen(line)) < 0){
close(fd);
return 0;
blob - 4cf8735ad3ae38e94c85028d2cbcbf04dd138e84
blob + 74460b14683356487f70eea3fd2e7b06e2ae89d3
--- src/libndb/dnsquery.c
+++ src/libndb/dnsquery.c
snprint(buf, sizeof(buf), "!%s %s", dn, type);
if(write(fd, buf, strlen(buf)) < 0)
return nil;
-
+
seek(fd, 0, 0);
first = last = nil;
-
+
for(;;){
n = read(fd, buf, sizeof(buf)-2);
if(n <= 0)
blob - 94246fc6a97f1da8ba6c0752ce6afa1fea0b664a
blob + a2688736ca3ee9d23bed38c1dee0336c98053913
--- src/libndb/ndbaux.c
+++ src/libndb/ndbaux.c
}
/*
- * parse all tuples in a line. we assume that the
+ * parse all tuples in a line. we assume that the
* line ends in a '\n'.
*
* the tuples are linked as a list using ->entry and
blob - 80dbc35b4c9e50950459d3d61b11918ba20b2237
blob + d02530f528032ac1cb1b6fdfd1ad242e5cf0637b
--- src/libndb/ndbcache.c
+++ src/libndb/ndbcache.c
char *attr;
char *val;
Ndbs s;
- Ndbtuple *t;
+ Ndbtuple *t;
};
enum
blob - 647bff03c0c17f7b5bbfcfea492c058f567eae07
blob + 506261319a53339144fb1dfaeade31a54216c76c
--- src/libndb/ndbfree.c
+++ src/libndb/ndbfree.c
t->val = t->valbuf;
if(val != nil)
ndbsetval(t, val, strlen(val));
- return t;
+ return t;
}
blob - 4f9cb4b644031c89817dd43b0b189989197b5af1
blob + 8dee18a5e4d674290cb2316c353e51393776c9fb
--- src/libndb/ndbhash.c
+++ src/libndb/ndbhash.c
ndbfree(t);
} else if(s->type == Cptr){
if(Bseek(&db->b, s->ptr, 0) < 0)
- break;
+ break;
s->ptr = s->ptr1;
s->type = Cptr1;
t = ndbparse(db);
s->type = Cptr;
} else { /* end of hash chain */
if(Bseek(&db->b, s->ptr, 0) < 0)
- break;
+ break;
s->ptr = NDBNAP;
t = ndbparse(db);
if(t == 0)
blob - fdda79ec7d2bf92ac075574af880b139d7e3214d
blob + 1002b4d686a22d544a04a44dd5cc498920d39e4e
--- src/libndb/ndbopen.c
+++ src/libndb/ndbopen.c
* Unrooted paths are taken relative to db we opened.
*/
if(file[0]!='/' && rel && (p=strrchr(rel, '/'))!=nil)
- snprint(db->file, sizeof(db->file), "%.*s/%s",
+ snprint(db->file, sizeof(db->file), "%.*s/%s",
utfnlen(rel, p-rel), rel, file);
else
strncpy(db->file, file, sizeof(db->file)-1);
blob - 390d7818f1bbe88fc8bbc9dad731bc95ee34f9e8
blob + c25d7b5f32248f39af1178fae017b58d35c08fa6
--- src/libndb/ndbreorder.c
+++ src/libndb/ndbreorder.c
for(nt = t; nt->entry != last->line; nt = nt->entry)
;
nt->entry = nil;
-
+
/* switch */
for(nt = last; nt->entry != nil; nt = nt->entry)
;
blob - 0a771e2b9f0158c91f542985f300ff0ef123d56e
blob + 1f6cbb58bb762aba2ef647e60c9070ee63a60a6c
--- src/libndb/sysdnsquery.c
+++ src/libndb/sysdnsquery.c
dnsquery(char *net, char *val, char *type)
{
static int init;
- char rip[128];
+ char rip[128];
Ndbtuple *t;
USED(net);
-
+
if(!init){
init = 1;
fmtinstall('I', eipfmt);
/* give up early on stupid questions - vwhois */
if(strcmp(val, "::") == 0 || strcmp(val, "0.0.0.0") == 0)
return nil;
-
+
/* zero out the error string */
werrstr("");
-
+
/* if this is a reverse lookup, first look up the domain name */
if(strcmp(type, "ptr") == 0){
mkptrname(val, rip, sizeof rip);
t = doquery(rip, "ptr");
}else
t = doquery(val, type);
-
+
return t;
}
/* query types (all RR types are also queries) */
Tixfr= 251, /* incremental zone transfer */
Taxfr= 252, /* zone transfer */
- Tmailb= 253, /* { Tmb, Tmg, Tmr } */
+ Tmailb= 253, /* { Tmb, Tmg, Tmr } */
Tall= 255, /* all records */
/* classes */
qdcount = (buf[4]<<8)|buf[5];
ancount = (buf[6]<<8)|buf[7];
-
+
p = buf+12;
p = skipquestion(buf, buf+n, p, qdcount);
p = unpack(buf, buf+n, p, &t, ancount);
type2name(int t)
{
int i;
-
+
for(i=0; i<nelem(dnsnames); i++)
if(dnsnames[i].t == t)
return dnsnames[i].s;
name2type(char *name)
{
int i;
-
+
for(i=0; i<nelem(dnsnames); i++)
if(strcmp(name, dnsnames[i].s) == 0)
return dnsnames[i].t;
{
int i, len;
char tmp[100];
-
+
for(i=0; i<n; i++){
if((len = dn_expand(buf, ebuf, p, tmp, sizeof tmp)) <= 0)
return nil;
return nil;
}
p += len;
-
+
rrtype = G2(p);
rrlen = G2(p+8);
p += 10;
-
+
if(rrtype == Tptr)
first = ndbnew("ptr", b);
else
break;
case Tsoa:
- t = rrunpack(buf, ebuf, &p, "NNLLLLL", "ns", "mbox",
+ t = rrunpack(buf, ebuf, &p, "NNLLLLL", "ns", "mbox",
"serial", "refresh", "retry", "expire", "ttl");
break;
case Tkey:
t = rrunpack(buf, ebuf, &p, "SCCY", "flags", "proto", "alg", "key");
break;
-
+
case Tsig:
t = rrunpack(buf, ebuf, &p, "SCCLLLSNY", "type", "alg", "labels",
"ttl", "exp", "incep", "tag", "signer", "sig");
break;
-
+
case Tcert:
t = rrunpack(buf, ebuf, &p, "SSCY", "type", "tag", "alg", "cert");
break;
va_list arg;
Ndbtuple *t, *first, *last;
char tmp[Ndbvlen];
-
+
p = *pp;
va_start(arg, fmt);
first = nil;
blob - 6c72c5d86fb95ba0de361327439366d16c90c83b
blob + 96cbec57cef8c95f10eedfa6e5adc7977784c271
--- src/libndb/testdns.c
+++ src/libndb/testdns.c
main(int argc, char **argv)
{
Ndbtuple *t, *t0;
-
+
ARGBEGIN{
default:
goto usage;
}ARGEND
-
+
if(argc != 2){
usage:
fprint(2, "usage: testdns name val\n");
exits("usage");
}
-
+
quotefmtinstall();
if((t = dnsquery(nil, argv[0], argv[1])) == nil)
sysfatal("dnsquery: %r");
-
+
for(t0=t; t; t=t->entry){
print("%s=%q ", t->attr, t->val);
if(t->line == t0){
}
exits(0);
}
-
blob - 36a95d687f882f4cac738da882a22788bde65f01 (mode 755)
blob + 36a95d687f882f4cac738da882a22788bde65f01 (mode 644)
blob - 017f92c3ee290660da1e3683aaaa7c4f6cb47618
blob + 8628f9f3085b6f7a265a19f4cda289679b3975e8
--- src/libplumb/fid.c
+++ src/libplumb/fid.c
free(buf);
return m;
}
-
blob - c9379307c7d79b807ec2985b9d3966968729492b (mode 755)
blob + acc0ac3234d1e90843b1744ab6cac1aea17b656c (mode 644)
--- src/libplumb/mesg.c
+++ src/libplumb/mesg.c
{
return plumbunpackpartial(buf, n, nil);
}
-
blob - 1d7aaa627f133c69006a479af7ae6c881e41915f
blob + f309c094faf1f9dbf2128fec91aee681df182375
--- src/libregexp/lib9.std.h
+++ src/libregexp/lib9.std.h
#define exits(x) exit(x && *x ? 1 : 0)
#define nil 0
-
blob - cd299a54a5e85e3c6b1aeb678d30b384a3158eae
blob + c58b4d846e73d37f8511f760680b8914a556bf92
--- src/libregexp/regcomp.c
+++ src/libregexp/regcomp.c
while(*s)
*cp++ = *s++;
*cp++ = c;
- *cp = '\0';
+ *cp = '\0';
rcerror(buf);
}
blob - 9cbb6bd90a6341a60b1e7a344f40bbbb112e2389
blob + 7612842e19266dadd958de2b3b0e16e4b158298a
--- src/libsec/port/aes.c
+++ src/libsec/port/aes.c
* invert the order of the round keys and
* apply the inverse MixColumn transform to all round keys but the first and the last
*/
- drk[0 ] = erk[4*Nr ];
+ drk[0 ] = erk[4*Nr ];
drk[1 ] = erk[4*Nr + 1];
- drk[2 ] = erk[4*Nr + 2];
+ drk[2 ] = erk[4*Nr + 2];
drk[3 ] = erk[4*Nr + 3];
- drk[4*Nr ] = erk[0 ];
+ drk[4*Nr ] = erk[0 ];
drk[4*Nr + 1] = erk[1 ];
- drk[4*Nr + 2] = erk[2 ];
+ drk[4*Nr + 2] = erk[2 ];
drk[4*Nr + 3] = erk[3 ];
erk += 4 * Nr;
for (i = 1; i < Nr; i++) {
(Te4[(s1 >> 8) & 0xff] << 8) ^
(Te4[(s2 ) & 0xff] ) ^
rk[3];
-
+
s0 = t0;
s1 = t1;
s2 = t2;
blob - 0eed2939ae04cd51a331ba43111275bbb6398f94
blob + abfe912eb7f7789b5696a7167e4e7737dfe343bc
--- src/libsec/port/blowfish.c
+++ src/libsec/port/blowfish.c
memmove(s->ivec, ivec, sizeof(s->ivec));
else
memset(s->ivec, 0, sizeof(s->ivec));
-
+
memmove(s->pbox, pbox, sizeof(pbox));
memmove(s->sbox, sbox, sizeof(sbox));
buf[0] = b[0];
}
- return;
+ return;
}
static void
for(i=1; i<16; i += 2) {
r ^= pb[i];
- r ^= ( (sb[ (uchar) (l>>24)] + sb[256 + ((uchar) (l>>16))]) ^
+ r ^= ( (sb[ (uchar) (l>>24)] + sb[256 + ((uchar) (l>>16))]) ^
sb[512 + ((uchar) (l>>8))]) + sb[768 +((uchar) l)];
l ^= pb[i+1];
- l ^= ( (sb[ (uchar) (r>>24)] + sb[256 + ((uchar) (r>>16))]) ^
+ l ^= ( (sb[ (uchar) (r>>24)] + sb[256 + ((uchar) (r>>16))]) ^
sb[512 + ((uchar) (r>>8))]) + sb[768 +((uchar) r)];
}
for(i=16; i > 0; i -= 2) {
r ^= pb[i];
- r ^= ( (sb[ (uchar) (l>>24)] + sb[256 + ((uchar) (l>>16))]) ^
+ r ^= ( (sb[ (uchar) (l>>24)] + sb[256 + ((uchar) (l>>16))]) ^
sb[512 + ((uchar) (l>>8))]) + sb[768 +((uchar) l)];
l ^= pb[i-1];
- l ^= ( (sb[ (uchar) (r>>24)] + sb[256 + ((uchar) (r>>16))]) ^
+ l ^= ( (sb[ (uchar) (r>>24)] + sb[256 + ((uchar) (r>>16))]) ^
sb[512 + ((uchar) (r>>8))]) + sb[768 +((uchar) r)];
}
}
static u32int pbox[BFrounds+2] = {
- 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
- 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
- 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
- 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
+ 0x243f6a88, 0x85a308d3, 0x13198a2e, 0x03707344,
+ 0xa4093822, 0x299f31d0, 0x082efa98, 0xec4e6c89,
+ 0x452821e6, 0x38d01377, 0xbe5466cf, 0x34e90c6c,
+ 0xc0ac29b7, 0xc97c50dd, 0x3f84d5b5, 0xb5470917,
0x9216d5d9, 0x8979fb1b
};
static u32int sbox[1024] = {
- 0xd1310ba6L, 0x98dfb5acL, 0x2ffd72dbL, 0xd01adfb7L,
- 0xb8e1afedL, 0x6a267e96L, 0xba7c9045L, 0xf12c7f99L,
- 0x24a19947L, 0xb3916cf7L, 0x0801f2e2L, 0x858efc16L,
- 0x636920d8L, 0x71574e69L, 0xa458fea3L, 0xf4933d7eL,
- 0x0d95748fL, 0x728eb658L, 0x718bcd58L, 0x82154aeeL,
- 0x7b54a41dL, 0xc25a59b5L, 0x9c30d539L, 0x2af26013L,
- 0xc5d1b023L, 0x286085f0L, 0xca417918L, 0xb8db38efL,
- 0x8e79dcb0L, 0x603a180eL, 0x6c9e0e8bL, 0xb01e8a3eL,
- 0xd71577c1L, 0xbd314b27L, 0x78af2fdaL, 0x55605c60L,
- 0xe65525f3L, 0xaa55ab94L, 0x57489862L, 0x63e81440L,
- 0x55ca396aL, 0x2aab10b6L, 0xb4cc5c34L, 0x1141e8ceL,
- 0xa15486afL, 0x7c72e993L, 0xb3ee1411L, 0x636fbc2aL,
- 0x2ba9c55dL, 0x741831f6L, 0xce5c3e16L, 0x9b87931eL,
- 0xafd6ba33L, 0x6c24cf5cL, 0x7a325381L, 0x28958677L,
- 0x3b8f4898L, 0x6b4bb9afL, 0xc4bfe81bL, 0x66282193L,
- 0x61d809ccL, 0xfb21a991L, 0x487cac60L, 0x5dec8032L,
- 0xef845d5dL, 0xe98575b1L, 0xdc262302L, 0xeb651b88L,
- 0x23893e81L, 0xd396acc5L, 0x0f6d6ff3L, 0x83f44239L,
- 0x2e0b4482L, 0xa4842004L, 0x69c8f04aL, 0x9e1f9b5eL,
- 0x21c66842L, 0xf6e96c9aL, 0x670c9c61L, 0xabd388f0L,
- 0x6a51a0d2L, 0xd8542f68L, 0x960fa728L, 0xab5133a3L,
- 0x6eef0b6cL, 0x137a3be4L, 0xba3bf050L, 0x7efb2a98L,
- 0xa1f1651dL, 0x39af0176L, 0x66ca593eL, 0x82430e88L,
- 0x8cee8619L, 0x456f9fb4L, 0x7d84a5c3L, 0x3b8b5ebeL,
- 0xe06f75d8L, 0x85c12073L, 0x401a449fL, 0x56c16aa6L,
- 0x4ed3aa62L, 0x363f7706L, 0x1bfedf72L, 0x429b023dL,
- 0x37d0d724L, 0xd00a1248L, 0xdb0fead3L, 0x49f1c09bL,
- 0x075372c9L, 0x80991b7bL, 0x25d479d8L, 0xf6e8def7L,
- 0xe3fe501aL, 0xb6794c3bL, 0x976ce0bdL, 0x04c006baL,
- 0xc1a94fb6L, 0x409f60c4L, 0x5e5c9ec2L, 0x196a2463L,
- 0x68fb6fafL, 0x3e6c53b5L, 0x1339b2ebL, 0x3b52ec6fL,
- 0x6dfc511fL, 0x9b30952cL, 0xcc814544L, 0xaf5ebd09L,
- 0xbee3d004L, 0xde334afdL, 0x660f2807L, 0x192e4bb3L,
- 0xc0cba857L, 0x45c8740fL, 0xd20b5f39L, 0xb9d3fbdbL,
- 0x5579c0bdL, 0x1a60320aL, 0xd6a100c6L, 0x402c7279L,
- 0x679f25feL, 0xfb1fa3ccL, 0x8ea5e9f8L, 0xdb3222f8L,
- 0x3c7516dfL, 0xfd616b15L, 0x2f501ec8L, 0xad0552abL,
- 0x323db5faL, 0xfd238760L, 0x53317b48L, 0x3e00df82L,
- 0x9e5c57bbL, 0xca6f8ca0L, 0x1a87562eL, 0xdf1769dbL,
- 0xd542a8f6L, 0x287effc3L, 0xac6732c6L, 0x8c4f5573L,
- 0x695b27b0L, 0xbbca58c8L, 0xe1ffa35dL, 0xb8f011a0L,
- 0x10fa3d98L, 0xfd2183b8L, 0x4afcb56cL, 0x2dd1d35bL,
- 0x9a53e479L, 0xb6f84565L, 0xd28e49bcL, 0x4bfb9790L,
- 0xe1ddf2daL, 0xa4cb7e33L, 0x62fb1341L, 0xcee4c6e8L,
- 0xef20cadaL, 0x36774c01L, 0xd07e9efeL, 0x2bf11fb4L,
- 0x95dbda4dL, 0xae909198L, 0xeaad8e71L, 0x6b93d5a0L,
- 0xd08ed1d0L, 0xafc725e0L, 0x8e3c5b2fL, 0x8e7594b7L,
- 0x8ff6e2fbL, 0xf2122b64L, 0x8888b812L, 0x900df01cL,
- 0x4fad5ea0L, 0x688fc31cL, 0xd1cff191L, 0xb3a8c1adL,
- 0x2f2f2218L, 0xbe0e1777L, 0xea752dfeL, 0x8b021fa1L,
- 0xe5a0cc0fL, 0xb56f74e8L, 0x18acf3d6L, 0xce89e299L,
- 0xb4a84fe0L, 0xfd13e0b7L, 0x7cc43b81L, 0xd2ada8d9L,
- 0x165fa266L, 0x80957705L, 0x93cc7314L, 0x211a1477L,
- 0xe6ad2065L, 0x77b5fa86L, 0xc75442f5L, 0xfb9d35cfL,
- 0xebcdaf0cL, 0x7b3e89a0L, 0xd6411bd3L, 0xae1e7e49L,
- 0x00250e2dL, 0x2071b35eL, 0x226800bbL, 0x57b8e0afL,
- 0x2464369bL, 0xf009b91eL, 0x5563911dL, 0x59dfa6aaL,
- 0x78c14389L, 0xd95a537fL, 0x207d5ba2L, 0x02e5b9c5L,
- 0x83260376L, 0x6295cfa9L, 0x11c81968L, 0x4e734a41L,
- 0xb3472dcaL, 0x7b14a94aL, 0x1b510052L, 0x9a532915L,
- 0xd60f573fL, 0xbc9bc6e4L, 0x2b60a476L, 0x81e67400L,
- 0x08ba6fb5L, 0x571be91fL, 0xf296ec6bL, 0x2a0dd915L,
- 0xb6636521L, 0xe7b9f9b6L, 0xff34052eL, 0xc5855664L,
- 0x53b02d5dL, 0xa99f8fa1L, 0x08ba4799L, 0x6e85076aL,
- 0x4b7a70e9L, 0xb5b32944L, 0xdb75092eL, 0xc4192623L,
- 0xad6ea6b0L, 0x49a7df7dL, 0x9cee60b8L, 0x8fedb266L,
- 0xecaa8c71L, 0x699a17ffL, 0x5664526cL, 0xc2b19ee1L,
- 0x193602a5L, 0x75094c29L, 0xa0591340L, 0xe4183a3eL,
- 0x3f54989aL, 0x5b429d65L, 0x6b8fe4d6L, 0x99f73fd6L,
- 0xa1d29c07L, 0xefe830f5L, 0x4d2d38e6L, 0xf0255dc1L,
- 0x4cdd2086L, 0x8470eb26L, 0x6382e9c6L, 0x021ecc5eL,
- 0x09686b3fL, 0x3ebaefc9L, 0x3c971814L, 0x6b6a70a1L,
- 0x687f3584L, 0x52a0e286L, 0xb79c5305L, 0xaa500737L,
- 0x3e07841cL, 0x7fdeae5cL, 0x8e7d44ecL, 0x5716f2b8L,
- 0xb03ada37L, 0xf0500c0dL, 0xf01c1f04L, 0x0200b3ffL,
- 0xae0cf51aL, 0x3cb574b2L, 0x25837a58L, 0xdc0921bdL,
- 0xd19113f9L, 0x7ca92ff6L, 0x94324773L, 0x22f54701L,
- 0x3ae5e581L, 0x37c2dadcL, 0xc8b57634L, 0x9af3dda7L,
- 0xa9446146L, 0x0fd0030eL, 0xecc8c73eL, 0xa4751e41L,
- 0xe238cd99L, 0x3bea0e2fL, 0x3280bba1L, 0x183eb331L,
- 0x4e548b38L, 0x4f6db908L, 0x6f420d03L, 0xf60a04bfL,
- 0x2cb81290L, 0x24977c79L, 0x5679b072L, 0xbcaf89afL,
- 0xde9a771fL, 0xd9930810L, 0xb38bae12L, 0xdccf3f2eL,
- 0x5512721fL, 0x2e6b7124L, 0x501adde6L, 0x9f84cd87L,
- 0x7a584718L, 0x7408da17L, 0xbc9f9abcL, 0xe94b7d8cL,
- 0xec7aec3aL, 0xdb851dfaL, 0x63094366L, 0xc464c3d2L,
- 0xef1c1847L, 0x3215d908L, 0xdd433b37L, 0x24c2ba16L,
- 0x12a14d43L, 0x2a65c451L, 0x50940002L, 0x133ae4ddL,
- 0x71dff89eL, 0x10314e55L, 0x81ac77d6L, 0x5f11199bL,
- 0x043556f1L, 0xd7a3c76bL, 0x3c11183bL, 0x5924a509L,
- 0xf28fe6edL, 0x97f1fbfaL, 0x9ebabf2cL, 0x1e153c6eL,
- 0x86e34570L, 0xeae96fb1L, 0x860e5e0aL, 0x5a3e2ab3L,
- 0x771fe71cL, 0x4e3d06faL, 0x2965dcb9L, 0x99e71d0fL,
- 0x803e89d6L, 0x5266c825L, 0x2e4cc978L, 0x9c10b36aL,
- 0xc6150ebaL, 0x94e2ea78L, 0xa5fc3c53L, 0x1e0a2df4L,
- 0xf2f74ea7L, 0x361d2b3dL, 0x1939260fL, 0x19c27960L,
- 0x5223a708L, 0xf71312b6L, 0xebadfe6eL, 0xeac31f66L,
- 0xe3bc4595L, 0xa67bc883L, 0xb17f37d1L, 0x018cff28L,
- 0xc332ddefL, 0xbe6c5aa5L, 0x65582185L, 0x68ab9802L,
- 0xeecea50fL, 0xdb2f953bL, 0x2aef7dadL, 0x5b6e2f84L,
- 0x1521b628L, 0x29076170L, 0xecdd4775L, 0x619f1510L,
- 0x13cca830L, 0xeb61bd96L, 0x0334fe1eL, 0xaa0363cfL,
- 0xb5735c90L, 0x4c70a239L, 0xd59e9e0bL, 0xcbaade14L,
- 0xeecc86bcL, 0x60622ca7L, 0x9cab5cabL, 0xb2f3846eL,
- 0x648b1eafL, 0x19bdf0caL, 0xa02369b9L, 0x655abb50L,
- 0x40685a32L, 0x3c2ab4b3L, 0x319ee9d5L, 0xc021b8f7L,
- 0x9b540b19L, 0x875fa099L, 0x95f7997eL, 0x623d7da8L,
- 0xf837889aL, 0x97e32d77L, 0x11ed935fL, 0x16681281L,
- 0x0e358829L, 0xc7e61fd6L, 0x96dedfa1L, 0x7858ba99L,
- 0x57f584a5L, 0x1b227263L, 0x9b83c3ffL, 0x1ac24696L,
- 0xcdb30aebL, 0x532e3054L, 0x8fd948e4L, 0x6dbc3128L,
- 0x58ebf2efL, 0x34c6ffeaL, 0xfe28ed61L, 0xee7c3c73L,
- 0x5d4a14d9L, 0xe864b7e3L, 0x42105d14L, 0x203e13e0L,
- 0x45eee2b6L, 0xa3aaabeaL, 0xdb6c4f15L, 0xfacb4fd0L,
- 0xc742f442L, 0xef6abbb5L, 0x654f3b1dL, 0x41cd2105L,
- 0xd81e799eL, 0x86854dc7L, 0xe44b476aL, 0x3d816250L,
- 0xcf62a1f2L, 0x5b8d2646L, 0xfc8883a0L, 0xc1c7b6a3L,
- 0x7f1524c3L, 0x69cb7492L, 0x47848a0bL, 0x5692b285L,
- 0x095bbf00L, 0xad19489dL, 0x1462b174L, 0x23820e00L,
- 0x58428d2aL, 0x0c55f5eaL, 0x1dadf43eL, 0x233f7061L,
- 0x3372f092L, 0x8d937e41L, 0xd65fecf1L, 0x6c223bdbL,
- 0x7cde3759L, 0xcbee7460L, 0x4085f2a7L, 0xce77326eL,
- 0xa6078084L, 0x19f8509eL, 0xe8efd855L, 0x61d99735L,
- 0xa969a7aaL, 0xc50c06c2L, 0x5a04abfcL, 0x800bcadcL,
- 0x9e447a2eL, 0xc3453484L, 0xfdd56705L, 0x0e1e9ec9L,
- 0xdb73dbd3L, 0x105588cdL, 0x675fda79L, 0xe3674340L,
- 0xc5c43465L, 0x713e38d8L, 0x3d28f89eL, 0xf16dff20L,
- 0x153e21e7L, 0x8fb03d4aL, 0xe6e39f2bL, 0xdb83adf7L,
- 0xe93d5a68L, 0x948140f7L, 0xf64c261cL, 0x94692934L,
- 0x411520f7L, 0x7602d4f7L, 0xbcf46b2eL, 0xd4a20068L,
- 0xd4082471L, 0x3320f46aL, 0x43b7d4b7L, 0x500061afL,
- 0x1e39f62eL, 0x97244546L, 0x14214f74L, 0xbf8b8840L,
- 0x4d95fc1dL, 0x96b591afL, 0x70f4ddd3L, 0x66a02f45L,
- 0xbfbc09ecL, 0x03bd9785L, 0x7fac6dd0L, 0x31cb8504L,
- 0x96eb27b3L, 0x55fd3941L, 0xda2547e6L, 0xabca0a9aL,
- 0x28507825L, 0x530429f4L, 0x0a2c86daL, 0xe9b66dfbL,
- 0x68dc1462L, 0xd7486900L, 0x680ec0a4L, 0x27a18deeL,
- 0x4f3ffea2L, 0xe887ad8cL, 0xb58ce006L, 0x7af4d6b6L,
- 0xaace1e7cL, 0xd3375fecL, 0xce78a399L, 0x406b2a42L,
- 0x20fe9e35L, 0xd9f385b9L, 0xee39d7abL, 0x3b124e8bL,
- 0x1dc9faf7L, 0x4b6d1856L, 0x26a36631L, 0xeae397b2L,
- 0x3a6efa74L, 0xdd5b4332L, 0x6841e7f7L, 0xca7820fbL,
- 0xfb0af54eL, 0xd8feb397L, 0x454056acL, 0xba489527L,
- 0x55533a3aL, 0x20838d87L, 0xfe6ba9b7L, 0xd096954bL,
- 0x55a867bcL, 0xa1159a58L, 0xcca92963L, 0x99e1db33L,
- 0xa62a4a56L, 0x3f3125f9L, 0x5ef47e1cL, 0x9029317cL,
- 0xfdf8e802L, 0x04272f70L, 0x80bb155cL, 0x05282ce3L,
- 0x95c11548L, 0xe4c66d22L, 0x48c1133fL, 0xc70f86dcL,
- 0x07f9c9eeL, 0x41041f0fL, 0x404779a4L, 0x5d886e17L,
- 0x325f51ebL, 0xd59bc0d1L, 0xf2bcc18fL, 0x41113564L,
- 0x257b7834L, 0x602a9c60L, 0xdff8e8a3L, 0x1f636c1bL,
- 0x0e12b4c2L, 0x02e1329eL, 0xaf664fd1L, 0xcad18115L,
- 0x6b2395e0L, 0x333e92e1L, 0x3b240b62L, 0xeebeb922L,
- 0x85b2a20eL, 0xe6ba0d99L, 0xde720c8cL, 0x2da2f728L,
- 0xd0127845L, 0x95b794fdL, 0x647d0862L, 0xe7ccf5f0L,
- 0x5449a36fL, 0x877d48faL, 0xc39dfd27L, 0xf33e8d1eL,
- 0x0a476341L, 0x992eff74L, 0x3a6f6eabL, 0xf4f8fd37L,
- 0xa812dc60L, 0xa1ebddf8L, 0x991be14cL, 0xdb6e6b0dL,
- 0xc67b5510L, 0x6d672c37L, 0x2765d43bL, 0xdcd0e804L,
- 0xf1290dc7L, 0xcc00ffa3L, 0xb5390f92L, 0x690fed0bL,
- 0x667b9ffbL, 0xcedb7d9cL, 0xa091cf0bL, 0xd9155ea3L,
- 0xbb132f88L, 0x515bad24L, 0x7b9479bfL, 0x763bd6ebL,
- 0x37392eb3L, 0xcc115979L, 0x8026e297L, 0xf42e312dL,
- 0x6842ada7L, 0xc66a2b3bL, 0x12754cccL, 0x782ef11cL,
- 0x6a124237L, 0xb79251e7L, 0x06a1bbe6L, 0x4bfb6350L,
- 0x1a6b1018L, 0x11caedfaL, 0x3d25bdd8L, 0xe2e1c3c9L,
- 0x44421659L, 0x0a121386L, 0xd90cec6eL, 0xd5abea2aL,
- 0x64af674eL, 0xda86a85fL, 0xbebfe988L, 0x64e4c3feL,
- 0x9dbc8057L, 0xf0f7c086L, 0x60787bf8L, 0x6003604dL,
- 0xd1fd8346L, 0xf6381fb0L, 0x7745ae04L, 0xd736fcccL,
- 0x83426b33L, 0xf01eab71L, 0xb0804187L, 0x3c005e5fL,
- 0x77a057beL, 0xbde8ae24L, 0x55464299L, 0xbf582e61L,
- 0x4e58f48fL, 0xf2ddfda2L, 0xf474ef38L, 0x8789bdc2L,
- 0x5366f9c3L, 0xc8b38e74L, 0xb475f255L, 0x46fcd9b9L,
- 0x7aeb2661L, 0x8b1ddf84L, 0x846a0e79L, 0x915f95e2L,
- 0x466e598eL, 0x20b45770L, 0x8cd55591L, 0xc902de4cL,
- 0xb90bace1L, 0xbb8205d0L, 0x11a86248L, 0x7574a99eL,
- 0xb77f19b6L, 0xe0a9dc09L, 0x662d09a1L, 0xc4324633L,
- 0xe85a1f02L, 0x09f0be8cL, 0x4a99a025L, 0x1d6efe10L,
- 0x1ab93d1dL, 0x0ba5a4dfL, 0xa186f20fL, 0x2868f169L,
- 0xdcb7da83L, 0x573906feL, 0xa1e2ce9bL, 0x4fcd7f52L,
- 0x50115e01L, 0xa70683faL, 0xa002b5c4L, 0x0de6d027L,
- 0x9af88c27L, 0x773f8641L, 0xc3604c06L, 0x61a806b5L,
- 0xf0177a28L, 0xc0f586e0L, 0x006058aaL, 0x30dc7d62L,
- 0x11e69ed7L, 0x2338ea63L, 0x53c2dd94L, 0xc2c21634L,
- 0xbbcbee56L, 0x90bcb6deL, 0xebfc7da1L, 0xce591d76L,
- 0x6f05e409L, 0x4b7c0188L, 0x39720a3dL, 0x7c927c24L,
- 0x86e3725fL, 0x724d9db9L, 0x1ac15bb4L, 0xd39eb8fcL,
- 0xed545578L, 0x08fca5b5L, 0xd83d7cd3L, 0x4dad0fc4L,
- 0x1e50ef5eL, 0xb161e6f8L, 0xa28514d9L, 0x6c51133cL,
- 0x6fd5c7e7L, 0x56e14ec4L, 0x362abfceL, 0xddc6c837L,
- 0xd79a3234L, 0x92638212L, 0x670efa8eL, 0x406000e0L,
- 0x3a39ce37L, 0xd3faf5cfL, 0xabc27737L, 0x5ac52d1bL,
- 0x5cb0679eL, 0x4fa33742L, 0xd3822740L, 0x99bc9bbeL,
- 0xd5118e9dL, 0xbf0f7315L, 0xd62d1c7eL, 0xc700c47bL,
- 0xb78c1b6bL, 0x21a19045L, 0xb26eb1beL, 0x6a366eb4L,
- 0x5748ab2fL, 0xbc946e79L, 0xc6a376d2L, 0x6549c2c8L,
- 0x530ff8eeL, 0x468dde7dL, 0xd5730a1dL, 0x4cd04dc6L,
- 0x2939bbdbL, 0xa9ba4650L, 0xac9526e8L, 0xbe5ee304L,
- 0xa1fad5f0L, 0x6a2d519aL, 0x63ef8ce2L, 0x9a86ee22L,
- 0xc089c2b8L, 0x43242ef6L, 0xa51e03aaL, 0x9cf2d0a4L,
- 0x83c061baL, 0x9be96a4dL, 0x8fe51550L, 0xba645bd6L,
- 0x2826a2f9L, 0xa73a3ae1L, 0x4ba99586L, 0xef5562e9L,
- 0xc72fefd3L, 0xf752f7daL, 0x3f046f69L, 0x77fa0a59L,
- 0x80e4a915L, 0x87b08601L, 0x9b09e6adL, 0x3b3ee593L,
- 0xe990fd5aL, 0x9e34d797L, 0x2cf0b7d9L, 0x022b8b51L,
- 0x96d5ac3aL, 0x017da67dL, 0xd1cf3ed6L, 0x7c7d2d28L,
- 0x1f9f25cfL, 0xadf2b89bL, 0x5ad6b472L, 0x5a88f54cL,
- 0xe029ac71L, 0xe019a5e6L, 0x47b0acfdL, 0xed93fa9bL,
- 0xe8d3c48dL, 0x283b57ccL, 0xf8d56629L, 0x79132e28L,
- 0x785f0191L, 0xed756055L, 0xf7960e44L, 0xe3d35e8cL,
- 0x15056dd4L, 0x88f46dbaL, 0x03a16125L, 0x0564f0bdL,
- 0xc3eb9e15L, 0x3c9057a2L, 0x97271aecL, 0xa93a072aL,
- 0x1b3f6d9bL, 0x1e6321f5L, 0xf59c66fbL, 0x26dcf319L,
- 0x7533d928L, 0xb155fdf5L, 0x03563482L, 0x8aba3cbbL,
- 0x28517711L, 0xc20ad9f8L, 0xabcc5167L, 0xccad925fL,
- 0x4de81751L, 0x3830dc8eL, 0x379d5862L, 0x9320f991L,
- 0xea7a90c2L, 0xfb3e7bceL, 0x5121ce64L, 0x774fbe32L,
- 0xa8b6e37eL, 0xc3293d46L, 0x48de5369L, 0x6413e680L,
- 0xa2ae0810L, 0xdd6db224L, 0x69852dfdL, 0x09072166L,
- 0xb39a460aL, 0x6445c0ddL, 0x586cdecfL, 0x1c20c8aeL,
- 0x5bbef7ddL, 0x1b588d40L, 0xccd2017fL, 0x6bb4e3bbL,
- 0xdda26a7eL, 0x3a59ff45L, 0x3e350a44L, 0xbcb4cdd5L,
- 0x72eacea8L, 0xfa6484bbL, 0x8d6612aeL, 0xbf3c6f47L,
- 0xd29be463L, 0x542f5d9eL, 0xaec2771bL, 0xf64e6370L,
- 0x740e0d8dL, 0xe75b1357L, 0xf8721671L, 0xaf537d5dL,
- 0x4040cb08L, 0x4eb4e2ccL, 0x34d2466aL, 0x0115af84L,
- 0xe1b00428L, 0x95983a1dL, 0x06b89fb4L, 0xce6ea048L,
- 0x6f3f3b82L, 0x3520ab82L, 0x011a1d4bL, 0x277227f8L,
- 0x611560b1L, 0xe7933fdcL, 0xbb3a792bL, 0x344525bdL,
- 0xa08839e1L, 0x51ce794bL, 0x2f32c9b7L, 0xa01fbac9L,
- 0xe01cc87eL, 0xbcc7d1f6L, 0xcf0111c3L, 0xa1e8aac7L,
- 0x1a908749L, 0xd44fbd9aL, 0xd0dadecbL, 0xd50ada38L,
- 0x0339c32aL, 0xc6913667L, 0x8df9317cL, 0xe0b12b4fL,
- 0xf79e59b7L, 0x43f5bb3aL, 0xf2d519ffL, 0x27d9459cL,
- 0xbf97222cL, 0x15e6fc2aL, 0x0f91fc71L, 0x9b941525L,
- 0xfae59361L, 0xceb69cebL, 0xc2a86459L, 0x12baa8d1L,
- 0xb6c1075eL, 0xe3056a0cL, 0x10d25065L, 0xcb03a442L,
- 0xe0ec6e0eL, 0x1698db3bL, 0x4c98a0beL, 0x3278e964L,
- 0x9f1f9532L, 0xe0d392dfL, 0xd3a0342bL, 0x8971f21eL,
- 0x1b0a7441L, 0x4ba3348cL, 0xc5be7120L, 0xc37632d8L,
- 0xdf359f8dL, 0x9b992f2eL, 0xe60b6f47L, 0x0fe3f11dL,
- 0xe54cda54L, 0x1edad891L, 0xce6279cfL, 0xcd3e7e6fL,
- 0x1618b166L, 0xfd2c1d05L, 0x848fd2c5L, 0xf6fb2299L,
- 0xf523f357L, 0xa6327623L, 0x93a83531L, 0x56cccd02L,
- 0xacf08162L, 0x5a75ebb5L, 0x6e163697L, 0x88d273ccL,
- 0xde966292L, 0x81b949d0L, 0x4c50901bL, 0x71c65614L,
- 0xe6c6c7bdL, 0x327a140aL, 0x45e1d006L, 0xc3f27b9aL,
- 0xc9aa53fdL, 0x62a80f00L, 0xbb25bfe2L, 0x35bdd2f6L,
- 0x71126905L, 0xb2040222L, 0xb6cbcf7cL, 0xcd769c2bL,
- 0x53113ec0L, 0x1640e3d3L, 0x38abbd60L, 0x2547adf0L,
- 0xba38209cL, 0xf746ce76L, 0x77afa1c5L, 0x20756060L,
- 0x85cbfe4eL, 0x8ae88dd8L, 0x7aaaf9b0L, 0x4cf9aa7eL,
- 0x1948c25cL, 0x02fb8a8cL, 0x01c36ae4L, 0xd6ebe1f9L,
- 0x90d4f869L, 0xa65cdea0L, 0x3f09252dL, 0xc208e69fL,
- 0xb74e6132L, 0xce77e25bL, 0x578fdfe3L, 0x3ac372e6L,
+ 0xd1310ba6L, 0x98dfb5acL, 0x2ffd72dbL, 0xd01adfb7L,
+ 0xb8e1afedL, 0x6a267e96L, 0xba7c9045L, 0xf12c7f99L,
+ 0x24a19947L, 0xb3916cf7L, 0x0801f2e2L, 0x858efc16L,
+ 0x636920d8L, 0x71574e69L, 0xa458fea3L, 0xf4933d7eL,
+ 0x0d95748fL, 0x728eb658L, 0x718bcd58L, 0x82154aeeL,
+ 0x7b54a41dL, 0xc25a59b5L, 0x9c30d539L, 0x2af26013L,
+ 0xc5d1b023L, 0x286085f0L, 0xca417918L, 0xb8db38efL,
+ 0x8e79dcb0L, 0x603a180eL, 0x6c9e0e8bL, 0xb01e8a3eL,
+ 0xd71577c1L, 0xbd314b27L, 0x78af2fdaL, 0x55605c60L,
+ 0xe65525f3L, 0xaa55ab94L, 0x57489862L, 0x63e81440L,
+ 0x55ca396aL, 0x2aab10b6L, 0xb4cc5c34L, 0x1141e8ceL,
+ 0xa15486afL, 0x7c72e993L, 0xb3ee1411L, 0x636fbc2aL,
+ 0x2ba9c55dL, 0x741831f6L, 0xce5c3e16L, 0x9b87931eL,
+ 0xafd6ba33L, 0x6c24cf5cL, 0x7a325381L, 0x28958677L,
+ 0x3b8f4898L, 0x6b4bb9afL, 0xc4bfe81bL, 0x66282193L,
+ 0x61d809ccL, 0xfb21a991L, 0x487cac60L, 0x5dec8032L,
+ 0xef845d5dL, 0xe98575b1L, 0xdc262302L, 0xeb651b88L,
+ 0x23893e81L, 0xd396acc5L, 0x0f6d6ff3L, 0x83f44239L,
+ 0x2e0b4482L, 0xa4842004L, 0x69c8f04aL, 0x9e1f9b5eL,
+ 0x21c66842L, 0xf6e96c9aL, 0x670c9c61L, 0xabd388f0L,
+ 0x6a51a0d2L, 0xd8542f68L, 0x960fa728L, 0xab5133a3L,
+ 0x6eef0b6cL, 0x137a3be4L, 0xba3bf050L, 0x7efb2a98L,
+ 0xa1f1651dL, 0x39af0176L, 0x66ca593eL, 0x82430e88L,
+ 0x8cee8619L, 0x456f9fb4L, 0x7d84a5c3L, 0x3b8b5ebeL,
+ 0xe06f75d8L, 0x85c12073L, 0x401a449fL, 0x56c16aa6L,
+ 0x4ed3aa62L, 0x363f7706L, 0x1bfedf72L, 0x429b023dL,
+ 0x37d0d724L, 0xd00a1248L, 0xdb0fead3L, 0x49f1c09bL,
+ 0x075372c9L, 0x80991b7bL, 0x25d479d8L, 0xf6e8def7L,
+ 0xe3fe501aL, 0xb6794c3bL, 0x976ce0bdL, 0x04c006baL,
+ 0xc1a94fb6L, 0x409f60c4L, 0x5e5c9ec2L, 0x196a2463L,
+ 0x68fb6fafL, 0x3e6c53b5L, 0x1339b2ebL, 0x3b52ec6fL,
+ 0x6dfc511fL, 0x9b30952cL, 0xcc814544L, 0xaf5ebd09L,
+ 0xbee3d004L, 0xde334afdL, 0x660f2807L, 0x192e4bb3L,
+ 0xc0cba857L, 0x45c8740fL, 0xd20b5f39L, 0xb9d3fbdbL,
+ 0x5579c0bdL, 0x1a60320aL, 0xd6a100c6L, 0x402c7279L,
+ 0x679f25feL, 0xfb1fa3ccL, 0x8ea5e9f8L, 0xdb3222f8L,
+ 0x3c7516dfL, 0xfd616b15L, 0x2f501ec8L, 0xad0552abL,
+ 0x323db5faL, 0xfd238760L, 0x53317b48L, 0x3e00df82L,
+ 0x9e5c57bbL, 0xca6f8ca0L, 0x1a87562eL, 0xdf1769dbL,
+ 0xd542a8f6L, 0x287effc3L, 0xac6732c6L, 0x8c4f5573L,
+ 0x695b27b0L, 0xbbca58c8L, 0xe1ffa35dL, 0xb8f011a0L,
+ 0x10fa3d98L, 0xfd2183b8L, 0x4afcb56cL, 0x2dd1d35bL,
+ 0x9a53e479L, 0xb6f84565L, 0xd28e49bcL, 0x4bfb9790L,
+ 0xe1ddf2daL, 0xa4cb7e33L, 0x62fb1341L, 0xcee4c6e8L,
+ 0xef20cadaL, 0x36774c01L, 0xd07e9efeL, 0x2bf11fb4L,
+ 0x95dbda4dL, 0xae909198L, 0xeaad8e71L, 0x6b93d5a0L,
+ 0xd08ed1d0L, 0xafc725e0L, 0x8e3c5b2fL, 0x8e7594b7L,
+ 0x8ff6e2fbL, 0xf2122b64L, 0x8888b812L, 0x900df01cL,
+ 0x4fad5ea0L, 0x688fc31cL, 0xd1cff191L, 0xb3a8c1adL,
+ 0x2f2f2218L, 0xbe0e1777L, 0xea752dfeL, 0x8b021fa1L,
+ 0xe5a0cc0fL, 0xb56f74e8L, 0x18acf3d6L, 0xce89e299L,
+ 0xb4a84fe0L, 0xfd13e0b7L, 0x7cc43b81L, 0xd2ada8d9L,
+ 0x165fa266L, 0x80957705L, 0x93cc7314L, 0x211a1477L,
+ 0xe6ad2065L, 0x77b5fa86L, 0xc75442f5L, 0xfb9d35cfL,
+ 0xebcdaf0cL, 0x7b3e89a0L, 0xd6411bd3L, 0xae1e7e49L,
+ 0x00250e2dL, 0x2071b35eL, 0x226800bbL, 0x57b8e0afL,
+ 0x2464369bL, 0xf009b91eL, 0x5563911dL, 0x59dfa6aaL,
+ 0x78c14389L, 0xd95a537fL, 0x207d5ba2L, 0x02e5b9c5L,
+ 0x83260376L, 0x6295cfa9L, 0x11c81968L, 0x4e734a41L,
+ 0xb3472dcaL, 0x7b14a94aL, 0x1b510052L, 0x9a532915L,
+ 0xd60f573fL, 0xbc9bc6e4L, 0x2b60a476L, 0x81e67400L,
+ 0x08ba6fb5L, 0x571be91fL, 0xf296ec6bL, 0x2a0dd915L,
+ 0xb6636521L, 0xe7b9f9b6L, 0xff34052eL, 0xc5855664L,
+ 0x53b02d5dL, 0xa99f8fa1L, 0x08ba4799L, 0x6e85076aL,
+ 0x4b7a70e9L, 0xb5b32944L, 0xdb75092eL, 0xc4192623L,
+ 0xad6ea6b0L, 0x49a7df7dL, 0x9cee60b8L, 0x8fedb266L,
+ 0xecaa8c71L, 0x699a17ffL, 0x5664526cL, 0xc2b19ee1L,
+ 0x193602a5L, 0x75094c29L, 0xa0591340L, 0xe4183a3eL,
+ 0x3f54989aL, 0x5b429d65L, 0x6b8fe4d6L, 0x99f73fd6L,
+ 0xa1d29c07L, 0xefe830f5L, 0x4d2d38e6L, 0xf0255dc1L,
+ 0x4cdd2086L, 0x8470eb26L, 0x6382e9c6L, 0x021ecc5eL,
+ 0x09686b3fL, 0x3ebaefc9L, 0x3c971814L, 0x6b6a70a1L,
+ 0x687f3584L, 0x52a0e286L, 0xb79c5305L, 0xaa500737L,
+ 0x3e07841cL, 0x7fdeae5cL, 0x8e7d44ecL, 0x5716f2b8L,
+ 0xb03ada37L, 0xf0500c0dL, 0xf01c1f04L, 0x0200b3ffL,
+ 0xae0cf51aL, 0x3cb574b2L, 0x25837a58L, 0xdc0921bdL,
+ 0xd19113f9L, 0x7ca92ff6L, 0x94324773L, 0x22f54701L,
+ 0x3ae5e581L, 0x37c2dadcL, 0xc8b57634L, 0x9af3dda7L,
+ 0xa9446146L, 0x0fd0030eL, 0xecc8c73eL, 0xa4751e41L,
+ 0xe238cd99L, 0x3bea0e2fL, 0x3280bba1L, 0x183eb331L,
+ 0x4e548b38L, 0x4f6db908L, 0x6f420d03L, 0xf60a04bfL,
+ 0x2cb81290L, 0x24977c79L, 0x5679b072L, 0xbcaf89afL,
+ 0xde9a771fL, 0xd9930810L, 0xb38bae12L, 0xdccf3f2eL,
+ 0x5512721fL, 0x2e6b7124L, 0x501adde6L, 0x9f84cd87L,
+ 0x7a584718L, 0x7408da17L, 0xbc9f9abcL, 0xe94b7d8cL,
+ 0xec7aec3aL, 0xdb851dfaL, 0x63094366L, 0xc464c3d2L,
+ 0xef1c1847L, 0x3215d908L, 0xdd433b37L, 0x24c2ba16L,
+ 0x12a14d43L, 0x2a65c451L, 0x50940002L, 0x133ae4ddL,
+ 0x71dff89eL, 0x10314e55L, 0x81ac77d6L, 0x5f11199bL,
+ 0x043556f1L, 0xd7a3c76bL, 0x3c11183bL, 0x5924a509L,
+ 0xf28fe6edL, 0x97f1fbfaL, 0x9ebabf2cL, 0x1e153c6eL,
+ 0x86e34570L, 0xeae96fb1L, 0x860e5e0aL, 0x5a3e2ab3L,
+ 0x771fe71cL, 0x4e3d06faL, 0x2965dcb9L, 0x99e71d0fL,
+ 0x803e89d6L, 0x5266c825L, 0x2e4cc978L, 0x9c10b36aL,
+ 0xc6150ebaL, 0x94e2ea78L, 0xa5fc3c53L, 0x1e0a2df4L,
+ 0xf2f74ea7L, 0x361d2b3dL, 0x1939260fL, 0x19c27960L,
+ 0x5223a708L, 0xf71312b6L, 0xebadfe6eL, 0xeac31f66L,
+ 0xe3bc4595L, 0xa67bc883L, 0xb17f37d1L, 0x018cff28L,
+ 0xc332ddefL, 0xbe6c5aa5L, 0x65582185L, 0x68ab9802L,
+ 0xeecea50fL, 0xdb2f953bL, 0x2aef7dadL, 0x5b6e2f84L,
+ 0x1521b628L, 0x29076170L, 0xecdd4775L, 0x619f1510L,
+ 0x13cca830L, 0xeb61bd96L, 0x0334fe1eL, 0xaa0363cfL,
+ 0xb5735c90L, 0x4c70a239L, 0xd59e9e0bL, 0xcbaade14L,
+ 0xeecc86bcL, 0x60622ca7L, 0x9cab5cabL, 0xb2f3846eL,
+ 0x648b1eafL, 0x19bdf0caL, 0xa02369b9L, 0x655abb50L,
+ 0x40685a32L, 0x3c2ab4b3L, 0x319ee9d5L, 0xc021b8f7L,
+ 0x9b540b19L, 0x875fa099L, 0x95f7997eL, 0x623d7da8L,
+ 0xf837889aL, 0x97e32d77L, 0x11ed935fL, 0x16681281L,
+ 0x0e358829L, 0xc7e61fd6L, 0x96dedfa1L, 0x7858ba99L,
+ 0x57f584a5L, 0x1b227263L, 0x9b83c3ffL, 0x1ac24696L,
+ 0xcdb30aebL, 0x532e3054L, 0x8fd948e4L, 0x6dbc3128L,
+ 0x58ebf2efL, 0x34c6ffeaL, 0xfe28ed61L, 0xee7c3c73L,
+ 0x5d4a14d9L, 0xe864b7e3L, 0x42105d14L, 0x203e13e0L,
+ 0x45eee2b6L, 0xa3aaabeaL, 0xdb6c4f15L, 0xfacb4fd0L,
+ 0xc742f442L, 0xef6abbb5L, 0x654f3b1dL, 0x41cd2105L,
+ 0xd81e799eL, 0x86854dc7L, 0xe44b476aL, 0x3d816250L,
+ 0xcf62a1f2L, 0x5b8d2646L, 0xfc8883a0L, 0xc1c7b6a3L,
+ 0x7f1524c3L, 0x69cb7492L, 0x47848a0bL, 0x5692b285L,
+ 0x095bbf00L, 0xad19489dL, 0x1462b174L, 0x23820e00L,
+ 0x58428d2aL, 0x0c55f5eaL, 0x1dadf43eL, 0x233f7061L,
+ 0x3372f092L, 0x8d937e41L, 0xd65fecf1L, 0x6c223bdbL,
+ 0x7cde3759L, 0xcbee7460L, 0x4085f2a7L, 0xce77326eL,
+ 0xa6078084L, 0x19f8509eL, 0xe8efd855L, 0x61d99735L,
+ 0xa969a7aaL, 0xc50c06c2L, 0x5a04abfcL, 0x800bcadcL,
+ 0x9e447a2eL, 0xc3453484L, 0xfdd56705L, 0x0e1e9ec9L,
+ 0xdb73dbd3L, 0x105588cdL, 0x675fda79L, 0xe3674340L,
+ 0xc5c43465L, 0x713e38d8L, 0x3d28f89eL, 0xf16dff20L,
+ 0x153e21e7L, 0x8fb03d4aL, 0xe6e39f2bL, 0xdb83adf7L,
+ 0xe93d5a68L, 0x948140f7L, 0xf64c261cL, 0x94692934L,
+ 0x411520f7L, 0x7602d4f7L, 0xbcf46b2eL, 0xd4a20068L,
+ 0xd4082471L, 0x3320f46aL, 0x43b7d4b7L, 0x500061afL,
+ 0x1e39f62eL, 0x97244546L, 0x14214f74L, 0xbf8b8840L,
+ 0x4d95fc1dL, 0x96b591afL, 0x70f4ddd3L, 0x66a02f45L,
+ 0xbfbc09ecL, 0x03bd9785L, 0x7fac6dd0L, 0x31cb8504L,
+ 0x96eb27b3L, 0x55fd3941L, 0xda2547e6L, 0xabca0a9aL,
+ 0x28507825L, 0x530429f4L, 0x0a2c86daL, 0xe9b66dfbL,
+ 0x68dc1462L, 0xd7486900L, 0x680ec0a4L, 0x27a18deeL,
+ 0x4f3ffea2L, 0xe887ad8cL, 0xb58ce006L, 0x7af4d6b6L,
+ 0xaace1e7cL, 0xd3375fecL, 0xce78a399L, 0x406b2a42L,
+ 0x20fe9e35L, 0xd9f385b9L, 0xee39d7abL, 0x3b124e8bL,
+ 0x1dc9faf7L, 0x4b6d1856L, 0x26a36631L, 0xeae397b2L,
+ 0x3a6efa74L, 0xdd5b4332L, 0x6841e7f7L, 0xca7820fbL,
+ 0xfb0af54eL, 0xd8feb397L, 0x454056acL, 0xba489527L,
+ 0x55533a3aL, 0x20838d87L, 0xfe6ba9b7L, 0xd096954bL,
+ 0x55a867bcL, 0xa1159a58L, 0xcca92963L, 0x99e1db33L,
+ 0xa62a4a56L, 0x3f3125f9L, 0x5ef47e1cL, 0x9029317cL,
+ 0xfdf8e802L, 0x04272f70L, 0x80bb155cL, 0x05282ce3L,
+ 0x95c11548L, 0xe4c66d22L, 0x48c1133fL, 0xc70f86dcL,
+ 0x07f9c9eeL, 0x41041f0fL, 0x404779a4L, 0x5d886e17L,
+ 0x325f51ebL, 0xd59bc0d1L, 0xf2bcc18fL, 0x41113564L,
+ 0x257b7834L, 0x602a9c60L, 0xdff8e8a3L, 0x1f636c1bL,
+ 0x0e12b4c2L, 0x02e1329eL, 0xaf664fd1L, 0xcad18115L,
+ 0x6b2395e0L, 0x333e92e1L, 0x3b240b62L, 0xeebeb922L,
+ 0x85b2a20eL, 0xe6ba0d99L, 0xde720c8cL, 0x2da2f728L,
+ 0xd0127845L, 0x95b794fdL, 0x647d0862L, 0xe7ccf5f0L,
+ 0x5449a36fL, 0x877d48faL, 0xc39dfd27L, 0xf33e8d1eL,
+ 0x0a476341L, 0x992eff74L, 0x3a6f6eabL, 0xf4f8fd37L,
+ 0xa812dc60L, 0xa1ebddf8L, 0x991be14cL, 0xdb6e6b0dL,
+ 0xc67b5510L, 0x6d672c37L, 0x2765d43bL, 0xdcd0e804L,
+ 0xf1290dc7L, 0xcc00ffa3L, 0xb5390f92L, 0x690fed0bL,
+ 0x667b9ffbL, 0xcedb7d9cL, 0xa091cf0bL, 0xd9155ea3L,
+ 0xbb132f88L, 0x515bad24L, 0x7b9479bfL, 0x763bd6ebL,
+ 0x37392eb3L, 0xcc115979L, 0x8026e297L, 0xf42e312dL,
+ 0x6842ada7L, 0xc66a2b3bL, 0x12754cccL, 0x782ef11cL,
+ 0x6a124237L, 0xb79251e7L, 0x06a1bbe6L, 0x4bfb6350L,
+ 0x1a6b1018L, 0x11caedfaL, 0x3d25bdd8L, 0xe2e1c3c9L,
+ 0x44421659L, 0x0a121386L, 0xd90cec6eL, 0xd5abea2aL,
+ 0x64af674eL, 0xda86a85fL, 0xbebfe988L, 0x64e4c3feL,
+ 0x9dbc8057L, 0xf0f7c086L, 0x60787bf8L, 0x6003604dL,
+ 0xd1fd8346L, 0xf6381fb0L, 0x7745ae04L, 0xd736fcccL,
+ 0x83426b33L, 0xf01eab71L, 0xb0804187L, 0x3c005e5fL,
+ 0x77a057beL, 0xbde8ae24L, 0x55464299L, 0xbf582e61L,
+ 0x4e58f48fL, 0xf2ddfda2L, 0xf474ef38L, 0x8789bdc2L,
+ 0x5366f9c3L, 0xc8b38e74L, 0xb475f255L, 0x46fcd9b9L,
+ 0x7aeb2661L, 0x8b1ddf84L, 0x846a0e79L, 0x915f95e2L,
+ 0x466e598eL, 0x20b45770L, 0x8cd55591L, 0xc902de4cL,
+ 0xb90bace1L, 0xbb8205d0L, 0x11a86248L, 0x7574a99eL,
+ 0xb77f19b6L, 0xe0a9dc09L, 0x662d09a1L, 0xc4324633L,
+ 0xe85a1f02L, 0x09f0be8cL, 0x4a99a025L, 0x1d6efe10L,
+ 0x1ab93d1dL, 0x0ba5a4dfL, 0xa186f20fL, 0x2868f169L,
+ 0xdcb7da83L, 0x573906feL, 0xa1e2ce9bL, 0x4fcd7f52L,
+ 0x50115e01L, 0xa70683faL, 0xa002b5c4L, 0x0de6d027L,
+ 0x9af88c27L, 0x773f8641L, 0xc3604c06L, 0x61a806b5L,
+ 0xf0177a28L, 0xc0f586e0L, 0x006058aaL, 0x30dc7d62L,
+ 0x11e69ed7L, 0x2338ea63L, 0x53c2dd94L, 0xc2c21634L,
+ 0xbbcbee56L, 0x90bcb6deL, 0xebfc7da1L, 0xce591d76L,
+ 0x6f05e409L, 0x4b7c0188L, 0x39720a3dL, 0x7c927c24L,
+ 0x86e3725fL, 0x724d9db9L, 0x1ac15bb4L, 0xd39eb8fcL,
+ 0xed545578L, 0x08fca5b5L, 0xd83d7cd3L, 0x4dad0fc4L,
+ 0x1e50ef5eL, 0xb161e6f8L, 0xa28514d9L, 0x6c51133cL,
+ 0x6fd5c7e7L, 0x56e14ec4L, 0x362abfceL, 0xddc6c837L,
+ 0xd79a3234L, 0x92638212L, 0x670efa8eL, 0x406000e0L,
+ 0x3a39ce37L, 0xd3faf5cfL, 0xabc27737L, 0x5ac52d1bL,
+ 0x5cb0679eL, 0x4fa33742L, 0xd3822740L, 0x99bc9bbeL,
+ 0xd5118e9dL, 0xbf0f7315L, 0xd62d1c7eL, 0xc700c47bL,
+ 0xb78c1b6bL, 0x21a19045L, 0xb26eb1beL, 0x6a366eb4L,
+ 0x5748ab2fL, 0xbc946e79L, 0xc6a376d2L, 0x6549c2c8L,
+ 0x530ff8eeL, 0x468dde7dL, 0xd5730a1dL, 0x4cd04dc6L,
+ 0x2939bbdbL, 0xa9ba4650L, 0xac9526e8L, 0xbe5ee304L,
+ 0xa1fad5f0L, 0x6a2d519aL, 0x63ef8ce2L, 0x9a86ee22L,
+ 0xc089c2b8L, 0x43242ef6L, 0xa51e03aaL, 0x9cf2d0a4L,
+ 0x83c061baL, 0x9be96a4dL, 0x8fe51550L, 0xba645bd6L,
+ 0x2826a2f9L, 0xa73a3ae1L, 0x4ba99586L, 0xef5562e9L,
+ 0xc72fefd3L, 0xf752f7daL, 0x3f046f69L, 0x77fa0a59L,
+ 0x80e4a915L, 0x87b08601L, 0x9b09e6adL, 0x3b3ee593L,
+ 0xe990fd5aL, 0x9e34d797L, 0x2cf0b7d9L, 0x022b8b51L,
+ 0x96d5ac3aL, 0x017da67dL, 0xd1cf3ed6L, 0x7c7d2d28L,
+ 0x1f9f25cfL, 0xadf2b89bL, 0x5ad6b472L, 0x5a88f54cL,
+ 0xe029ac71L, 0xe019a5e6L, 0x47b0acfdL, 0xed93fa9bL,
+ 0xe8d3c48dL, 0x283b57ccL, 0xf8d56629L, 0x79132e28L,
+ 0x785f0191L, 0xed756055L, 0xf7960e44L, 0xe3d35e8cL,
+ 0x15056dd4L, 0x88f46dbaL, 0x03a16125L, 0x0564f0bdL,
+ 0xc3eb9e15L, 0x3c9057a2L, 0x97271aecL, 0xa93a072aL,
+ 0x1b3f6d9bL, 0x1e6321f5L, 0xf59c66fbL, 0x26dcf319L,
+ 0x7533d928L, 0xb155fdf5L, 0x03563482L, 0x8aba3cbbL,
+ 0x28517711L, 0xc20ad9f8L, 0xabcc5167L, 0xccad925fL,
+ 0x4de81751L, 0x3830dc8eL, 0x379d5862L, 0x9320f991L,
+ 0xea7a90c2L, 0xfb3e7bceL, 0x5121ce64L, 0x774fbe32L,
+ 0xa8b6e37eL, 0xc3293d46L, 0x48de5369L, 0x6413e680L,
+ 0xa2ae0810L, 0xdd6db224L, 0x69852dfdL, 0x09072166L,
+ 0xb39a460aL, 0x6445c0ddL, 0x586cdecfL, 0x1c20c8aeL,
+ 0x5bbef7ddL, 0x1b588d40L, 0xccd2017fL, 0x6bb4e3bbL,
+ 0xdda26a7eL, 0x3a59ff45L, 0x3e350a44L, 0xbcb4cdd5L,
+ 0x72eacea8L, 0xfa6484bbL, 0x8d6612aeL, 0xbf3c6f47L,
+ 0xd29be463L, 0x542f5d9eL, 0xaec2771bL, 0xf64e6370L,
+ 0x740e0d8dL, 0xe75b1357L, 0xf8721671L, 0xaf537d5dL,
+ 0x4040cb08L, 0x4eb4e2ccL, 0x34d2466aL, 0x0115af84L,
+ 0xe1b00428L, 0x95983a1dL, 0x06b89fb4L, 0xce6ea048L,
+ 0x6f3f3b82L, 0x3520ab82L, 0x011a1d4bL, 0x277227f8L,
+ 0x611560b1L, 0xe7933fdcL, 0xbb3a792bL, 0x344525bdL,
+ 0xa08839e1L, 0x51ce794bL, 0x2f32c9b7L, 0xa01fbac9L,
+ 0xe01cc87eL, 0xbcc7d1f6L, 0xcf0111c3L, 0xa1e8aac7L,
+ 0x1a908749L, 0xd44fbd9aL, 0xd0dadecbL, 0xd50ada38L,
+ 0x0339c32aL, 0xc6913667L, 0x8df9317cL, 0xe0b12b4fL,
+ 0xf79e59b7L, 0x43f5bb3aL, 0xf2d519ffL, 0x27d9459cL,
+ 0xbf97222cL, 0x15e6fc2aL, 0x0f91fc71L, 0x9b941525L,
+ 0xfae59361L, 0xceb69cebL, 0xc2a86459L, 0x12baa8d1L,
+ 0xb6c1075eL, 0xe3056a0cL, 0x10d25065L, 0xcb03a442L,
+ 0xe0ec6e0eL, 0x1698db3bL, 0x4c98a0beL, 0x3278e964L,
+ 0x9f1f9532L, 0xe0d392dfL, 0xd3a0342bL, 0x8971f21eL,
+ 0x1b0a7441L, 0x4ba3348cL, 0xc5be7120L, 0xc37632d8L,
+ 0xdf359f8dL, 0x9b992f2eL, 0xe60b6f47L, 0x0fe3f11dL,
+ 0xe54cda54L, 0x1edad891L, 0xce6279cfL, 0xcd3e7e6fL,
+ 0x1618b166L, 0xfd2c1d05L, 0x848fd2c5L, 0xf6fb2299L,
+ 0xf523f357L, 0xa6327623L, 0x93a83531L, 0x56cccd02L,
+ 0xacf08162L, 0x5a75ebb5L, 0x6e163697L, 0x88d273ccL,
+ 0xde966292L, 0x81b949d0L, 0x4c50901bL, 0x71c65614L,
+ 0xe6c6c7bdL, 0x327a140aL, 0x45e1d006L, 0xc3f27b9aL,
+ 0xc9aa53fdL, 0x62a80f00L, 0xbb25bfe2L, 0x35bdd2f6L,
+ 0x71126905L, 0xb2040222L, 0xb6cbcf7cL, 0xcd769c2bL,
+ 0x53113ec0L, 0x1640e3d3L, 0x38abbd60L, 0x2547adf0L,
+ 0xba38209cL, 0xf746ce76L, 0x77afa1c5L, 0x20756060L,
+ 0x85cbfe4eL, 0x8ae88dd8L, 0x7aaaf9b0L, 0x4cf9aa7eL,
+ 0x1948c25cL, 0x02fb8a8cL, 0x01c36ae4L, 0xd6ebe1f9L,
+ 0x90d4f869L, 0xa65cdea0L, 0x3f09252dL, 0xc208e69fL,
+ 0xb74e6132L, 0xce77e25bL, 0x578fdfe3L, 0x3ac372e6L,
};
-
-
blob - c54541c58b96c42446f927aac644aa700869c413
blob + f14d2ea9049fe3b67feee74d6a0deed980a701f3
--- src/libsec/port/des.c
+++ src/libsec/port/des.c
^ fetch(5, v1, 8)
^ fetch(7, v1, 0);
key += keystep;
-
+
v0 = key[0];
v0 ^= (left >> 1) | (left << 31);
right ^= fetch(0, v0, 24)
^ fetch(5, v1, 8)
^ fetch(7, v1, 0);
key += keystep;
-
+
v0 = key[0];
v0 ^= (left >> 1) | (left << 31);
right ^= fetch(0, v0, 24)
static uchar parity[128] =
{
- 0x01, 0x02, 0x04, 0x07, 0x08, 0x0b, 0x0d, 0x0e,
- 0x10, 0x13, 0x15, 0x16, 0x19, 0x1a, 0x1c, 0x1f,
- 0x20, 0x23, 0x25, 0x26, 0x29, 0x2a, 0x2c, 0x2f,
- 0x31, 0x32, 0x34, 0x37, 0x38, 0x3b, 0x3d, 0x3e,
- 0x40, 0x43, 0x45, 0x46, 0x49, 0x4a, 0x4c, 0x4f,
- 0x51, 0x52, 0x54, 0x57, 0x58, 0x5b, 0x5d, 0x5e,
- 0x61, 0x62, 0x64, 0x67, 0x68, 0x6b, 0x6d, 0x6e,
- 0x70, 0x73, 0x75, 0x76, 0x79, 0x7a, 0x7c, 0x7f,
- 0x80, 0x83, 0x85, 0x86, 0x89, 0x8a, 0x8c, 0x8f,
- 0x91, 0x92, 0x94, 0x97, 0x98, 0x9b, 0x9d, 0x9e,
- 0xa1, 0xa2, 0xa4, 0xa7, 0xa8, 0xab, 0xad, 0xae,
- 0xb0, 0xb3, 0xb5, 0xb6, 0xb9, 0xba, 0xbc, 0xbf,
- 0xc1, 0xc2, 0xc4, 0xc7, 0xc8, 0xcb, 0xcd, 0xce,
- 0xd0, 0xd3, 0xd5, 0xd6, 0xd9, 0xda, 0xdc, 0xdf,
- 0xe0, 0xe3, 0xe5, 0xe6, 0xe9, 0xea, 0xec, 0xef,
+ 0x01, 0x02, 0x04, 0x07, 0x08, 0x0b, 0x0d, 0x0e,
+ 0x10, 0x13, 0x15, 0x16, 0x19, 0x1a, 0x1c, 0x1f,
+ 0x20, 0x23, 0x25, 0x26, 0x29, 0x2a, 0x2c, 0x2f,
+ 0x31, 0x32, 0x34, 0x37, 0x38, 0x3b, 0x3d, 0x3e,
+ 0x40, 0x43, 0x45, 0x46, 0x49, 0x4a, 0x4c, 0x4f,
+ 0x51, 0x52, 0x54, 0x57, 0x58, 0x5b, 0x5d, 0x5e,
+ 0x61, 0x62, 0x64, 0x67, 0x68, 0x6b, 0x6d, 0x6e,
+ 0x70, 0x73, 0x75, 0x76, 0x79, 0x7a, 0x7c, 0x7f,
+ 0x80, 0x83, 0x85, 0x86, 0x89, 0x8a, 0x8c, 0x8f,
+ 0x91, 0x92, 0x94, 0x97, 0x98, 0x9b, 0x9d, 0x9e,
+ 0xa1, 0xa2, 0xa4, 0xa7, 0xa8, 0xab, 0xad, 0xae,
+ 0xb0, 0xb3, 0xb5, 0xb6, 0xb9, 0xba, 0xbc, 0xbf,
+ 0xc1, 0xc2, 0xc4, 0xc7, 0xc8, 0xcb, 0xcd, 0xce,
+ 0xd0, 0xd3, 0xd5, 0xd6, 0xd9, 0xda, 0xdc, 0xdf,
+ 0xe0, 0xe3, 0xe5, 0xe6, 0xe9, 0xea, 0xec, 0xef,
0xf1, 0xf2, 0xf4, 0xf7, 0xf8, 0xfb, 0xfd, 0xfe,
};
uchar k64[8];
des56to64(key, k64);
- des_key_setup(k64, ek);
+ des_key_setup(k64, ek);
}
blob - a03d7044e754b0cc419c4e6822ee569726793b0f
blob + cfd2ce966adde05328603a6b8cb61fbca9dd725e
--- src/libsec/port/des3ECB.c
+++ src/libsec/port/des3ECB.c
triple_block_cipher(s->expanded, p, DES3EDE);
p += 8;
}
-
+
if(len > 0){
for (i=0; i<8; i++)
tmp[i] = i;
triple_block_cipher(s->expanded, p, DES3DED);
p += 8;
}
-
+
if(len > 0){
for (i=0; i<8; i++)
tmp[i] = i;
blob - 0bc3414193cecfa278567ac11bef186dcf962c93
blob + b38ae4fd736f6ad77ef30296b10e4bb0ffa64cd6
--- src/libsec/port/desECB.c
+++ src/libsec/port/desECB.c
block_cipher(s->expanded, p, 0);
p += 8;
}
-
+
if(len > 0){
for (i=0; i<8; i++)
tmp[i] = i;
block_cipher(s->expanded, p, 1);
p += 8;
}
-
+
if(len > 0){
for (i=0; i<8; i++)
tmp[i] = i;
blob - 2457880069c20fc72d062e2e5db2c0f341ac42c7
blob + 31d4bdd57a4432eeb2f6c778411e8a70b5643e3e
--- src/libsec/port/egdecrypt.c
+++ src/libsec/port/egdecrypt.c
delta = mpnew(0);
mpright(in, shift, gamma);
mpleft(gamma, shift, delta);
- mpsub(in, delta, delta);
+ mpsub(in, delta, delta);
mpexp(gamma, priv->secret, p, out);
mpinvert(out, p, gamma);
mpmul(gamma, delta, out);
blob - 14571277426c78edf2039d2260014fac1e7b41c5
blob + ca3c0195423ba54c7e90d1d7e9f70322287d8894
--- src/libsec/port/fastrand.c
+++ src/libsec/port/fastrand.c
#include <libc.h>
#include <libsec.h>
-/*
+/*
* use the X917 random number generator to create random
* numbers (faster than truerand() but not as random).
*/
fastrand(void)
{
ulong x;
-
+
genrandom((uchar*)&x, sizeof x);
return x;
}
blob - dc4a8c2a87569c38dd4513e3492137cb2f40a245
blob + 6fb5c0026172667d42ef50f7a6a393777278b92a
--- src/libsec/port/md4.c
+++ src/libsec/port/md4.c
static MD4Table tab[] =
{
/* round 1 */
-/*[0]*/ { 0, S11},
- { 1, S12},
- { 2, S13},
- { 3, S14},
- { 4, S11},
- { 5, S12},
- { 6, S13},
- { 7, S14},
- { 8, S11},
- { 9, S12},
- { 10, S13},
- { 11, S14},
- { 12, S11},
- { 13, S12},
- { 14, S13},
+/*[0]*/ { 0, S11},
+ { 1, S12},
+ { 2, S13},
+ { 3, S14},
+ { 4, S11},
+ { 5, S12},
+ { 6, S13},
+ { 7, S14},
+ { 8, S11},
+ { 9, S12},
+ { 10, S13},
+ { 11, S14},
+ { 12, S11},
+ { 13, S12},
+ { 14, S13},
{ 15, S14},
/* round 2 */
-/*[16]*/{ 0, S21},
- { 4, S22},
- { 8, S23},
- { 12, S24},
- { 1, S21},
- { 5, S22},
- { 9, S23},
- { 13, S24},
- { 2, S21},
- { 6, S22},
- { 10, S23},
- { 14, S24},
- { 3, S21},
- { 7, S22},
- { 11, S23},
+/*[16]*/{ 0, S21},
+ { 4, S22},
+ { 8, S23},
+ { 12, S24},
+ { 1, S21},
+ { 5, S22},
+ { 9, S23},
+ { 13, S24},
+ { 2, S21},
+ { 6, S22},
+ { 10, S23},
+ { 14, S24},
+ { 3, S21},
+ { 7, S22},
+ { 11, S23},
{ 15, S24},
/* round 3 */
-/*[32]*/{ 0, S31},
- { 8, S32},
- { 4, S33},
- { 12, S34},
- { 2, S31},
- { 10, S32},
- { 6, S33},
- { 14, S34},
- { 1, S31},
- { 9, S32},
- { 5, S33},
- { 13, S34},
- { 3, S31},
- { 11, S32},
- { 7, S33},
- { 15, S34},
+/*[32]*/{ 0, S31},
+ { 8, S32},
+ { 4, S33},
+ { 12, S34},
+ { 2, S31},
+ { 10, S32},
+ { 6, S33},
+ { 14, S34},
+ { 1, S31},
+ { 9, S32},
+ { 5, S33},
+ { 13, S34},
+ { 3, S31},
+ { 11, S32},
+ { 7, S33},
+ { 15, S34},
};
static void encode(uchar*, u32int*, ulong);
d = s->state[3];
decode(x, p, 64);
-
+
for(i = 0; i < 48; i++){
t = tab + i;
switch(i>>4){
}
a += x[t->x];
a = (a << t->rot) | (a >> (32 - t->rot));
-
+
/* rotate variables */
tmp = d;
d = c;
blob - 07fe2237978d2d603370b69b3d22ab4af39c3d39
blob + 4183f929bf3bfe01a06f649175cf2951a8cf65b1
--- src/libsec/port/md5block.c
+++ src/libsec/port/md5block.c
static u32int md5tab[] =
{
/* round 1 */
-/*[0]*/ 0xd76aa478,
- 0xe8c7b756,
- 0x242070db,
- 0xc1bdceee,
- 0xf57c0faf,
- 0x4787c62a,
- 0xa8304613,
- 0xfd469501,
- 0x698098d8,
- 0x8b44f7af,
- 0xffff5bb1,
- 0x895cd7be,
- 0x6b901122,
- 0xfd987193,
- 0xa679438e,
+/*[0]*/ 0xd76aa478,
+ 0xe8c7b756,
+ 0x242070db,
+ 0xc1bdceee,
+ 0xf57c0faf,
+ 0x4787c62a,
+ 0xa8304613,
+ 0xfd469501,
+ 0x698098d8,
+ 0x8b44f7af,
+ 0xffff5bb1,
+ 0x895cd7be,
+ 0x6b901122,
+ 0xfd987193,
+ 0xa679438e,
0x49b40821,
/* round 2 */
-/*[16]*/0xf61e2562,
- 0xc040b340,
- 0x265e5a51,
- 0xe9b6c7aa,
- 0xd62f105d,
- 0x2441453,
- 0xd8a1e681,
- 0xe7d3fbc8,
- 0x21e1cde6,
- 0xc33707d6,
- 0xf4d50d87,
- 0x455a14ed,
- 0xa9e3e905,
- 0xfcefa3f8,
- 0x676f02d9,
+/*[16]*/0xf61e2562,
+ 0xc040b340,
+ 0x265e5a51,
+ 0xe9b6c7aa,
+ 0xd62f105d,
+ 0x2441453,
+ 0xd8a1e681,
+ 0xe7d3fbc8,
+ 0x21e1cde6,
+ 0xc33707d6,
+ 0xf4d50d87,
+ 0x455a14ed,
+ 0xa9e3e905,
+ 0xfcefa3f8,
+ 0x676f02d9,
0x8d2a4c8a,
/* round 3 */
-/*[32]*/0xfffa3942,
- 0x8771f681,
- 0x6d9d6122,
- 0xfde5380c,
- 0xa4beea44,
- 0x4bdecfa9,
- 0xf6bb4b60,
- 0xbebfbc70,
- 0x289b7ec6,
- 0xeaa127fa,
- 0xd4ef3085,
- 0x4881d05,
- 0xd9d4d039,
- 0xe6db99e5,
- 0x1fa27cf8,
- 0xc4ac5665,
+/*[32]*/0xfffa3942,
+ 0x8771f681,
+ 0x6d9d6122,
+ 0xfde5380c,
+ 0xa4beea44,
+ 0x4bdecfa9,
+ 0xf6bb4b60,
+ 0xbebfbc70,
+ 0x289b7ec6,
+ 0xeaa127fa,
+ 0xd4ef3085,
+ 0x4881d05,
+ 0xd9d4d039,
+ 0xe6db99e5,
+ 0x1fa27cf8,
+ 0xc4ac5665,
/* round 4 */
-/*[48]*/0xf4292244,
- 0x432aff97,
- 0xab9423a7,
- 0xfc93a039,
- 0x655b59c3,
- 0x8f0ccc92,
- 0xffeff47d,
- 0x85845dd1,
- 0x6fa87e4f,
- 0xfe2ce6e0,
- 0xa3014314,
- 0x4e0811a1,
- 0xf7537e82,
- 0xbd3af235,
- 0x2ad7d2bb,
- 0xeb86d391,
+/*[48]*/0xf4292244,
+ 0x432aff97,
+ 0xab9423a7,
+ 0xfc93a039,
+ 0x655b59c3,
+ 0x8f0ccc92,
+ 0xffeff47d,
+ 0x85845dd1,
+ 0x6fa87e4f,
+ 0xfe2ce6e0,
+ 0xa3014314,
+ 0x4e0811a1,
+ 0xf7537e82,
+ 0xbd3af235,
+ 0x2ad7d2bb,
+ 0xeb86d391,
};
static void decode(u32int*, uchar*, ulong);
d = s[3];
decode(x, p, 64);
-
+
t = md5tab;
sh = 0;
for(; sh != 16; t += 4){
blob - 3ba77003d400a3929f6acc9b6972622237d089a8
blob + a4d640dd7d04d2e5e6afa6976a59c85371c82b3d
--- src/libsec/port/nfastrand.c
+++ src/libsec/port/nfastrand.c
nfastrand(ulong n)
{
ulong m, r;
-
+
/*
* set m to the maximum multiple of n <= 2^31-1
* so we want a random number < m.
blob - b8ddf6d2f74b06a2dd2e9a5861dbba5f95384a33
blob + 69a5a9d3e6e2bfeeb96cb82a24d2f107ec349bc3
--- src/libsec/port/readcert.c
+++ src/libsec/port/readcert.c
chp = decodepemchain(chfile, "CERTIFICATE");
return chp;
}
-
blob - 82e2eeea0e72a2d997e1d59e56acae7899f72ae9
blob + 147cafd8f7bd6f7a7bd8c830669cee6a6a9faa7c
--- src/libsec/port/rsadecrypt.c
+++ src/libsec/port/rsadecrypt.c
/* exponentiate the modular rep */
mpexp(v1, rsa->kp, rsa->p, v1);
mpexp(v2, rsa->kq, rsa->q, v2);
-
+
/* out = v1 + p*((v2-v1)*c2 mod q) */
mpsub(v2, v1, v2);
mpmul(v2, rsa->c2, v2);
blob - 7b7156140fabe1e0ebc97f25c950b608ecf7ff33
blob + cc123a23963608d076491083f89063cd842581b7
--- src/libsec/port/rsafill.c
+++ src/libsec/port/rsafill.c
return rsa;
}
-
blob - 9ff66b5c266fdc6c674537e909936ccb2a292ee2
blob + 270e7694314bd0ffb747caceb565893e52fd461e
--- src/libsec/port/rsatest.c
+++ src/libsec/port/rsatest.c
strtomp("123456789abcdef123456789abcdef123456789abcdef123456789abcdef", nil, 16, clr);
rsaencrypt(&rsa->pub, clr, enc);
-
+
start = nsec();
for(n = 0; n < 10; n++)
rsadecrypt(rsa, enc, clr);
if(mpcmp(clr, clr2) != 0)
print("%B != %B\n", clr, clr2);
-
+
print("> ");
while(p = Brdline(&b, '\n')){
n = Blinelen(&b);
blob - 82566f21029c551fb9cd42bb09c2c86b31959906
blob + 6d7122630e459abc399d829c49fb9401925d99b2
--- src/libsec/port/sha1block.c
+++ src/libsec/port/sha1block.c
a += ((b<<5) | (b>>27)) + wp[4];
a += 0x5a827999 + (((d^e)&c)^e);
c = (c<<30)|(c>>2);
-
+
p += 20;
}
blob - cac95a436cedf0d2d34cf3173805d7687ba105d4
blob + 6010342ccf360ff66d49a2a59049548ad083509d
--- src/libsec/port/thumb.c
+++ src/libsec/port/thumb.c
free(crltab);
return table;
}
-
blob - ae216716da9c5ced55ec17105657c8289e1a750e
blob + f12d8ce9a75d8cd07e8c70fdba7069eb73393b79
--- src/libsec/port/tlshand.c
+++ src/libsec/port/tlshand.c
USED(sid);
USED(nsid);
-
+
memmove(sec->srandom, srandom, RandomSize);
if(setVers(sec, vers) < 0)
genrandom(pm->data, MasterSecretSize);
}
setMasterSecret(sec, pm);
- memset(pm->data, 0, pm->len);
+ memset(pm->data, 0, pm->len);
freebytes(pm);
}
blob - 2bbf85381d12780383c7df419a51f319d03c97a2
blob + 47900253346931b8956d02918364aff7399f3be9
--- src/libsec/port/x509.c
+++ src/libsec/port/x509.c
return nil;
return "digests did not match";
}
-
+
RSApub*
X509toRSApub(uchar *cert, int ncert, char *name, int nname)
{
blob - 692ab59161abe9692e2bcdf5e4fa4a737d076120
blob + 44ead7d17c1e747c9ac159380deaed862da4ad58
--- src/libsunrpc/client.c
+++ src/libsunrpc/client.c
if(nout == 0)
a[1].op = CHANNOP;
break;
-
+
case 2: /* tag = <-flushchan */
for(i=0; i<nout; i++){
o = out[i];
chanfree(cli->timerchan);
free(cli);
}
-
+
void
sunclientflushrpc(SunClient *cli, ulong tag)
{
blob - 8a09eda784e8721b5ab26b24b0ce0972e87fc5e7
blob + ce617412256089359171223d7dbbc5d6e8ab6e02
--- src/libsunrpc/emalloc.c
+++ src/libsunrpc/emalloc.c
setrealloctag(v, getcallerpc(&n));
return v;
}
-
-
blob - d487c8064792901f89912352c0daa338a4a4a9fa
blob + 4da94896ab88fdda9dbb3b25bbfc69d6b1cf30fa
--- src/libsunrpc/mount3.c
+++ src/libsunrpc/mount3.c
(P)nfsmount3rexportpack, (P)nfsmount3rexportunpack, (S)nfsmount3rexportsize, (F)nfsmount3rexportprint, sizeof(NfsMount3RExport),
};
-SunProg nfsmount3prog =
+SunProg nfsmount3prog =
{
NfsMount3Program,
NfsMount3Version,
blob - 706d9c4f47910bc71cefb4f54c62954d0d725254
blob + 8cf52db1a76ef15ffa346e088088d8030cb0f186
--- src/libsunrpc/nfs3.c
+++ src/libsunrpc/nfs3.c
*pa = a;
return 0;
}
-
+
int
nfs3rreaddirplusunpack(uchar *a, uchar *ea, uchar **pa, Nfs3RReadDirPlus *x)
{
(P)nfs3rcommitpack, (P)nfs3rcommitunpack, (S)nfs3rcommitsize, (F)nfs3rcommitprint, sizeof(Nfs3RCommit)
};
-SunProg nfs3prog =
+SunProg nfs3prog =
{
Nfs3Program,
Nfs3Version,
blob - 2bb401534ce8285340b245b763c2226971b93174
blob + 76a1dde1d7e6e1b9d6db82b800c5bc19e9a3c035
--- src/libsunrpc/portmap.c
+++ src/libsunrpc/portmap.c
(P)portRCallitPack, (P)portRCallitUnpack, (S)portRCallitSize, (F)portRCallitPrint, sizeof(PortRCallit),
};
-SunProg portprog =
+SunProg portprog =
{
PortProgram,
PortVersion,
blob - 4ebe1ec89ba229d128f493ea63ff999baf07fb3c
blob + a4b3f011ba14a73fdb4639cfc29fe02018d7cfb3
--- src/libsunrpc/rpc.c
+++ src/libsunrpc/rpc.c
goto Err;
break;
}
-
+
switch(rpc->status){
case SunSuccess:
if(sunuint32pack(a, ea, &a, (x=MsgSuccess, &x)) < 0
*pa = ea;
return -1;
}
-
blob - 6e024fca70a2a0c07b6cf2fa91b5a06a7cc55f58
blob + b94b7643947352a0ee4806082a5931910ebdec1c
--- src/libsunrpc/server.c
+++ src/libsunrpc/server.c
while((m = recvp(srv->creply)) != nil){
/* could record in cache here? */
sendp(m->creply, m);
- }
+ }
}
int
free(m);
return 0;
}
-
blob - 21327d9bc4cc17cbfaabdb8caca1a819fe322a24
blob + b1ee81b30837fa2615a4cccd151ce26c03022817
--- src/libthread/386-ucontext.h
+++ src/libthread/386-ucontext.h
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer
+ * notice, this list of conditions and the following disclaimer
* in this position and unchanged.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer
+ * notice, this list of conditions and the following disclaimer
* in this position and unchanged.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
stack_t uc_stack;
int __spare__[8];
};
-
-
blob - b9e8888e4c193ec6bb9a73d1c102415398414742
blob + 737c0a63a073c2bd781081409b0169d1614aa570
--- src/libthread/BSD.c
+++ src/libthread/BSD.c
if(msg == nil)
msg = "";
- /*
+ /*
* Only one guy, ever, gets to run this.
* If two guys do it, inevitably they end up
* tripping over each other in the underlying
{
_exit(0);
}
-
blob - 3ad1941c9ef745fd35a044a25dea9e298f5ae6c5
blob + b138e420043787d8f9ddce34ae01bc1e1885d5e8
--- src/libthread/Darwin-386.c
+++ src/libthread/Darwin-386.c
setcontext(ucp);
return 0;
}
-
blob - efcdb18c6f0004ba725dafdbc6d8fa09967d4bc9
blob + 3f2bf5669a9124b89d6e9a71301f01f666c5b3d8
--- src/libthread/Darwin-power.c
+++ src/libthread/Darwin-power.c
va_list arg;
tos = (ulong*)ucp->uc_stack.ss_sp+ucp->uc_stack.ss_size/sizeof(ulong);
- sp = tos - 16;
+ sp = tos - 16;
ucp->mc.pc = (long)func;
ucp->mc.sp = (long)sp;
va_start(arg, argc);
setcontext(ucp);
return 0;
}
-
blob - 0593e481dd6399d10b6a8e11df4d17bcc2295b94
blob + 27931456d6d0d9bf6377056fe280ef31437c4a62
--- src/libthread/Darwin-x86_64-swapcontext.c
+++ src/libthread/Darwin-x86_64-swapcontext.c
setcontext(ucp);
return 0;
}
-
-
blob - 907fb0c3fd4b29e0279c5de34eb0e374b2514d97
blob + fc0dfddaa03cbd92f88456486f189585fc73b24f
--- src/libthread/Linux-arm-swapcontext.c
+++ src/libthread/Linux-arm-swapcontext.c
setcontext(ucp);
return 0;
}
-
-
blob - a621b7a1b8fd1e979490d344c17d0d9e518f143f
blob + e4800c19ccb07521c5448fefd34f52ee05519dbd
--- src/libthread/Linux-sparc64-swapcontext.c
+++ src/libthread/Linux-sparc64-swapcontext.c
clr %o0 \n\
.size __swapcontext_ret, .-__swapcontext_ret \n\
");
-
blob - 17e8c12bb8ec7bddad7d1c9b15701e33d74c0f0c
blob + 31577e876dc7be7d2c6d59e67e02887eadf5c25c
--- src/libthread/Linux.c
+++ src/libthread/Linux.c
static int
timefmt(Fmt *fmt)
{
- static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
+ static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
vlong ns;
Tm tm;
ns = nsec();
tm = *localtime(time(0));
- return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
+ return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}
/*
* indirect through here so that parent need not wait for child zombie
- *
- * slight race - if child exits and then another process starts before we
+ *
+ * slight race - if child exits and then another process starts before we
* manage to exit, we'll be running on a freed stack.
*/
static int
if(msg == nil)
msg = "";
- /*
+ /*
* Only one guy, ever, gets to run this.
* If two guys do it, inevitably they end up
* tripping over each other in the underlying
{
int i, *sp;
va_list arg;
-
+
sp = (int*)uc->uc_stack.ss_sp+uc->uc_stack.ss_size/4;
va_start(arg, argc);
for(i=0; i<4 && i<argc; i++)
return 0;
}
#endif
-
blob - cb19514957dafba00dc40aad3aad58ed5589c29c
blob + 37dabe9c909f047f45cd39c8daf9ec699061528c
--- src/libthread/NetBSD.c
+++ src/libthread/NetBSD.c
#include "Linux.c"
-
blob - 3725f264a4ef4f7b132095d58194cc55820437c3
blob + 89bfedcd985079d81b12d77062db6bb55de5994b
--- src/libthread/OpenBSD-386.c
+++ src/libthread/OpenBSD-386.c
setcontext(ucp);
return 0;
}
-
blob - b83522f00e6725fba2d9f975e9eae0e945f8bcad
blob + eab711f22577a9910515ee3a005484968de34977
--- src/libthread/OpenBSD-power.c
+++ src/libthread/OpenBSD-power.c
setcontext(ucp);
return 0;
}
-
blob - 0593e481dd6399d10b6a8e11df4d17bcc2295b94
blob + 27931456d6d0d9bf6377056fe280ef31437c4a62
--- src/libthread/OpenBSD-x86_64.c
+++ src/libthread/OpenBSD-x86_64.c
setcontext(ucp);
return 0;
}
-
-
blob - cd7750c0cc6a5dcbe50745818fe324c79024ca3c
blob + b6b2e3e63d48b1165efc818b8d8d9a3cfad9b67c
--- src/libthread/channel.c
+++ src/libthread/channel.c
* You have to put locks in all the channels and all the Alt
* structures. At the beginning of an alt you have to lock all
* the channels, but then to try to actually exec an op you
- * have to lock the other guy's alt structure, so that other
+ * have to lock the other guy's alt structure, so that other
* people aren't trying to use him in some other op at the
* same time.
- *
+ *
* For Plan 9 apps, it's just not worth the extra effort.
*/
static QLock chanlock;
return val;
return -1;
}
-
blob - e047ab02e249bdb5e530befb7d667c140dee27c0
blob + 387d1527280d0a6b584e26851e35f3d622616d53
--- src/libthread/daemonize.c
+++ src/libthread/daemonize.c
kill(sigpid, sig);
}
-static int sigs[] =
+static int sigs[] =
{
SIGHUP, SIGINT, SIGQUIT, SIGILL,
SIGTRAP, SIGABRT, SIGBUS, SIGFPE,
SIGUSR1, SIGSEGV, SIGUSR2, SIGPIPE,
SIGALRM, SIGTERM, SIGCHLD, SIGSTOP,
- /*SIGTSTP, SIGTTIN, SIGTTOU,*/ SIGURG,
+ /*SIGTSTP, SIGTTIN, SIGTTOU,*/ SIGURG,
SIGXCPU, SIGXFSZ, SIGVTALRM, SIGPROF,
#ifdef SIGWINCH
SIGWINCH,
SIGEMT,
#endif
#ifdef SIGPWR
- SIGPWR,
+ SIGPWR,
#endif
#ifdef SIGINFO
SIGINFO,
blob - 62805ba282d15a825403cb516e379f6fd3a3602b
blob + fb5d521a6dfca833f403493446a60bf784b557c7
--- src/libthread/exec.c
+++ src/libthread/exec.c
if(pid >= 0)
threadexits("threadexecl");
}
-
blob - f3a488d3ce493b2f4177ef1cc794b8c715a279b8
blob + 831beade97ee3ac9e33e20e8c842b059840de14c
--- src/libthread/ioproc.h
+++ src/libthread/ioproc.h
char err[ERRMAX];
Ioproc *next;
};
-
blob - 27ed3390e295f2c48626acea9b496eadba8eceea
blob + 1985d98d235e1ea7a0412b8599e64fde79d7701b
--- src/libthread/power-ucontext.h
+++ src/libthread/power-ucontext.h
int swapcontext(ucontext_t*, ucontext_t*);
int _getmcontext(mcontext_t*);
void _setmcontext(mcontext_t*);
-
blob - 0031d2a46df864a8c71b6ed18df7aefa6cc7f4ce
blob + 36b8817103a0d70a1a9a9cf7d9a186c06e5d0b95
--- src/libthread/sparc-ucontext.h
+++ src/libthread/sparc-ucontext.h
int swapcontext(ucontext_t*, ucontext_t*);
int _getmcontext(mcontext_t*);
void _setmcontext(mcontext_t*);
-
blob - c5732165cd9ed7d1e8bd4d491d9b0327e877029d
blob + c237b7cdcd2912c8dd6ad9fc0daa5743abec580e
--- src/libthread/test/thello.c
+++ src/libthread/test/thello.c
{
print("hello, world\n");
}
-
blob - 542a2437a4f03c6c18cfad5af890e7731594b870
blob + cbad185c4a7fa7ad4dd85caf341894514ff56b6a
--- src/libthread/thread.c
+++ src/libthread/thread.c
t->context.uc.uc_stack.ss_size = t->stksize-64;
#if defined(__sun__) && !defined(__MAKECONTEXT_V2_SOURCE) /* sigh */
/* can avoid this with __MAKECONTEXT_V2_SOURCE but only on SunOS 5.9 */
- t->context.uc.uc_stack.ss_sp =
+ t->context.uc.uc_stack.ss_sp =
(char*)t->context.uc.uc_stack.ss_sp
+t->context.uc.uc_stack.ss_size;
#endif
/* defend against bad C libraries */
if(stack < (256<<10))
stack = 256<<10;
-
+
t = threadalloc(fn, arg, stack);
t->proc = p;
addthreadinproc(p, t);
{
int n;
Proc *p;
-
+
p = proc();
n = p->nswitch;
lock(&p->lock);
threadid(void)
{
_Thread *t;
-
+
t = proc()->thread;
return t->id;
}
threadqunlock(QLock *l, ulong pc)
{
_Thread *ready;
-
+
lock(&l->l);
/*print("qlock unlock %p @%#x by %p (owner %p)\n", l, pc, (*threadnow)(), l->owner); */
if(l->owner == 0){
addthread(&l->rwaiting, (*threadnow)());
unlock(&l->l);
_threadswitch();
- return 1;
+ return 1;
}
static int
if((t = r->waiting.head) == nil)
break;
delthread(&r->waiting, t);
- _threadready(t);
+ _threadready(t);
}
return i;
}
unlock(&_threadprocslock);
}
-/*
+/*
* notify - for now just use the usual mechanisms
*/
void
fprint(2, "proc %p %s%s\n", (void*)p->osprocid, p->msg,
p->sysproc ? " (sysproc)": "");
for(t=p->allthreads.head; t; t=t->allnext){
- fprint(2, "\tthread %d %s: %s %s\n",
- t->id,
- t == p->thread ? "Running" :
+ fprint(2, "\tthread %d %s: %s %s\n",
+ t->id,
+ t == p->thread ? "Running" :
onrunqueue(p, t) ? "Ready" : "Sleeping",
t->state, t->name);
}
}
return 1;
}
-
-
blob - 144a2136b1687b2501ec3dbb3ca9af1109c1b168
blob + a8d52704db96a276c602c0fb2e5da3239115cd7c
--- src/libthread/threadimpl.h
+++ src/libthread/threadimpl.h
/*
* OS X before 10.5 (Leopard) does not provide
* swapcontext nor makecontext, so we have to use our own.
- * In theory, Leopard does provide them, but when we use
+ * In theory, Leopard does provide them, but when we use
* them, they seg fault. Maybe we're using them wrong.
* So just use our own versions, even on Leopard.
*/
blob - 24538e586da3569638eac9b38833edd65ba05fea
blob + ba2301f547619feb9082e4020d911f6427005877
--- src/libthread/wait.c
+++ src/libthread/wait.c
Waiter me;
Waitmsg *msg;
int i;
-
+
memset(&me, 0, sizeof me);
me.pid = pid;
me.r.l = &waiting.lk;
-
+
qlock(&waiting.lk);
for(i=0; i<waiting.nmsg; i++){
if(waiting.msg[i]->pid == pid){
blob - 08c6d9a8e8396cc5a3ad21872eb02af021a315cb
blob + e0640761c450f51994fc091c69417a74d7b5fff1
--- src/libthread/x86_64-ucontext.h
+++ src/libthread/x86_64-ucontext.h
int swapcontext(ucontext_t*, ucontext_t*);
int libthread_getmcontext(mcontext_t*);
void libthread_setmcontext(mcontext_t*);
-
blob - da0d103ec24ec95547be7405960a97e97456b060
blob + aed19c55e31bdbfd92d7ee7b607ebb04f8416379
--- src/libventi/cache.c
+++ src/libventi/cache.c
u32int now;
int p;
VtCache *c;
-
+
c = b->c;
now = c->now;
for(; i != 0; i = p){
u32int now;
int k;
VtCache *c;
-
+
c = b->c;
now = c->now;
for(; ; i = k){
b->prev = nil;
}
-
+
if(0)fprint(2, "droping %x:%V\n", b->addr, b->score);
/* set vtBlock to a reasonable state */
b->ref = 1;
vtcacheevict(VtCache *c, ulong size)
{
VtBlock *b;
-
+
/*
* If we were out of memory and put some blocks
* to the side but now we have memory, grab one.
b->next = nil;
goto alloc;
}
-
+
/*
* Otherwise, evict until we have memory.
*/
/*
* Lock b before unlocking c, so that others wait while we read.
- *
+ *
* You might think there is a race between this qlock(b) before qunlock(c)
* and the qlock(c) while holding a qlock(b) in vtblockwrite. However,
* the block here can never be the block in a vtblockwrite, so we're safe.
* b->nlock should probably stay at zero while
* the vtBlock is unlocked, but diskThread and vtSleep
* conspire to assume that they can just qlock(&b->lk); vtblockput(b),
- * so we have to keep b->nlock set to 1 even
+ * so we have to keep b->nlock set to 1 even
* when the vtBlock is unlocked.
*/
assert(b->nlock == 0);
return NilBlock;
return (score[16]<<24)|(score[17]<<16)|(score[18]<<8)|score[19];
}
-
blob - f76fd343311a1425179904239088739960a0289c
blob + 14f4543f98db97a64132c184500cc2d523a3b4d5
--- src/libventi/client.c
+++ src/libventi/client.c
vtgoodbye(VtConn *z)
{
VtFcall tx, rx;
-
+
tx.msgtype = VtTgoodbye;
vtfcallrpc(z, &tx, &rx); /* always fails: no VtRgoodbye */
return 0;
blob - ef4c2f51d9bf1ee0bc6433a30c38461801805a60
blob + 4d61dbed1d643bfa54600ddf7ec9d493a10b6995
--- src/libventi/cvt.h
+++ src/libventi/cvt.h
#define U32PUT(p,v) (p)[0]=(v)>>24;(p)[1]=(v)>>16;(p)[2]=(v)>>8;(p)[3]=(v)
#define U48PUT(p,v,t32) t32=(v)>>32;U16PUT(p,t32);t32=(v);U32PUT((p)+2,t32)
#define U64PUT(p,v,t32) t32=(v)>>32;U32PUT(p,t32);t32=(v);U32PUT((p)+4,t32)
-
blob - e0452e48d5363f4a4eb179acaafc933594af5b6b
blob + 9549d89b25b8270bd0fd33ae5b18117fd8a20a4d
--- src/libventi/debug.c
+++ src/libventi/debug.c
vfprint(2, fmt, arg);
va_end(arg);
}
-
blob - 4c13bc87ee866701a2e8c9b90a28925cb50b696f
blob + 1fbfea6a2882d16a732188e8ea79fdf3b4eff22e
--- src/libventi/debugpacket.c
+++ src/libventi/debugpacket.c
packetalloc(void)
{
Packet *p;
-
+
p = vtmallocz(sizeof *p);
p->free = vtfree;
p->arg = nil;
packetcmp(Packet *p, Packet *q)
{
int i, len;
-
+
NOTFREE(p);
NOTFREE(q);
len = p->len;
packetforeign(uchar *buf, int n, void (*free)(void*), void *a)
{
Packet *p;
-
+
if(n < 0)
abort();
p = packetalloc();
packetsplit(Packet *p, int n)
{
Packet *q;
-
+
NOTFREE(p);
q = packetalloc();
q->data = vtmalloc(n);
p->len -= n;
return 0;
}
-
blob - 7886518e2705cd2edc107e2393d2b9cdf9e6d491
blob + 7b0867ba7debcfe34f5ce6bb8e62848d0af2a580
--- src/libventi/dtype.c
+++ src/libventi/dtype.c
return VtCorruptType;
return fromdisk[n];
}
-
blob - 5e9a7c1fe8e25eaf7f9b6bb384afc7e9221c8c82
blob + 12fb9589f140416c2256f5766765b04e174477a6
--- src/libventi/entry.c
+++ src/libventi/entry.c
{
int shift;
ulong n0;
-
+
n0 = n;
shift = 0;
while(n >= (1<<(16 - 5))) {
shift++;
n >>= 1;
}
-
+
n = (n<<5) | shift;
if(((n>>5)<<(n&31)) != n0)
sysfatal("vttobig %#lux => %#lux failed", n0, n);
p += VtScoreSize;
assert(p-op == VtEntrySize);
-
+
if(!(e->flags & VtEntryActive))
return 0;
- /*
+ /*
* Some old vac files use psize==0 and dsize==0 when the
* file itself has size 0 or is zeros. Just to make programs not
* have to figure out what block sizes of 0 means, rewrite them.
return 0;
}
-
blob - e97df39c6ab8e6e03769cbd27829faac5b934f3f
blob + 8a051248113ab6d1a7003f253002f54470549c7f
--- src/libventi/file.c
+++ src/libventi/file.c
* The single point of truth for the info about the VtFiles themselves
* is the block data. Because of this, there is no explicit locking of
* VtFile structures, and indeed there may be more than one VtFile
- * structure for a given Venti file. They synchronize through the
+ * structure for a given Venti file. They synchronize through the
* block cache.
*
* This is a bit simpler than fossil because there are no epochs
int epb;
VtFile *rr;
u32int offset;
-
+
assert(ISLOCKED(r));
assert(type == VtDirType || type == VtDataType);
if(bb == nil)
break;
memmove(bb->data, b->score, VtScoreSize);
- memmove(e->score, bb->score, VtScoreSize);
+ memmove(e->score, bb->score, VtScoreSize);
e->type++;
e->flags |= VtEntryLocal;
vtblockput(b);
}
return i;
}
-
+
VtBlock *
vtfileblock(VtFile *r, u32int bn, int mode)
{
{
int np;
int d;
-
+
/* determine pointer depth */
np = psize/VtScoreSize;
s = (s + dsize - 1)/dsize;
vtentrypack(&e, b->data, i);
}
break;
-
+
default: /* VtPointerTypeX */
for(i=0; i<ppb; i++){
if(flushblock(c, nil, b->data+VtScoreSize*i, ppb, epb, type-1) < 0)
}else{
/*
* interior node: pointer blocks.
- * specifically, b = bi[i] is a block whose index[i-1]'th entry
- * points at bi[i-1].
+ * specifically, b = bi[i] is a block whose index[i-1]'th entry
+ * points at bi[i-1].
*/
b = bi[i];
/*
- * the index entries up to but not including index[i-1] point at
+ * the index entries up to but not including index[i-1] point at
* finished blocks, so flush them for sure.
*/
for(j=0; j<index[i-1]; j++)
blob - 365baf1daca301f70c08aa0e82741d56d5b3fa60
blob + a17b7c3f99f3c4f9a436353710a5dc43c7c7b604
--- src/libventi/hangup.c
+++ src/libventi/hangup.c
_vtqhangup(z->readq);
qunlock(&z->lk);
}
-
blob - 0d67a98bd05652b4c8c48313027ca075c1efe1d0
blob + a6738c7a9ebb8408bb6254712f425fe7e51ac72f
--- src/libventi/log.c
+++ src/libventi/log.c
int i, nname, size;
VtLog *l;
char **s, *a, *e;
-
+
qlock(&vl.lk);
size = 0;
nname = 0;
nname++;
size += strlen(l->name)+1;
}
-
+
s = vtmalloc(nname*sizeof(char*)+size);
a = (char*)(s+nname);
e = (char*)s+nname*sizeof(char*)+size;
}
strcpy(p, name);
l->name = p;
-
+
/* insert */
l->next = vl.hash[h];
vl.hash[h] = l;
l->ref++;
-
+
l->ref++;
qunlock(&vl.lk);
return l;
vtlogprint(VtLog *l, char *fmt, ...)
{
va_list arg;
-
+
if(l == nil)
return;
-
+
va_start(arg, fmt);
vtlogvprint(l, fmt, arg);
va_end(arg);
if(l == nil)
return;
-
+
c = l->w;
for(i=0; i<l->nchunk; i++){
if(++c == l->chunk+l->nchunk)
write(fd, c->p, c->wp-c->p);
}
}
-
blob - dea99a9d1a0abacef20424505f00549d516066ab
blob + 2f03de4e79e628bdd4656931053bf116be857995
--- src/libventi/mem.c
+++ src/libventi/mem.c
align = IdealAlignment;
else if(n > 8)
align = 8;
- else
+ else
align = 4;
lock(&lk);
nchunk++;
}
- assert(n + pad <= nbuf);
-
+ assert(n + pad <= nbuf);
+
p = buf + pad;
buf += pad + n;
nbuf -= pad + n;
return p;
}
-
blob - d19d85371965ae5765494e6ebad44b98b2dfda1e
blob + 8d1628188eb1df57de1b452f6b3c4bcf805fc9f0
--- src/libventi/packet.c
+++ src/libventi/packet.c
FragLocalAlloc,
FragGlobal
};
-
+
struct Frag
{
int state;
ulong pc;
Packet *next;
-
+
Frag *first;
Frag *last;
-
+
Frag local[NLocalFrag];
};
#endif
/*
- * the free list is primarily for speed, but it is
+ * the free list is primarily for speed, but it is
* also necessary for packetsplit that packets
* are never freed -- a packet can contain a different
* packet's local fragments, thanks to packetsplit!
Packet *
packetdup(Packet *p, int offset, int n)
-{
+{
Frag *f, *ff;
Packet *pp;
/* skip offset */
for(f=p->first; offset >= FRAGSIZE(f); f=f->next)
offset -= FRAGSIZE(f);
-
+
/* first frag */
ff = fragdup(pp, f);
ff->rp += offset;
n -= FRAGSIZE(ff);
pp->asize += FRAGASIZE(ff);
}
-
+
/* fix up last frag: note n <= 0 */
ff->wp += n;
ff->next = nil;
NOTFREE(p);
return 0;
}
-
+
/* free before offset */
for(f=p->first; offset >= FRAGSIZE(f); f=ff) {
p->asize -= FRAGASIZE(f);
}
p->size += n;
-
+
/* try and fix in current frag */
f = p->first;
if(f != nil) {
}
p->size += n;
-
+
/* try and fix in current frag */
if(p->first != nil) {
f = p->last;
nn = n;
if(nn > MaxFragSize)
nn = MaxFragSize;
- f = fragalloc(p, nn, PEnd, p->first);
+ f = fragalloc(p, nn, PEnd, p->first);
p->asize += FRAGASIZE(f);
if(p->first == nil)
p->last = f;
n -= nn;
}
}
-
+
while(n > 0) {
nn = n;
if(nn > MaxFragSize)
werrstr(EPacketSize);
return nil;
}
-
+
/* skip up to offset */
for(f=p->first; offset >= FRAGSIZE(f); f=f->next)
offset -= FRAGSIZE(f);
NOTFREE(p);
if(p->size == 0 || nio <= 0)
return 0;
-
+
if(offset < 0 || offset > p->size) {
werrstr(EPacketOffset);
return -1;
eio = io + nio;
for(; f != nil && io < eio; f=f->next) {
io->addr = f->rp + offset;
- io->len = f->wp - (f->rp + offset);
+ io->len = f->wp - (f->rp + offset);
offset = 0;
size += io->len;
io++;
nbm = 0;
for(m=freelist.bigmem; m; m=m->next)
nbm++;
-
+
fprint(2, "packet: %d/%d frag: %d/%d small mem: %d/%d big mem: %d/%d\n",
np, freelist.npacket,
nf, freelist.nfrag,
if(1) {
Frag *f;
int size = 0;
-
+
for(f=p->first; f; f=f->next)
size += FRAGSIZE(f);
if(size != p->size)
if(0) {
Frag *f;
int asize = 0;
-
+
for(f=p->first; f; f=f->next)
asize += FRAGASIZE(f);
if(asize != p->asize)
goto Found;
}
}
- lock(&freelist.lk);
+ lock(&freelist.lk);
f = freelist.frag;
if(f != nil)
freelist.frag = f->next;
Frag *ff;
Mem *m;
- m = f->mem;
+ m = f->mem;
/*
* m->rp && m->wp can be out of date when ref == 1
unlock(&m->lk);
}
-
+
return ff;
}
lock(&freelist.lk);
f->next = freelist.frag;
freelist.frag = f;
- unlock(&freelist.lk);
+ unlock(&freelist.lk);
}
static Mem *
m->bp = vtbrk(nn);
m->ep = m->bp + nn;
}
- assert(m->ref == 0);
+ assert(m->ref == 0);
m->ref = 1;
switch(pos) {
break;
case PEnd:
m->rp = m->ep - n;
- break;
+ break;
}
/* check we did not blow it */
if(m->rp < m->bp)
blob - bba630324e0cd1d6cfd9f456cb6b347136b38295
blob + b898ea745cc837dd2fd4f234cb668c563bf58185
--- src/libventi/queue.c
+++ src/libventi/queue.c
_vtqdecref(Queue *q)
{
Qel *e;
-
+
qlock(&q->lk);
if(--q->ref > 0){
qunlock(&q->lk);
blob - 8f26863372f4ca13b71791b06c2321518b7bb0cb
blob + 2abe3e42f6e63b73d23d7433832c9ae4ecfc9175
--- src/libventi/rpc.c
+++ src/libventi/rpc.c
/*
- * Multiplexed Venti client. It would be nice if we
+ * Multiplexed Venti client. It would be nice if we
* could turn this into a generic library routine rather
* than keep it Venti specific. A user-level 9P client
* could use something like this too.
- *
+ *
* (Actually it does - this should be replaced with libmux,
* which should be renamed librpcmux.)
*
return _vtrpc(z, p, nil);
}
-static int
+static int
gettag(VtConn *z, Rwait *r)
{
int i;
r->done = 1;
rwakeup(&r->r);
}
-
blob - 4dbe115f30d7f172b103c715619d3f0ce99c3d67
blob + 96dfe9e6e0f496c3a2f446195e16b73ef60487e2
--- src/libventi/send.c
+++ src/libventi/send.c
p = packetsplit(p, len);
vtlog(VtServerLog, "<font size=-1>%T %s:</font> read packet %p len %d<br>\n", z->addr, p, len);
return p;
-Err:
+Err:
vtlog(VtServerLog, "<font size=-1>%T %s:</font> error reading packet: %r<br>\n", z->addr);
- return nil;
+ return nil;
}
/*
* If you fork off two procs running vtrecvproc and vtsendproc,
- * then vtrecv/vtsend (and thus vtrpc) will never block except on
+ * then vtrecv/vtsend (and thus vtrpc) will never block except on
* rendevouses, which is nice when it's running in one thread of many.
*/
void
if(_vtsend(z, p) < 0){
qunlock(&z->outlk);
vthangup(z);
- return -1;
+ return -1;
}
qunlock(&z->outlk);
return 0;
}
-
blob - 917522007696539ded4d9462f5f66ae256c007ae
blob + 58ce1d8d1c7640f2b83ffc146292d64deafccb6e
--- src/libventi/server.c
+++ src/libventi/server.c
vtgetreq(VtSrv *srv)
{
VtReq *r;
-
+
r = _vtqrecv(srv->q);
if (r != nil)
vtlog(VtServerLog, "<font size=-1>%T %s:</font> vtgetreq %F<br>\n", ((VtSconn*)r->sc)->c->addr, &r->tx);
vtfcallclear(&r->rx);
vtfree(r);
}
-
blob - e191c390c03982fe9c17d7d267613e11263a639b
blob + 36fa6fc7e4c7443101524be09e661e113d303157
--- src/libventi/strdup.c
+++ src/libventi/strdup.c
memmove(ss, s, n);
return ss;
}
-
blob - 9763149a1c93dc0f9c80a9697e0794dafcb2ab68
blob + b273b182004b89a8b067736bf4edc6731734354e
--- src/libventi/string.c
+++ src/libventi/string.c
*ps = s;
return 0;
}
-
blob - eb686b32963a870552b707d8205e32982c4f45bd
blob + e105c624f8e30129ca45081853f27ca0036cd35e
--- src/libventi/time.c
+++ src/libventi/time.c
ns = nsec();
tm = *localtime(ns/1000000000);
if(fmt->flags&FmtLong){
- return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d.%03d",
- tm.year+1900, tm.mon+1, tm.mday,
+ return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d.%03d",
+ tm.year+1900, tm.mon+1, tm.mday,
tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}else{
- return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d",
- tm.year+1900, tm.mon+1, tm.mday,
+ return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d",
+ tm.year+1900, tm.mon+1, tm.mday,
tm.hour, tm.min, tm.sec);
}
}
-
blob - c40aea96916d1608a1d69cf713c0581586006d09
blob + 33353c7865eac7a21c7fb54e2be872f2c3a71724
--- src/libventi/zero.c
+++ src/libventi/zero.c
}
}
-uint
+uint
vtzerotruncate(int type, uchar *buf, uint n)
{
uchar *p;
blob - 6f22d72de2616cd6d498b619a06f003e05acab1e
blob + b58b13c2b907b1e80e6479fe0d949a802f86f28d
--- src/libventi/zeroscore.c
+++ src/libventi/zeroscore.c
0xda, 0x39, 0xa3, 0xee, 0x5e, 0x6b, 0x4b, 0x0d, 0x32, 0x55,
0xbf, 0xef, 0x95, 0x60, 0x18, 0x90, 0xaf, 0xd8, 0x07, 0x09
};
-
