/* pptfs.c © Steve Simon 2007 */
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <ctype.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>
enum {
PPTMAGIC = 0xe391c05f,
Isdir = 0x0f
};
typedef struct {
vlong base; // start of record in file
int cont; // is 0x0f if its a container
int opts; // record options
int type; // record type
int len; // length of current record
int got; // remaining record data
} Hdr;
typedef struct {
int num; // slide number ?
vlong off; // file offset
} Blk;
typedef struct {
int bullet; // true if lines have bullets
char allign; // l=left, r=right, c=center
} Para;
typedef struct {
char *type;
int len;
int off;
} Img;
typedef struct {
int size;
void *table;
int alloc;
int used;
} Tab;
typedef struct {
int slide;
int blip;
} Xref;
Tab Imgtab = { sizeof(Img) }; // Blip Images (in order found)
Tab Blktab = { sizeof(Blk) }; // edited block of slides (sorted by slide ID)
Tab Xreftab = { sizeof(Xref) }; // maps blips to slides
int Slideno = -1; // current slide number
int Margin = 1; // am at the margin
int Txtype = -1; // type of current text (title, body etc)
vlong Start; // first edited slide chunk
Fmt *Fp;
int Debug = 0;
Biobuf *Bi = nil;
int parse(vlong off, int len, int indent);
typedef struct {
char *data;
int len;
} Vfile;
struct {
char *s;
int n;
} Types[] = {
{ "Unknown", 0 },
{ "Document", 1000 },
{ "Document Atom", 1001 },
{ "End Document", 1002 },
{ "Slide", 1006 },
{ "Slide Atom", 1007 },
{ "Notes", 1008 },
{ "Notes Atom", 1009 },
{ "Environment", 1010 },
{ "Slide Persist Atom", 1011 },
{ "S Slide Layout Atom", 1015 },
{ "Main Master", 1016 },
{ "SS Slide Info Atom", 1017 },
{ "Slide View Info", 1018 },
{ "Guide Atom", 1019 },
{ "View Info", 1020 },
{ "View Info Atom", 1021 },
{ "Slide View Info Atom", 1022 },
{ "VBA Info", 1023 },
{ "VBA Info Atom", 1024 },
{ "SS Doc Info Atom", 1025 },
{ "Summary", 1026 },
{ "Doc Routing Slip", 1030 },
{ "Outline View Info", 1031 },
{ "Sorter View Info", 1032 },
{ "Ex Obj List", 1033 },
{ "Ex Obj List Atom", 1034 },
{ "PP Drawing Group", 1035 },
{ "PP Drawing", 1036 }, // Escher container
{ "Named Shows", 1040 },
{ "Named Show", 1041 },
{ "Named Show Slides", 1042 },
{ "List", 2000 },
{ "Font Collection", 2005 },
{ "Bookmark Collection", 2019 },
{ "Sound Coll Atom", 2021 },
{ "Sound", 2022 },
{ "Sound Data", 2023 },
{ "Bookmark Seed Atom", 2025 },
{ "Color Scheme Atom", 2032 },
{ "Ex Obj Xref Atom", 3009 },
{ "OE Shape Atom", 3009 },
{ "OE Placeholder Atom", 3011 },
{ "G Point Atom", 3024 },
{ "G Ratio Atom", 3031 },
{ "Outline Text Xref Atom", 3998 },
{ "Text Header Atom", 3999 },
{ "Text Chars Atom", 4000 },
{ "Style Text Prop Atom", 4001 },
{ "Base Text Prop Atom", 4002 },
{ "Tx Master Style Atom", 4003 },
{ "Tx CF Style Atom", 4004 },
{ "Tx PF Style Atom", 4005 },
{ "Text Ruler Atom", 4006 },
{ "Text Bookmark Atom", 4007 },
{ "Text Bytes Atom", 4008 },
{ "Tx SI Style Atom", 4009 },
{ "Text Spec Info Atom", 4010 },
{ "Default Ruler Atom", 4011 },
{ "Font Entity Atom", 4023 },
{ "Font Embedded Data", 4024 },
{ "C String", 4026 },
{ "Meta File", 4033 },
{ "Ex Ole Obj Atom", 4035 },
{ "Sr Kinsoku", 4040 },
{ "Hand Out", 4041 },
{ "Ex Embed", 4044 },
{ "Ex Embed Atom", 4045 },
{ "Ex Link", 4046 },
{ "Bookmark Entity Atom", 4048 },
{ "Ex Link Atom", 4049 },
{ "Sr Kinsoku Atom", 4050 },
{ "Ex Hyperlink Atom", 4051 },
{ "Ex Hyperlink", 4055 },
{ "Slide Number MC Atom", 4056 },
{ "Headers Footers", 4057 },
{ "Headers Footers Atom", 4058 },
{ "Tx Interactive Info Atom", 4063 },
{ "Char Format Atom", 4066 },
{ "Para Format Atom", 4067 },
{ "Recolor Info Atom", 4071 },
{ "Ex Quick Time Movie", 4074 },
{ "Ex Quick Time Movie Data", 4075 },
{ "Ex Control", 4078 },
{ "Slide List With Text", 4080 },
{ "Interactive Info", 4082 },
{ "Interactive Info Atom", 4083 },
{ "User Edit Atom", 4085 },
{ "Current User Atom", 4086 },
{ "Date Time MC Atom", 4087 },
{ "Generic Date MC Atom", 4088 },
{ "Footer MC Atom", 4090 },
{ "Ex Control Atom", 4091 },
{ "Ex Media Atom", 4100 },
{ "Ex Video", 4101 },
{ "Ex Avi Movie", 4102 },
{ "Ex MCI Movie", 4103 },
{ "Ex MIDI Audio", 4109 },
{ "Ex CD Audio", 4110 },
{ "Ex WAV Audio Embedded", 4111 },
{ "Ex WAV Audio Link", 4112 },
{ "Ex Ole Obj Stg", 4113 },
{ "Ex CD Audio Atom", 4114 },
{ "Ex WAV Audio Embedded Atom", 4115 },
{ "Animation Info Atom", 4116 },
{ "RTF Date Time MC Atom", 4117 },
{ "Prog Tags", 5000 },
{ "Prog String Tag", 5001 },
{ "Prog Binary Tag", 5002 },
{ "Binary Tag Data", 5003 },
{ "Print Options", 6000 },
{ "Persist Ptr Full Block", 6001 },
{ "Persist Ptr Inc Block", 6002 },
{ "G Scaling Atom", 10001 },
{ "GR Color Atom", 10002 },
{ "Escher Dgg Container", 0xf000 },
{ "Escher Dgg", 0xf006 },
{ "Escher CLSID", 0xf016 },
{ "Escher OPT", 0xf00b },
{ "Escher BStore Container", 0xf001 },
{ "Escher BSE", 0xf007 },
{ "Escher Blip first", 0xf018 },
{ "Escher Blip unknown", 0xf019 },
{ "Escher Blip EMF", 0xf01a },
{ "Escher Blip WMF", 0xf01b },
{ "Escher Blip PICT", 0xf01c },
{ "Escher Blip JPEG", 0xf01d },
{ "Escher Blip PNG", 0xf01e },
{ "Escher Blip DIB", 0xf01f },
{ "Escher Blip last", 0xf117 },
{ "Escher Dg Container", 0xf002 },
{ "Escher Dg", 0xf008 },
{ "Escher Regroup Items", 0xf118 },
{ "Escher Color Scheme", 0xf120 }, /* bug in docs */
{ "Escher Spgr Container", 0xf003 },
{ "Escher Sp Container", 0xf004 },
{ "Escher Spgr", 0xf009 },
{ "Escher Sp", 0xf00a },
{ "Escher Textbox", 0xf00c },
{ "Escher Client Textbox", 0xf00d },
{ "Escher Anchor", 0xf00e },
{ "Escher Child Anchor", 0xf00f },
{ "Escher Client Anchor", 0xf010 },
{ "Escher Client Data", 0xf011 },
{ "Escher Solver Container", 0xf005 },
{ "Escher Connector Rule", 0xf012 } , /* bug in docs */
{ "Escher Align Rule", 0xf013 },
{ "Escher Arc Rule", 0xf014 },
{ "Escher Client Rule", 0xf015 },
{ "Escher Callout Rule", 0xf017 },
{ "Escher Selection", 0xf119 },
{ "Escher Color MRU", 0xf11a },
{ "Escher Deleted Pspl", 0xf11d } , /* bug in docs */
{ "Escher Split Menu Colors", 0xf11e },
{ "Escher Ole Object", 0xf11f },
{ "Escher User Defined", 0xf122 },
};
void fsread(Req *);
Srv Fs = {
.read = fsread,
};
void
pr(char *fmt, ...)
{
va_list args;
va_start(args, fmt);
if (Debug)
vfprint(1, fmt, args);
fmtvprint(Fp, fmt, args);
va_end(args);
}
void *
growtab(Tab *t)
{
if(t->alloc >= t->used){
t->alloc += 8;
t->table = realloc(t->table, t->alloc * t->size);
if(t->table == nil)
sysfatal("no memory - %r");
}
return (char *)t->table + t->used++ * t->size;
}
void *
indextab(Tab *t, int idx)
{
if (idx < 0 || idx >= t->used)
return nil;
return (char *)t->table + idx * t->size;
}
int
mkfile(char *name, char *data, int len)
{
int seq;
char *p;
Vfile *vf;
File *f, *nf;
char s[128];
vf = emalloc9p(sizeof(Vfile));
vf->data = data;
vf->len = len;
f = Fs.tree->root;
incref(f);
while(f && (p = strchr(name, '/'))) {
*p = '\0';
if(strcmp(name, "") != 0 && strcmp(name, ".") != 0){
/* this would be a race if we were multithreaded */
incref(f); /* so walk doesn't kill it immediately on failure */
if((nf = walkfile(f, name)) == nil)
nf = createfile(f, name, "bill", DMDIR|0755, nil);
decref(f);
f = nf;
}
*p = '/';
name = p+1;
}
if(f == nil){
free(vf->data);
free(vf);
return -1;
}
incref(f);
seq = 0;
snprint(s, sizeof(s), "%s", name);
while((nf = walkfile(f, s)) != nil){
f = walkfile(nf, "..");
snprint(s, sizeof(s), "%s.%d", name, seq++);
}
nf = createfile(f, s, "bill", 0644, vf);
decref(f);
nf->length = len;
return 0;
}
char *
rectype(int type)
{
int i;
static char buf[32];
for (i = 0; i < nelem(Types); i++)
if(type == Types[i].n)
return Types[i].s;
snprint(buf, nelem(buf), "0x%x", type);
return buf;
}
void
sheet(int num, vlong off)
{
int i;
Blk *bk;
for(i = 0; (bk = indextab(&Blktab, i)); i++)
if(bk->num == num)
return;
bk = growtab(&Blktab);
bk->num = num;
bk->off = off;
}
int
cmp(void *a, void *b)
{
return ((Blk *)a)->num - ((Blk *)b)->num;
}
void
xd(Hdr *h)
{
vlong off;
uchar buf[16];
int addr, got, n, i, j;
addr = 0;
off = Boffset(Bi);
while (addr < h->len){
n = (h->len >= sizeof(buf))? sizeof(buf): h->len;
got = Bread(Bi, buf, n);
print(" %6d ", addr);
addr += n;
for (i = 0; i < got; i++)
print("%02x ", buf[i]);
for (j = i; j < 16; j++)
print(" ");
print(" ");
for (i = 0; i < got; i++)
print("%c", isprint(buf[i])? buf[i]: '.');
print("\n");
}
Bseek(Bi, off, 0);
}
vlong
gint(Hdr *h, int n)
{
int i, c;
uvlong vl, rc;
assert(n <= h->got);
rc = 0;
for (i = 0; i < n; i++){
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->got--;
vl = c;
rc |= vl << (8*i);
}
return rc;
}
static int
getrec(Hdr *h, int indent)
{
int c;
h->base = Boffset(Bi);
if ((c = Bgetc(Bi)) == -1)
return -1; // real EOF
h->cont = c & 0x0f;
h->opts = (c >> 4) & 0x0f;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->opts |= c << 4;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->type = c;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->type |= c << 8;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->got = c;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->got |= c << 8;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->got |= c << 16;
if ((c = Bgetc(Bi)) == -1)
sysfatal("unexpected EOF - %r\n");
h->got |= c << 24;
h->len = h->got +8;
if (Debug > 1){
print("%*.3s%s off=%-6lld len=%-6d %d=0x%x=%s\n",
indent, "", (h->cont == Isdir)? "cont": "atom",
h->base, h->len+8, h->type, h->type, rectype(h->type));
if (Debug > 2 && h->cont != Isdir)
xd(h);
}
return 0;
}
void
skip(Hdr *h, vlong n)
{
assert(n <= h->got);
if (Bseek(Bi, n, 1) == -1)
sysfatal("seek failed - %r\n");
h->got -= n;
}
void
putrune(Rune r, int bullet)
{
static int em = 0;
if (Margin && bullet && r != L'\r' && r != L'\n'){
pr("\t• ");
Margin = 0;
}
switch(r){
case L'\n':
case L'\r':
pr("\n");
Margin = 1;
break;
case L'':
em = 1;
break;
case L'': // FIXME: guesswork
pr(" ");
break;
case L' ':
pr("``");
break;
case L' ':
pr("''");
break;
case L'�':
pr("£");
break;
case L' ':
if (Debug)
print("\t");
fmtprint(Fp, "\t");
break;
case L' ':
if (em)
pr("'");
else
pr(" ");
em = 0;
break;
case 0: // ignore embedded nulls
break;
default:
pr("%C", r);
break;
}
}
void
gmem(Hdr *h, void *v, int n)
{
assert(n <= h->got);
if (Bread(Bi, v, n) != n)
sysfatal("unexpected EOF - %r\n");
h->got -= n;
}
/**********************************************/
void
textcharsatom(Hdr *h, int bullet)
{
Rune r;
Margin = 1;
do {
r = Bgetrune(Bi);
h->got -= runelen(r);
putrune(r, bullet);
} while(h->got);
pr("\n");
}
void
textbytesatom(Hdr *h, int bullet)
{
int i;
Rune r;
char buf[UTFmax];
Margin = 1;
do {
i = Bgetc(Bi);
buf[0] = i;
h->got--;
chartorune(&r, buf);
putrune(r, bullet);
} while(h->got);
pr("\n");
}
void
cstring(Hdr *h, int bullet)
{
Rune r;
Margin = 1;
do {
r = Bgetrune(Bi);
h->got -= runelen(r);
putrune(r, bullet);
} while(h->got);
pr("\n");
}
void
persistincrement(Hdr *h)
{
uint x;
int i, num, off, first;
do {
x = gint(h, 4);
first = x & 0xfffff;
num = (x >> 20)&0xfff;
for(i = 0; i < num; i++){
off = gint(h, 4);
sheet(first+i, off);
}
} while(h->got);
}
void
useredit(Hdr *h, int indent)
{
vlong was;
int lastedit, persistdir;
skip(h, 4); // last slide viewed
skip(h, 4); // major ver of app
lastedit = gint(h, 4); // previous user edit
persistdir = gint(h, 4); // directory
skip(h, h->got);
was = Boffset(Bi);
if(lastedit)
parse(lastedit, 0, indent+1);
if(persistdir)
parse(persistdir, 0, indent+1);
Bseek(Bi, was, 0);
}
/*
* This record is special, it occurs only
* in the CurrentUser OLE file where it is the sole record.
* It gives detail of the offset to _start_ walking the UserEdit
* records from in the main PowerPointDocument OLE file.
*/
void
currentuser(Hdr *h)
{
int n;
char *buf;
skip(h, 4); // size of this rec
if(gint(h, 4) != PPTMAGIC)
sysfatal("bad magic number - not a powerpoint file\n");
Start = gint(h, 4);
n = gint(h, 2); // usr name len
buf = malloc(n+2);
skip(h, 4); // file version
skip(h, 1); // app major version
skip(h, 1); // app minor version
gmem(h, buf, n); // user who edited
buf[n] = '\n';
buf[n+1] = 0;
mkfile("/ppt/author", buf, n+1);
skip(h, h->got);
}
void
textheaderatom(Hdr *h, int *type)
{
*type = gint(h, 4); // text block type
if(Debug)
print("#text-type: %d\n", *type);
}
void
blipstoreentry(Hdr *h)
{
Img *i;
int m, w;
char *types[] = {
"err", "unk", "emf.gz", "wmf.gz",
"pict.gz", "jpeg", "png", "dbi"
};
i = growtab(&Imgtab);
w = gint(h, 1);
m = gint(h, 1);
if (w > 1 && w < nelem(types))
i->type = types[w];
else
if (m >= 0 && m < nelem(types))
i->type = types[m];
else
i->type = "bad";
skip(h, 16); // md4 of blip
skip(h, 2); // tag (unused)
i->len = gint(h, 4);
gint(h, 4); // ref count (unused ?)
i->off = gint(h, 4);
skip(h, h->got); // don't care about the rest
}
void
slide(Hdr *h)
{
char places[8];
int flags, geo, master, id;
geo = gint(h, 4); // geometry
gmem(h, places, sizeof(places));
master = gint(h, 4); // master of this slide of 0 if is a master
id = gint(h, 4); // id of this slide
flags = gint(h, 2); // master follow flags
if (Debug)
print("#slide: master-id=%d geo=%d flags=%x id=%d/%x\n",
master, geo, flags, id, id);
skip(h, h->got); // don't care about the rest
Slideno = id;
}
void
slidepersist(Hdr *h)
{
int ref, shapes, ntexts, id;
ref = gint(h, 4); // slide ref
shapes = gint(h, 4); // has shapes
ntexts = gint(h, 4); // num texts
id = gint(h, 4); // slide ID
if (Debug)
print("#slidepersist: ref=%d shapes=%d ntexts=%d id=%d/%x\n",
ref, shapes, ntexts, id, id);
skip(h, h->got); // don't care about the rest
Slideno = id;
}
void
notes(Hdr *h)
{
int flags, id;
id = gint(h, 4); // slide ID these notes relate to
flags = gint(h, 2); // master follow flags
if (Debug)
print("#notes: flags=%x id=%d/%x\n", flags, id, id);
skip(h, h->got); // don't care about the rest
Slideno = id;
}
void
escheropt(Hdr *h)
{
Xref *rf;
int x, blip, off, val, id;
off = 0;
blip = -1;
do{
x = gint(h, 2);
id = x & 0x3fff;
val = gint(h, 4);
if(id == 260)
blip = val;
if((x & 0x8000) != 0) // complex value
off += val;
}while(h->got >= off+6);
skip(h, h->got); // don't care about the rest
if (blip == -1) // only uninteresting info
return;
rf = growtab(&Xreftab);
rf->blip = blip;
rf->slide = Slideno;
if (Debug)
print("#escheropt: blip=%d slide=%d\n", blip-1, Slideno);
}
void
pushimage(Hdr *h, char *ext)
{
int n;
char *p, buf[64];
static int blipno = 1;
skip(h, 16); // md4 sum of image
skip(h, 1); // tag (seems always to be 0xff)
n = h->got;
p = emalloc9p(n);
gmem(h, p, n);
if (Slideno == 0)
snprint(buf, sizeof(buf), "/ppt/master/image.%s", ext);
else
snprint(buf, sizeof(buf), "/ppt/slide%d/image.%s", Slideno, ext);
mkfile(buf, p, n);
if(Debug)
print("#blip type=%s len=%d\n", ext, n);
}
void
pushtext(int type)
{
int n;
char *p, buf[64];
char *types[] = {
"title", "body", "notes", "unused", "other",
"centered-body", "centered-title", "half-body",
"quater-body"
};
p = fmtstrflush(Fp);
if (p == nil || *p == 0 || type < 0 || type >= nelem(types) || Slideno < 0){
free(p);
fmtstrinit(Fp);
return;
}
n = strlen(p);
if (Slideno == 0)
snprint(buf, sizeof(buf), "/ppt/master/%s", types[type]);
else
snprint(buf, sizeof(buf), "/ppt/slide%d/%s", Slideno, types[type]);
mkfile(buf, p, n);
fmtstrinit(Fp);
if(Debug)
print("#text name=%s len=%d\n#%s\n", buf, n, p);
}
int
decode(Hdr *h, int indent)
{
int bullet;
static int type;
/*
- Slide ID is really in the Slide Persist Atom unless the slide is from the
Template
- The slide sequence is listed under the latest 1000 record under 4080 and
the sequence of 1011 shows the list slides ... There is no real Slide
number that I can find.
*/
bullet = (type != 0 && type != 6);
switch (h->type){
case 1011:
slidepersist(h);
break;
case 1007:
slide(h);
break;
case 1009:
notes(h);
break;
case 3999:
textheaderatom(h, &type);
break;
case 4000:
textcharsatom(h, bullet);
pushtext(type);
break;
case 4008:
textbytesatom(h, bullet);
pushtext(type);
break;
case 4026:
cstring(h, bullet);
pushtext(type);
break;
case 4085:
useredit(h, indent+1);
break;
case 4086:
currentuser(h);
break;
case 6002:
persistincrement(h);
break;
case 0xf00b:
escheropt(h);
break;
case 0xf01a:
pushimage(h, "emf.gz");
break;
case 0xf01b:
pushimage(h, "wmf.gz");
break;
case 0xf01c:
pushimage(h, "pict.gz");
break;
case 0xf01d:
pushimage(h, "jpg");
break;
case 0xf01e:
pushimage(h, "png");
break;
case 0xf007:
blipstoreentry(h);
break;
default:
if (h->cont == Isdir)
return parse(-1, h->len, indent+1) +8;
skip(h, h->got);
break;
}
return h->len;
}
int
parse(vlong off, int len, int indent)
{
Hdr h;
int got;
if (off != -1 && Bseek(Bi, off, 0) != off)
sysfatal("seek failed");
got = 0;
do {
if(getrec(&h, indent) == -1)
return -1;
got += decode(&h, indent);
} while((len > 0 && got < len-9) || (len == 0 && got < h.got));
return got;
}
void
fsread(Req *r)
{
Vfile *vf;
vlong offset;
long count;
vf = r->fid->file->aux;
offset = r->ifcall.offset;
count = r->ifcall.count;
if(offset >= vf->len){
r->ofcall.count = 0;
respond(r, nil);
return;
}
if(offset+count >= vf->len)
count = vf->len - offset;
memmove(r->ofcall.data, vf->data+offset, count);
r->ofcall.count = count;
respond(r, nil);
}
void
usage(void)
{
fmtprint(Fp, "usage: %s [-ba] [-Dd] [-s srvname] [-m mtpt] [/mnt/doc/Current␣User "
"/mnt/doc/PowerPoint␣Document /mnt/doc/Pictures]\n", argv0);
exits("usage");
}
void
main(int argc, char **argv)
{
Qid q;
Img *im;
Blk *bk;
Xref *rf;
Fmt fmt;
int i, j, flags;
char *current, *document, *pictures, *srvname, *mtpt;
Fs.tree = alloctree("bill", "trog", DMDIR|0755, nil);
q = Fs.tree->root->qid;
Fp = &fmt;
mtpt = nil;
flags = 0;
srvname = nil;
current="/mnt/doc/Current␣User";
document="/mnt/doc/PowerPoint␣Document";
pictures="/mnt/doc/Pictures";
ARGBEGIN{
case 'D':
chatty9p++;
break;
case 'd':
Debug++;
break;
case 'b':
flags |= MBEFORE;
break;
case 'a':
flags |= MAFTER;
break;
case 's':
srvname = EARGF(usage());
break;
case 'm':
mtpt = EARGF(usage());
break;
default:
usage();
}ARGEND;
if (argc != 0 && argc != 3)
usage();
fmtstrinit(Fp);
if (Debug)
print("\nfile=%s\n", current);
if ((Bi = Bopen(current, OREAD)) == nil)
sysfatal("%s cannot open\n", current);
parse(0, 0, 0);
Bterm(Bi);
if (Debug)
print("\nfile=%s\n", document);
if ((Bi = Bopen(document, OREAD)) == nil)
sysfatal("%s cannot open\n", document);
parse(Start, 0, 0);
qsort(Blktab.table, Blktab.used, Blktab.size, cmp);
for(i = 0; (bk = indextab(&Blktab, i)); i++)
parse(bk->off, 0, 0);
Bterm(Bi);
if (Debug)
print("\nfile=%s\n", pictures);
if ((Bi = Bopen(pictures, OREAD)) != nil){
for(i = 0; (im = indextab(&Imgtab, i)) != nil; i++)
for(j = 0; (rf = indextab(&Xreftab, j)) != nil; j++){
if (rf->blip -1 == i){
Slideno = rf->slide;
parse(im->off, 0, 0);
}
}
Bterm(Bi);
}
if (mtpt == nil)
mtpt = "/mnt/doc/";
if (flags == 0)
flags = MBEFORE;
postmountsrv(&Fs, srvname, mtpt, flags);
exits(0);
}
|
