int linkedgenvertices (edge_t *ep, vertex_t *v0p, vertex_t *v1p) {
if (ep->v0p || ep->v1p) {
SUwarning (1, "linkedgenvertices", "edge %d has vertices", ep->tlid);
return -1;
}
if (v0p) {
ep->v0p = v0p;
if (v0p->edgepl == v0p->edgepn) {
if (!(v0p->edgeps = vmresize (
Vmheap, v0p->edgeps,
(v0p->edgepn * 2) * sizeof (edge_t *), VM_RSCOPY
))) {
SUwarning (1, "linkedgenvertices", "vmresize failed (1)");
return -1;
}
v0p->edgepn *= 2;
}
v0p->edgeps[(ep->v0i = v0p->edgepl++)] = ep;
}
if (v1p) {
ep->v1p = v1p;
if (v1p->edgepl == v1p->edgepn) {
if (!(v1p->edgeps = vmresize (
Vmheap, v1p->edgeps,
(v1p->edgepn * 2) * sizeof (edge_t *), VM_RSCOPY
))) {
SUwarning (1, "linkedgenvertices", "vmresize failed (2)");
return -1;
}
v1p->edgepn *= 2;
}
v1p->edgeps[(ep->v1i = v1p->edgepl++)] = ep;
}
return 0;
}
int linkedgenpolys (edge2polydata_t *e2pdp) {
edge_t *ep;
poly_t *p0p, *p1p, *pp;
if (!(ep = findedge (e2pdp->tlid))) {
SUwarning (1, "linkedgenpolys", "findedge failed");
return -1;
}
p0p = p1p = NULL;
if (e2pdp->polyidl && !(p0p = findpoly (e2pdp->polyidl, e2pdp->cenidl))) {
SUwarning (1, "linkedgenpolys", "findpoly failed for left poly");
return -1;
}
if (e2pdp->polyidr && !(p1p = findpoly (e2pdp->polyidr, e2pdp->cenidr))) {
SUwarning (1, "linkedgenpolys", "findpoly failed for right poly");
return -1;
}
if (
(ep->p0p && p0p && !ep->p1p && !p1p) ||
(!ep->p0p && !p0p && ep->p1p && p1p)
)
pp = p0p, p0p = p1p, p1p = pp;
if ((ep->p0p && p0p) || (ep->p1p && p1p))
SUwarning (1, "linkedgenpolys", "edge has polys attached");
if (p0p && !ep->p0p) {
ep->p0p = p0p;
if (p0p->edgepl == p0p->edgepn) {
if (!(p0p->edgeps = vmresize (
Vmheap, p0p->edgeps,
(p0p->edgepn * 2) * sizeof (edge_t *), VM_RSCOPY
))) {
SUwarning (1, "linkedgenpolys", "vmresize failed (1)");
return -1;
}
p0p->edgepn *= 2;
}
p0p->edgeps[(ep->p0i = p0p->edgepl++)] = ep;
}
if (p1p && !ep->p1p) {
ep->p1p = p1p;
if (p1p->edgepl == p1p->edgepn) {
if (!(p1p->edgeps = vmresize (
Vmheap, p1p->edgeps,
(p1p->edgepn * 2) * sizeof (edge_t *), VM_RSCOPY
))) {
SUwarning (1, "linkedgenpolys", "vmresize failed (2)");
return -1;
}
p1p->edgepn *= 2;
}
p1p->edgeps[(ep->p1i = p1p->edgepl++)] = ep;
}
return 0;
}
int EEcaddvar (int codej) {
int varj, id;
char *np;
np = (char *) &codep[codej].u.s[0];
for (varj = 0; varj < vari; varj++) {
if (strcmp (vars[varj].nam, np) == 0)
return varj;
}
if (vari >= varn) {
if (!(vars = vmresize (
Vmheap, vars, (varn + VARINCR) * VARSIZE, VM_RSCOPY
))) {
SUwarning (0, "EEcaddvar", "cannot resize var array");
return -1;
}
varn += VARINCR;
}
varj = vari++;
vars[varj].id = -1;
for (id = 0; currdict[id]; id++) {
if (strcmp (currdict[id], np) == 0) {
vars[varj].id = id;
break;
}
}
vars[varj].nam = np;
return varj;
}
int EEcstring (char *s, int recheck) {
int codej, size, incr;
char *s1;
size = (strlen (s) + stringoffset + CODESIZE - 1) / CODESIZE;
if (codei + size > coden) {
incr = (size > CODEINCR) ? size : CODEINCR;
if (!(codep = vmresize (
Vmheap, codep, (coden + incr) * CODESIZE, VM_RSCOPY
))) {
SUwarning (0, "EEcnew", "cannot resize code array");
return -1;
}
coden += incr;
}
codej = codei, codei += size;
memset (&codep[codej], 0, sizeof (EEcode_t) * size);
codep[codej].ctype = C_CSTRING;
if (recheck)
for (s1 = s; *s1; s1++)
if (!isalnum (*s1) && *s1 != '_') {
codep[codej].ctype = C_RSTRING;
break;
}
codep[codej].fp = C_NULL;
codep[codej].next = C_NULL;
codep[codej].vari = codep[codej].vali = -1;
strcpy ((char *) &codep[codej].u.s[0], s);
return codej;
}
tmain()
{
Vmalloc_t *vm;
Void_t *dt[10];
int i;
if(!(vm = vmopen(Vmdcsbrk, Vmbest, 0)) )
terror("Couldn't open region");
if(!(dt[0] = vmalloc(vm, 32)) )
terror("vmalloc failed1");
if(!(dt[1] = vmalloc(vm, 32)) )
terror("vmalloc failed2");
if(!(dt[2] = vmalloc(vm, 32)) )
terror("vmalloc failed3");
vmfree(vm,dt[1]);
vmfree(vm,dt[2]);
if(!(dt[0] = vmresize(vm, dt[0], 60, VM_RSCOPY)) )
terror("bestresize did not extend correctly");
if(!(dt[0] = vmresize(vm, dt[0], 32, VM_RSCOPY)) )
terror("bestresize did not reduce correctly2");
if(!(dt[1] = vmalloc(vm, 16)) )
terror("vmalloc failed4");
if(!(dt[2] = vmalloc(vm, 16)) )
terror("vmalloc failed5");
if(!(dt[3] = vmalloc(vm, 24)) )
terror("vmalloc failed6");
if(!(dt[4] = vmalloc(vm, 32)) )
terror("vmalloc failed7");
if(!(dt[5] = vmalloc(vm, 40)) )
terror("vmalloc failed8");
vmfree(vm,dt[2]);
vmfree(vm,dt[3]);
vmfree(vm,dt[4]);
vmfree(vm,dt[5]);
if(!(dt[1] = vmresize(vm,dt[1], 80, VM_RSCOPY)) )
terror("vmresize failed");
vmfree(vm,dt[1]);
if(!(dt[0] = vmresize(vm, dt[0], 120, VM_RSCOPY)) )
terror("vmresize did not extend correctly3");
texit(0);
}
int EEcaddval (int codej) {
int valj;
for (valj = 0; valj < vali; valj++) {
if (vals[valj].type != codep[codej].ctype)
continue;
switch (codep[codej].ctype) {
case C_INTEGER:
if (vals[valj].u.i == codep[codej].u.i)
return valj;
break;
case C_REAL:
if (vals[valj].u.f == codep[codej].u.f)
return valj;
break;
case C_CSTRING:
case C_RSTRING:
if (strcmp (vals[valj].u.s, &codep[codej].u.s[0]) == 0)
return valj;
break;
}
}
if (vali >= valn) {
if (!(vals = vmresize (
Vmheap, vals, (valn + VALINCR) * VALSIZE, VM_RSCOPY
))) {
SUwarning (0, "EEcaddval", "cannot resize val array");
return -1;
}
valn += VALINCR;
}
valj = vali++;
vals[valj].type = codep[codej].ctype;
switch (codep[codej].ctype) {
case C_INTEGER: vals[valj].u.i = codep[codej].u.i; break;
case C_REAL: vals[valj].u.f = codep[codej].u.f; break;
case C_CSTRING: vals[valj].u.s = &codep[codej].u.s[0]; break;
case C_RSTRING: vals[valj].u.s = &codep[codej].u.s[0]; break;
}
return valj;
}
int mergepolys (edge_t *mep) {
int edgepi;
edge_t *ep;
poly_t *p0p, *p1p;
if (!mep->p0p || !mep->p1p) {
SUwarning (
1, "mergepolys", "edge %d does not have both poly pointers",
mep->tlid
);
return -1;
}
if (mep->p0p != mep->p1p) {
if (mep->p1p->edgepl > mep->p0p->edgepl)
p0p = mep->p1p, p1p = mep->p0p;
else
p0p = mep->p0p, p1p = mep->p1p;
if (p0p->edgepl + p1p->edgepl > p0p->edgepn) {
if (!(p0p->edgeps = vmresize (
Vmheap, p0p->edgeps, (p0p->edgepl +
p1p->edgepl) * sizeof (edge_t *), VM_RSCOPY
))) {
SUwarning (1, "mergepolys", "vmresize failed");
return -1;
}
p0p->edgepn = p0p->edgepl + p1p->edgepl;
}
for (edgepi = 0; edgepi < p1p->edgepl; edgepi++) {
ep = p1p->edgeps[edgepi];
if (ep->p0p == p1p)
ep->p0p = p0p, ep->p0i = p0p->edgepl;
else if (ep->p1p == p1p)
ep->p1p = p0p, ep->p1i = p0p->edgepl;
p0p->edgeps[p0p->edgepl++] = ep;
}
p1p->edgepl = 0;
destroypoly (p1p);
}
destroyedge (mep);
return 0;
}
int EEcnew (int ctype) {
int codej;
if (codei >= coden) {
if (!(codep = vmresize (
Vmheap, codep, (coden + CODEINCR) * CODESIZE, VM_RSCOPY
))) {
SUwarning (0, "EEcnew", "cannot resize code array");
return -1;
}
coden += CODEINCR;
}
codej = codei++;
memset (&codep[codej], 0, sizeof (EEcode_t));
codep[codej].ctype = ctype;
codep[codej].fp = C_NULL;
codep[codej].next = C_NULL;
codep[codej].vari = codep[codej].vali = -1;
return codej;
}
int main (int argc, char **argv) {
int norun;
char *mapnamep, mapmode, *onamep, *classp;
int keytype, keylen, valtype, vallen, dictincr, itemincr;
AGGRfile_t *iafp, *oafp;
char file[PATH_MAX];
Sfio_t *fp;
AGGRreaggr_t *reaggrs;
int reaggrn, reaggrl;
int count, rejcount;
char *line, *s;
unsigned char *ikeyp, *okeyp;
char *avs[10];
int avn;
int ret;
if (AGGRinit () == -1)
SUerror ("aggrreaggr", "init failed");
mapnamep = NULL, mapmode = 0;
onamep = "reaggr.aggr";
classp = "aggrreaggr";
keytype = AGGR_TYPE_STRING;
keylen = -1;
valtype = -1, vallen = -1;
dictincr = 1, itemincr = 1;
norun = 0;
for (;;) {
switch (optget (argv, usage)) {
case -100:
onamep = opt_info.arg;
continue;
case -101:
classp = opt_info.arg;
continue;
case -102:
if (AGGRparsetype (opt_info.arg, &keytype, &keylen) == -1)
SUerror ("aggrreaggr", "bad argument for -kt option");
continue;
case -103:
if (AGGRparsetype (opt_info.arg, &valtype, &vallen) == -1)
SUerror ("aggrreaggr", "bad argument for -vt option");
continue;
case -104:
dictincr = opt_info.num;
continue;
case -105:
itemincr = opt_info.num;
continue;
case -114:
mapnamep = opt_info.arg;
mapmode = 'a';
continue;
case -115:
mapnamep = opt_info.arg;
mapmode = 'b';
continue;
case -999:
SUwarnlevel++;
continue;
case '?':
SUusage (0, "aggrreaggr", opt_info.arg);
norun = 1;
continue;
case ':':
SUusage (1, "aggrreaggr", opt_info.arg);
norun = 2;
continue;
}
break;
}
if (norun)
return norun - 1;
argc -= opt_info.index, argv += opt_info.index;
if (argc != 1)
SUerror ("aggrreaggr", "no input file name specified");
if (!mapnamep)
SUerror ("aggrreaggr", "no map file name specified");
if (!(iafp = AGGRopen (argv[0], AGGR_RWMODE_RD, 1, TRUE)))
SUerror ("aggrreaggr", "open failed");
if (valtype == -1) {
valtype = AGGR_TYPE_FLOAT;
vallen = (
iafp->hdr.vallen / AGGRtypelens[iafp->hdr.valtype]
) * AGGRtypelens[valtype];
}
if (!(oafp = AGGRcreate (
onamep, 1, 1, keytype, valtype, classp,
keylen, vallen, dictincr, itemincr, 1, TRUE
)))
SUerror ("aggrreaggr", "create failed");
if (strcmp (mapnamep, "-") == 0)
fp = sfstdin;
else {
if (access (mapnamep, R_OK) == 0)
strcpy (file, mapnamep);
else if (!pathaccess (
getenv ("PATH"), "../lib/aggr", mapnamep, R_OK, file, PATH_MAX
))
SUerror ("aggrreaggr", "cannot find map file");
if (!(fp = sfopen (NULL, file, "r")))
SUerror ("aggrreaggr", "sfopen failed");
}
sfsetbuf (fp, NULL, 1048576);
if (iafp->ad.keylen != -1)
if (!(ikeyp = vmalloc (Vmheap, iafp->ad.keylen)))
SUerror ("aggrreaggr", "vmalloc failed");
if (oafp->ad.keylen != -1)
if (!(okeyp = vmalloc (Vmheap, oafp->ad.keylen)))
SUerror ("aggrreaggr", "vmalloc failed");
if (!(reaggrs = vmalloc (Vmheap, 100 * sizeof (AGGRreaggr_t))))
SUerror ("aggrreaggr", "vmalloc failed");
reaggrn = 100, reaggrl = 0;
count = 0, rejcount = 0;
switch (mapmode) {
case 'a':
while ((line = sfgetr (fp, '\n', 1))) {
count++;
if ((avn = tokscan (line, &s, " %v ", avs, 10)) < 1 || avn > 2) {
SUwarning (1, "aggrreaggr", "bad line %d", count);
rejcount++;
continue;
}
if (reaggrl >= reaggrn) {
if (!(reaggrs = vmresize (
Vmheap, reaggrs, reaggrn * 2 * sizeof (AGGRreaggr_t),
VM_RSCOPY
)))
SUerror ("aggrreaggr", "vmresize failed");
reaggrn *= 2;
}
if (_aggrdictscankey (iafp, avs[0], &ikeyp) == -1) {
SUwarning (1, "aggrreaggr", "bad key at line %d", count);
rejcount++;
continue;
}
reaggrs[reaggrl].okeyp = copy (iafp, ikeyp);
if (_aggrdictscankey (oafp, avs[1], &okeyp) == -1) {
SUwarning (1, "aggrreaggr", "bad key at line %d", count);
rejcount++;
continue;
}
reaggrs[reaggrl].nkeyp = copy (oafp, okeyp);
if (avn == 3)
reaggrs[reaggrl].nitemi = atoi (avs[2]);
else
reaggrs[reaggrl].nitemi = -1;
reaggrl++;
if (count % 10000 == 0)
SUmessage (
1, "aggrreaggr", "processed %d lines, dropped %d",
count, rejcount
);
}
break;
case 'b':
while (1) {
if (reaggrl >= reaggrn) {
if (!(reaggrs = vmresize (
Vmheap, reaggrs, reaggrn * 2 * sizeof (AGGRreaggr_t),
VM_RSCOPY
)))
SUerror ("aggrreaggr", "vmresize failed");
reaggrn *= 2;
}
if (iafp->ad.keylen == -1) {
if (!(ikeyp = (unsigned char *) sfgetr (fp, 0, 1))) {
if (sfvalue (fp) != 0)
SUerror ("aggrreaggr", "bad entry %d", reaggrl);
else
break;
}
} else {
if ((ret = sfread (fp, ikeyp, iafp->ad.keylen)) == 0)
break;
else if (ret != iafp->ad.keylen)
SUerror ("aggrreaggr", "bad entry %d", reaggrl);
SWAPKEY (ikeyp, iafp->hdr.keytype, iafp->ad.keylen);
}
reaggrs[reaggrl].okeyp = copy (iafp, ikeyp);
if (oafp->ad.keylen == -1) {
if (!(okeyp = (unsigned char *) sfgetr (fp, 0, 1))) {
if (sfvalue (fp) != 0)
SUerror ("aggrreaggr", "bad entry %d", reaggrl);
else
break;
}
} else {
if ((ret = sfread (fp, okeyp, oafp->ad.keylen)) == 0)
break;
else if (ret != oafp->ad.keylen)
SUerror ("aggrreaggr", "bad entry %d", reaggrl);
}
reaggrs[reaggrl].nkeyp = copy (oafp, okeyp);
count++;
reaggrs[reaggrl].nitemi = -1;
reaggrl++;
if (count % 10000 == 0)
SUmessage (
1, "aggrreaggr", "processed %d lines, dropped %d",
count, rejcount
);
}
break;
}
SUmessage (
rejcount > 0 ? 0 : 1,
"aggrreaggr", "processed %d lines, dropped %d", count, rejcount
);
if (AGGRreaggr (iafp, reaggrs, reaggrl, oafp) == -1)
SUerror ("aggrreaggr", "reaggr failed");
if (AGGRminmax (oafp, TRUE) == -1)
SUerror ("aggrreaggr", "minmax failed");
if (AGGRclose (oafp) == -1)
SUerror ("aggrreaggr", "close failed");
if (AGGRterm () == -1)
SUerror ("aggrreaggr", "term failed");
return 0;
}
tmain()
{
Obj_t *o, *next;
Void_t *huge;
size_t hugesz;
Vmstat_t sb;
ssize_t k, p;
srandom(0);
hugesz = Z_HUGE; /* one huge block to be resized occasionally */
if(!(huge = vmalloc(Vmregion, hugesz)) )
terror("Can't allocate block");
for(k = 0; k < N_OBJ; ++k)
{
/* free/resize all on this list */
for(o = List[k]; o; o = next)
{ next = o->next;
if((RAND()%2) == 0 ) /* flip a coin to see if freeing */
vmfree(Vmregion, o->obj);
else /* resizing */
{ o->size = ALLOCSIZE();
if(!(o->obj = vmresize(Vmregion,o->obj,o->size,VM_RSMOVE)) )
terror("Vmresize failed");
TIME(p, k, o->size); /* add to a future list */
o->next = List[p]; List[p] = o;
}
}
if(COMPACT(k)) /* global compaction */
{ if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Arena: busy=(%u,%u) free=(%u,%u) extent=%u #segs=%d",
sb.n_busy,sb.s_busy, sb.n_free,sb.s_free,
sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: busy=(%u,%u) free=(%u,%u) extent=%u #segs=%d",
sb.n_busy,sb.s_busy, sb.n_free,sb.s_free,
sb.extent, sb.n_seg);
}
if(RESIZE(k)) /* make the huge block bigger */
{ hugesz += Z_HUGE;
if(!(huge = vmresize(Vmregion, huge, hugesz, VM_RSMOVE)) )
terror("Bad resize of huge block");
}
o = Obj+k; /* allocate a new block */
o->size = ALLOCSIZE();
if(!(o->obj = vmalloc(Vmregion, o->size)) )
terror("Vmalloc failed");
TIME(p, k, o->size);
o->next = List[p]; List[p] = o;
}
if(vmdbcheck(Vmregion) < 0)
terror("Corrupted region");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Full: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
/* now free all left-overs */
for(o = List[N_OBJ]; o; o = o->next)
vmfree(Vmregion,o->obj);
vmfree(Vmregion,huge);
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Free: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(vmcompact(Vmregion) < 0 )
terror("Vmcompact failed2");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Compact: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
if(!(huge = vmalloc(Vmregion, 10)))
terror("Vmalloc failed");
if(vmstat(Vmregion, &sb) < 0)
terror("Vmstat failed");
tinfo("Small: Busy=(%u,%u) Free=(%u,%u) Extent=%u #segs=%d\n",
sb.n_busy, sb.s_busy, sb.n_free, sb.s_free, sb.extent, sb.n_seg);
texit(0);
}
int SWMIopnexec (state_t *sp) {
char q[1024], opnstr[1024], *name, *origname, *s;
opn_t *opnp, *opnbasep, *opntimep, *opnfreqp;
obj_t *objp;
HRESULT hr;
BSTR propb, ctb, wqlb, qb;
SAFEARRAY *props;
VARIANT var;
LONG pu, pl, pi;
ULONG ul;
double v;
kvt_t *kvtp;
int kvti;
ctb = s2b ("countertype");
wqlb = s2b ("WQL");
for (
objp = (obj_t *) dtfirst (objdict); objp;
objp = (obj_t *) dtnext (objdict, objp)
) {
sfsprintf (q, 1024, "select * from %s", objp->obj);
if (verbose)
sfprintf (sfstderr, "query: %s\n", q);
if (!(qb = s2b (q))) {
sfprintf (sfstderr, "cannot convert obj name %s to bstr\n", objp->obj);
return -1;
}
if ((hr = sp->pSvc->ExecQuery (
wqlb, qb, WBEM_FLAG_FORWARD_ONLY | WBEM_FLAG_RETURN_IMMEDIATELY,
0, &sp->pEnum
)) != S_OK) {
sfprintf (
sfstderr, "cannot execute query %s, error %s\n", q, E2ccp (hr)
);
return -1;
}
if (SWMIproxysecurity (sp, sp->pEnum) < 0) {
sfprintf (sfstderr, "cannot enable security for query %s\n", q);
return -1;
}
while (
sp->pEnum->Next (30 * 1000, 1, &sp->pClsObj, &ul
) == S_OK && ul == 1) {
if ((hr = sp->pClsObj->GetNames (
0, WBEM_FLAG_ALWAYS | WBEM_FLAG_NONSYSTEM_ONLY, 0, &props
)) != S_OK) {
sfprintf (
sfstderr, "cannot get props for obj %s, error %s\n",
objp->obj, E2ccp (hr)
);
return -1;
}
if(
(hr = SafeArrayGetLBound (props, 1, &pl)) != S_OK ||
(hr = SafeArrayGetUBound (props, 1, &pu)) != S_OK
) {
sfprintf (
sfstderr, "cannot get props bounds for %s, error %s\n",
objp->obj, E2ccp (hr)
);
return -1;
}
if (pu - pl + 1 > kvtn) {
kvtn = pu - pl + 1;
if (!(kvts = (kvt_t *) vmresize (
Vmheap, kvts, kvtn * sizeof (kvt_t), VM_RSCOPY
))) {
sfprintf (sfstderr, "cannot grow kvt array\n");
return -1;
}
}
name = NULL;
for (pi = pl, kvtl = 0; pi <= pu; pi++, kvtl++) {
kvtp = &kvts[kvtl];
if ((hr = SafeArrayGetElement (props, &pi, &propb)) != S_OK) {
sfprintf (
sfstderr, "cannot get prop name for %d/%s, error %s\n",
pi, objp->obj, E2ccp (hr)
);
continue;
}
kvtp->kp = (char *) b2s (propb);
if ((hr = sp->pClsObj->Get (propb, 0, &var, 0, 0)) != S_OK) {
sfprintf (
sfstderr, "cannot get prop value for %d/%s, error %s\n",
pi, objp->obj, E2ccp (hr)
);
continue;
}
if (
!(kvtp->vp = (char *) V2ccp (&var)) ||
!(kvtp->vp = vmstrdup (Vmheap, kvtp->vp))
) {
kvtl--;
continue;
}
switch (var.vt) {
case VT_UI1: kvtp->v = var.bVal; break;
case VT_I2: kvtp->v = var.iVal; break;
case VT_I4: kvtp->v = var.lVal; break;
default: kvtp->v = strtoull (kvtp->vp, &s, 10); break;
}
if (strcmp (kvtp->kp, "Name") == 0) {
if (var.vt == VT_NULL)
name = "ALL";
else
name = kvtp->vp;
origname = name;
}
if ((hr = sp->pClsObj->GetPropertyQualifierSet (
propb, &sp->pQualSet
)) != S_OK) {
sfprintf (
sfstderr, "cannot get quals for %d/%s, error %s\n",
pi, objp->obj, E2ccp (hr)
);
continue;
}
kvtp->type = V_TYPE_STRING;
if ((hr = sp->pQualSet->Get (
ctb, 0, &var, 0
)) == S_OK && var.vt == VT_I4) {
switch (var.lVal) {
case PERF_COUNTER_RAWCOUNT:
case PERF_COUNTER_LARGE_RAWCOUNT:
kvtp->type = V_TYPE_SIMPLE; break;
case PERF_RAW_FRACTION:
kvtp->type = V_TYPE_WITHBASE; break;
case PERF_RAW_BASE:
case PERF_PRECISION_TIMESTAMP:
kvtp->type = V_TYPE_ISBASE; break;
case PERF_COUNTER_COUNTER:
case PERF_COUNTER_BULK_COUNT:
kvtp->type = V_TYPE_WITHTIMENFREQ; break;
case PERF_100NSEC_TIMER:
kvtp->type = V_TYPE_WITH100NSEC; break;
case PERF_100NSEC_TIMER_INV:
kvtp->type = V_TYPE_WITH100NSECINV; break;
default:
kvtp->type = V_TYPE_SIMPLE; break;
}
} else {
if (strcmp (kvtp->kp, "Timestamp_PerfTime") == 0)
kvtp->type = V_TYPE_ISTIME;
else if (strcmp (kvtp->kp, "Frequency_PerfTime") == 0)
kvtp->type = V_TYPE_ISFREQ;
else if (strcmp (kvtp->kp, "Timestamp_Sys100NS") == 0)
kvtp->type = V_TYPE_IS100NSEC;
else if (kvtp->vp[0] == 0 || isdigit (kvtp->vp[0]))
kvtp->type = V_TYPE_SIMPLE;
}
}
::SafeArrayDestroy (props);
sp->pClsObj->Release ();
for (kvti = 0; kvti < kvtl; kvti++) {
kvtp = &kvts[kvti];
sfsprintf (opnstr, 1024, "%s.%s.%s", objp->obj, kvtp->kp, name);
if (!(opnp = (opn_t *) dtmatch (opndict, opnstr))) {
sfsprintf (opnstr, 1024, "%s.%s.ALL", objp->obj, kvtp->kp);
if ((opnp = (opn_t *) dtmatch (opndict, opnstr)))
name = "ALL";
else
sfsprintf (opnstr, 1024, "%s.%s.%s", objp->obj, kvtp->kp, name);
}
if (!opnp) {
if (kvtp->type < V_TYPE_SUPPORT)
continue;
if (!(opnp = opninsert (
OPN_KIND_S, "", "", "", objp->obj, kvtp->kp, name, ""
))) {
sfprintf (sfstderr, "cannot insert opn\n");
return -1;
}
opnp->objp = objp;
}
if (opnp->ep && strstr (origname, opnp->ep))
continue;
if (opnp->type == 0)
opnp->type = kvtp->type;
opnp->vp = kvtp->vp;
opnp->cv += kvtp->v;
opnp->havec = TRUE;
}
for (kvti = 0; kvti < kvtl; kvti++) {
kvtp = &kvts[kvti];
sfsprintf (opnstr, 1024, "%s.%s.SUM", objp->obj, kvtp->kp);
if (!(opnp = (opn_t *) dtmatch (opndict, opnstr)))
continue;
if (opnp->ep && strstr (origname, opnp->ep))
continue;
if (opnp->type == 0)
opnp->type = kvtp->type;
opnp->vp = kvtp->vp;
opnp->cv += kvtp->v;
opnp->havec = TRUE;
}
}
}
for (
opnp = (opn_t *) dtfirst (opndict); opnp;
opnp = (opn_t *) dtnext (opndict, opnp)
) {
if (opnp->kind != OPN_KIND_P || !opnp->havec)
continue;
if (opnp->type >= V_TYPE_SUPPORT)
continue;
switch (opnp->type) {
case V_TYPE_STRING:
#if 0
sfprintf (
sfstdout, "rt=STAT type=string name=%s str=%s%s%s%s\n",
opnp->mname, opnp->vp,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
#endif
break;
case V_TYPE_SIMPLE:
sfprintf (
sfstdout, "rt=STAT type=%s name=%s unit=%s num=%lld%s%s%s\n",
opnp->mtype, opnp->mname, opnp->munit, opnp->cv,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
break;
case V_TYPE_WITHBASE:
sfsprintf (opnstr, 1024, "%s.%s_Base.%s", opnp->op, opnp->pp, opnp->np);
if (!(opnbasep = (opn_t *) dtmatch (opndict, opnstr))) {
sfprintf (sfstderr, "cannot find base property for %s\n", opnp->opn);
continue;
}
if (!opnbasep->havec)
continue;
if ((v = (opnbasep->cv == 0) ? 0.00 : 100.0 * (
opnp->cv / (double) opnbasep->cv
)) < 0.0)
continue;
sfprintf (
sfstdout, "rt=STAT type=%s name=%s unit=%s num=%lf%s%s%s\n",
opnp->mtype, opnp->mname, opnp->munit, v,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
break;
case V_TYPE_WITHTIMENFREQ:
if (!opnp->havep)
continue;
sfsprintf (opnstr, 1024, "%s.Timestamp_PerfTime.%s", opnp->op, opnp->np);
if (!(opntimep = (opn_t *) dtmatch (opndict, opnstr))) {
sfprintf (sfstderr, "cannot find time property for %s\n", opnp->opn);
continue;
}
if (!opntimep->havec || !opntimep->havep)
continue;
sfsprintf (opnstr, 1024, "%s.Frequency_PerfTime.%s", opnp->op, opnp->np);
if (!(opnfreqp = (opn_t *) dtmatch (opndict, opnstr))) {
sfprintf (sfstderr, "cannot find freq property for %s\n", opnp->opn);
continue;
}
if (!opnfreqp->havec)
continue;
if (
opnp->cv < opnp->pv || opntimep->cv <= opntimep->pv ||
opnfreqp->cv == 0
)
continue;
if ((v = (opnp->cv - opnp->pv) / (
(opntimep->cv - opntimep->pv) / (double) opnfreqp->cv
)) < 0.0) {
if (v > -1)
v = 0.0;
else
continue;
}
sfprintf (
sfstdout, "rt=STAT type=%s name=%s unit=%s num=%lf%s%s%s\n",
opnp->mtype, opnp->mname, opnp->munit, v,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
break;
case V_TYPE_WITH100NSEC:
case V_TYPE_WITH100NSECINV:
if (!opnp->havep)
continue;
sfsprintf (opnstr, 1024, "%s.Timestamp_Sys100NS.%s", opnp->op, opnp->np);
if (!(opntimep = (opn_t *) dtmatch (opndict, opnstr))) {
sfprintf (sfstderr, "cannot find time property for %s\n", opnp->opn);
continue;
}
if (!opntimep->havec || !opntimep->havep)
continue;
if (opnp->cv < opnp->pv || opntimep->cv <= opntimep->pv)
continue;
if (opnp->type == V_TYPE_WITH100NSEC) {
if ((v = 100.0 * (
(opnp->cv - opnp->pv) /
((double) opntimep->cv - opntimep->pv)
)) < 0.0) {
if (v > -1)
v = 0.0;
else
continue;
}
sfprintf (
sfstdout, "rt=STAT type=%s name=%s unit=%s num=%lf%s%s%s\n",
opnp->mtype, opnp->mname, opnp->munit, v,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
} else {
if ((v = 100.0 * (
1.0 - (opnp->cv - opnp->pv) /
((double) opntimep->cv - opntimep->pv)
)) < 0.0) {
if (v > -1)
v = 0.0;
else
continue;
}
sfprintf (
sfstdout, "rt=STAT type=%s name=%s unit=%s num=%lf%s%s%s\n",
opnp->mtype, opnp->mname, opnp->munit, v,
(opnp->lp[0]) ? " label='" : "", (opnp->lp[0]) ? opnp->lp : "",
(opnp->lp[0]) ? "'" : ""
);
}
break;
}
}
return 0;
}
static int recparse (
XMLnode_t *xp, EMrec_t *crecs, int crecn, EMrec_t *drecs, int drecn,
int dir, EMbb_t *bbp
) {
EMrec_t *recs, *recp;
int reci, recj, recn, ri;
RIop_t *opp, top;
int opi, opk, opl;
EMbb_t cbb;
EMimage_t *ip, *imem;
XMLnode_t *cp, *pp, *tp, *fnp, *fsp, *clp;
char *fs, *fn, *cl;
int ci;
int dw, dh;
if (xp->type == XML_TYPE_TEXT) {
SUwarning (0, "recparse", "called with text node");
return -1;
}
opk = EMopm;
bbp->w = bbp->h = 0;
for (ci = 0; ci < xp->nodem; ci++) {
cp = xp->nodes[ci];
if (cp->type == XML_TYPE_TEXT)
continue;
if (strcmp (cp->tag, "v") == 0 || strcmp (cp->tag, "h") == 0) {
opl = EMopm;
if (recparse (
cp, crecs, crecn, drecs, drecn,
(cp->tag[0] == 'v') ? EM_DIR_V : EM_DIR_H, &cbb
) == -1) {
SUwarning (0, "recparse", "cannot parse v list");
return -1;
}
if (dir == EM_DIR_H) {
for (opi = opl; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I) {
EMops[opi].u.img.rx += bbp->w;
EMops[opi].u.img.ry += (bbp->h - cbb.h) / 2;
} else if (EMops[opi].type == RI_OP_T) {
EMops[opi].u.text.p.x += bbp->w;
EMops[opi].u.text.p.y += (bbp->h - cbb.h) / 2;
}
}
bbp->w += cbb.w;
if (bbp->h < cbb.h) {
dh = cbb.h - bbp->h;
bbp->h = cbb.h;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.ry += dh / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.y += dh / 2;
}
}
} else {
for (opi = opl; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I) {
EMops[opi].u.img.ry += bbp->h;
EMops[opi].u.img.rx += (bbp->w - cbb.w) / 2;
} else if (EMops[opi].type == RI_OP_T) {
EMops[opi].u.text.p.y += bbp->h;
EMops[opi].u.text.p.x += (bbp->w - cbb.w) / 2;
}
}
bbp->h += cbb.h;
if (bbp->w < cbb.w) {
dw = cbb.w - bbp->w;
bbp->w = cbb.w;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.rx += dw / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.x += dw / 2;
}
}
}
} else if (strcmp (cp->tag, "rimg") == 0) {
if (!(tp = XMLfind (cp, "path", XML_TYPE_TEXT, -1, TRUE))) {
SUwarning (0, "recparse", "cannot find rimg/path");
continue;
}
if (!(ip = dtmatch (imagedict, tp->text))) {
if (!(imem = vmalloc (Vmheap, sizeof (EMimage_t)))) {
SUwarning (0, "recparse", "cannot allocate imem");
return -1;
}
memset (imem, 0, sizeof (EMimage_t));
if (!(imem->file = vmstrdup (Vmheap, tp->text))) {
SUwarning (0, "recparse", "cannot copy image file");
return -1;
}
if (!(ip = dtinsert (imagedict, imem))) {
SUwarning (0, "recparse", "cannot insert image");
vmfree (Vmheap, imem->file);
vmfree (Vmheap, imem);
return -1;
}
if (RIloadimage (ip->file, &ip->op) == -1) {
SUwarning (0, "recparse", "cannot load image");
continue;
}
}
if (ip->op.type == RI_OP_NOOP) {
if ((pp = XMLfind (cp, "alt", XML_TYPE_TAG, -1, TRUE))) {
if (recparse (
pp, crecs, crecn, drecs, drecn, dir, &cbb
) == -1) {
SUwarning (0, "recparse", "cannot parse alt tag");
return -1;
}
if (dir == EM_DIR_H) {
bbp->w += cbb.w;
if (bbp->h < cbb.h) {
dh = cbb.h - bbp->h;
bbp->h = cbb.h;
}
} else {
bbp->h += cbb.h;
if (bbp->w < cbb.w) {
dw = cbb.w - bbp->w;
bbp->w = cbb.w;
}
}
}
} else {
if (EMopm >= EMopn) {
if (!(EMops = vmresize (
Vmheap, EMops, (EMopn + 100) * sizeof (RIop_t),
VM_RSCOPY
))) {
SUwarning (0, "recparse", "cannot grow EMops array");
return -1;
}
EMopn += 100;
}
opp = &EMops[EMopm++];
*opp = ip->op;
if (dir == EM_DIR_H) {
opp->u.img.rx = bbp->w + EM_MARGIN_W / 2;
opp->u.img.ry = (bbp->h - opp->u.img.ih) / 2;
bbp->w += opp->u.img.iw + EM_MARGIN_W;
if (bbp->h < opp->u.img.ih + EM_MARGIN_H) {
dh = opp->u.img.ih + EM_MARGIN_H - bbp->h;
bbp->h = opp->u.img.ih + EM_MARGIN_H;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.ry += dh / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.y += dh / 2;
}
}
} else {
opp->u.img.rx = (bbp->w - opp->u.img.iw) / 2;
opp->u.img.ry = bbp->h + EM_MARGIN_H / 2;
if (bbp->w < opp->u.img.iw + EM_MARGIN_W) {
dw = opp->u.img.iw + EM_MARGIN_W - bbp->w;
bbp->w = opp->u.img.iw + EM_MARGIN_W;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.rx += dw / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.x += dw / 2;
}
}
bbp->h += opp->u.img.ih + EM_MARGIN_H;
}
}
} else if (strcmp (cp->tag, "qimg") == 0) {
if (!(tp = XMLfind (cp, "path", XML_TYPE_TEXT, -1, TRUE))) {
SUwarning (0, "recparse", "cannot find qimg/path");
continue;
}
for (ri = 0; ri < 2; ri++) {
if (ri == 0)
recs = crecs, recn = crecn;
else
recs = drecs, recn = drecn;
recj = -1;
for (reci = 0; reci < recn; reci++) {
recp = &recs[reci];
if (strcmp (recp->id, tp->text) != 0)
continue;
if (recp->type == EM_TYPE_I) {
recj = reci;
if (!(ip = dtmatch (imagedict, recp->u.i.file))) {
if (!(imem = vmalloc (
Vmheap, sizeof (EMimage_t)
))) {
SUwarning (
0, "recparse", "cannot allocate imem"
);
return -1;
}
memset (imem, 0, sizeof (EMimage_t));
if (!(imem->file = vmstrdup (
Vmheap, recp->u.i.file
))) {
SUwarning (
0, "recparse", "cannot copy image file"
);
return -1;
}
if (!(ip = dtinsert (imagedict, imem))) {
SUwarning (
0, "recparse", "cannot insert image"
);
vmfree (Vmheap, imem->file);
vmfree (Vmheap, imem);
return -1;
}
if (RIloadimage (ip->file, &ip->op) == -1) {
SUwarning (0, "recparse", "cannot load image");
continue;
}
}
if (EMopm >= EMopn) {
if (!(EMops = vmresize (
Vmheap, EMops, (EMopn + 100) * sizeof (RIop_t),
VM_RSCOPY
))) {
SUwarning (
0, "recparse", "cannot grow EMops array"
);
return -1;
}
EMopn += 100;
}
opp = &EMops[EMopm++];
*opp = ip->op;
opp->u.img.ix = recp->u.i.x1;
opp->u.img.iy = recp->u.i.y1;
opp->u.img.iw = recp->u.i.x2 - recp->u.i.x1 + 1;
opp->u.img.ih = recp->u.i.y2 - recp->u.i.y1 + 1;
if (dir == EM_DIR_H) {
opp->u.img.rx = bbp->w + EM_MARGIN_W / 2;
opp->u.img.ry = (bbp->h - opp->u.img.ih) / 2;
bbp->w += opp->u.img.iw + EM_MARGIN_W;
if (bbp->h < opp->u.img.ih + EM_MARGIN_H) {
dh = opp->u.img.ih + EM_MARGIN_H - bbp->h;
bbp->h = opp->u.img.ih + EM_MARGIN_H;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.ry += dh / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.y += dh / 2;
}
}
} else {
opp->u.img.rx = (bbp->w - opp->u.img.iw) / 2;
opp->u.img.ry = bbp->h + EM_MARGIN_H / 2;
if (bbp->w < opp->u.img.iw + EM_MARGIN_W) {
dw = opp->u.img.iw + EM_MARGIN_W - bbp->w;
bbp->w = opp->u.img.iw + EM_MARGIN_W;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.rx += dw / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.x += dw / 2;
}
}
bbp->h += opp->u.img.ih + EM_MARGIN_H;
}
} else if (recp->type == EM_TYPE_S) {
recj = reci;
if (EMopm + 3 >= EMopn) {
if (!(EMops = vmresize (
Vmheap, EMops, (EMopn + 100) * sizeof (RIop_t),
VM_RSCOPY
))) {
SUwarning (
0, "recparse", "cannot grow EMops array"
);
return -1;
}
EMopn += 100;
}
if (recp->u.s.lncl && recp->u.s.lncl[0]) {
opp = &EMops[EMopm++];
opp->type = RI_OP_COPYc;
opp->u.color.n = 1;
opp->u.color.t = recp->u.s.lncl;
}
if (recp->u.s.fncl && recp->u.s.fncl[0]) {
opp = &EMops[EMopm++];
opp->type = RI_OP_COPYFC;
opp->u.color.n = 1;
opp->u.color.t = recp->u.s.fncl;
}
if (recp->u.s.flcl && recp->u.s.flcl[0]) {
opp = &EMops[EMopm++];
opp->type = RI_OP_COPYC;
opp->u.color.n = 1;
opp->u.color.t = recp->u.s.flcl;
}
}
}
if (recj != -1)
break;
}
} else if (strcmp (cp->tag, "label") == 0) {
if (!(fnp = XMLfind (cp, "fontname", XML_TYPE_TEXT, -1, TRUE)))
fn = "abc";
else
fn = fnp->text;
if (!(fsp = XMLfind (cp, "fontsize", XML_TYPE_TEXT, -1, TRUE)))
fs = "10";
else
fs = fsp->text;
if (!(clp = XMLfind (cp, "color", XML_TYPE_TEXT, -1, TRUE)))
cl = NULL;
else
cl = clp->text;
if (!(tp = XMLfind (cp, "text", XML_TYPE_TEXT, -1, TRUE)))
continue;
if (RIgettextsize (tp->text, fn, fs, &top) == -1) {
SUwarning (0, "recparse", "cannot get text size");
return -1;
}
top.u.font.w += 8, top.u.font.h += 4;
if (EMopm + 3 >= EMopn) {
if (!(EMops = vmresize (
Vmheap, EMops, (EMopn + 100) * sizeof (RIop_t), VM_RSCOPY
))) {
SUwarning (0, "recparse", "cannot grow EMops array");
return -1;
}
EMopn += 100;
}
opp = &EMops[EMopm++];
*opp = top;
opp->type = RI_OP_F;
if (cl) {
opp = &EMops[EMopm++];
memset (opp, 0, sizeof (RIop_t));
opp->type = RI_OP_FC;
if (!(opp->u.color.t = vmstrdup (Vmheap, cl))) {
SUwarning (0, "recparse", "cannot copy color");
return -1;
}
}
opp = &EMops[EMopm++];
memset (opp, 0, sizeof (RIop_t));
opp->type = RI_OP_T;
opp->u.text.jx = 0;
opp->u.text.jy = -1;
opp->u.text.w = top.u.font.w - 8;
opp->u.text.h = top.u.font.h - 4;
if (!(opp->u.text.t = vmstrdup (Vmheap, tp->text))) {
SUwarning (0, "recparse", "cannot copy text");
return -1;
}
if (dir == EM_DIR_H) {
opp->u.text.p.x = bbp->w + top.u.font.w / 2 + 4;
opp->u.text.p.y = (bbp->h - top.u.font.h) / 2 + 2;
bbp->w += top.u.font.w + EM_MARGIN_W;
if (bbp->h < top.u.font.h + EM_MARGIN_H) {
dh = top.u.font.h + EM_MARGIN_H - bbp->h;
bbp->h = top.u.font.h + EM_MARGIN_H;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.ry += dh / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.y += dh / 2;
}
}
} else {
opp->u.text.p.x = bbp->w / 2 + 0;
opp->u.text.p.y = bbp->h + EM_MARGIN_H / 2 + 2;
if (bbp->w < top.u.font.w + EM_MARGIN_W) {
dw = top.u.font.w + EM_MARGIN_W - bbp->w;
bbp->w = top.u.font.w + EM_MARGIN_W;
for (opi = opk; opi < EMopm; opi++) {
if (EMops[opi].type == RI_OP_I)
EMops[opi].u.img.rx += dw / 2;
else if (EMops[opi].type == RI_OP_T)
EMops[opi].u.text.p.x += dw / 2;
}
}
bbp->h += top.u.font.h + EM_MARGIN_H;
}
}
}
return 0;
}
static int load (char *id, char *file) {
EMnode_t n, *np, *nmem;
EMedge_t e, *ep, *emem;
EMrec_t *rp, **rsp;
int *rnp, *rmp;
Sfio_t *fp;
char *line, *s1, *s2, *s3, *s4, *s5, *s6, *s7;
if (!(fp = sfopen (NULL, file, "r"))) {
SUwarning (0, "load", "cannot open embed info file");
return 0;
}
while ((line = sfgetr (fp, '\n', 1))) {
np = NULL;
ep = NULL;
if (!(s1 = strchr (line, '|'))) {
SUwarning (0, "load", "bad line(1): %s", line);
continue;
}
*s1++ = 0;
if (line[0] == 'N' || line[0] == 'n') {
if (!(s2 = strchr (s1, '|')) || !(s3 = strchr (s2 + 1, '|'))) {
SUwarning (0, "load", "bad line(2): %s", s1);
continue;
}
*s2++ = 0, *s3++ = 0;
memset (&n, 0, sizeof (EMnode_t));
strcpy (n.level, s1);
strcpy (n.id, s2);
if (!(np = dtsearch (nodedict, &n))) {
if (!(nmem = vmalloc (Vmheap, sizeof (EMnode_t)))) {
SUwarning (0, "load", "cannot allocate nmem");
return -1;
}
memset (nmem, 0, sizeof (EMnode_t));
strcpy (nmem->level, s1);
strcpy (nmem->id, s2);
if (!(np = dtinsert (nodedict, nmem))) {
SUwarning (0, "load", "cannot insert node");
vmfree (Vmheap, nmem);
return -1;
}
}
s1 = s3;
rsp = &np->recs, rnp = &np->recn, rmp = &np->recm;
} else if (line[0] == 'E' || line[0] == 'e') {
if (!(s2 = strchr (s1, '|')) || !(s3 = strchr (s2 + 1, '|'))) {
SUwarning (0, "load", "bad line(3): %s", s1);
continue;
}
*s2++ = *s3++ = 0;
if (!(s4 = strchr (s3, '|')) || !(s5 = strchr (s4 + 1, '|'))) {
SUwarning (0, "load", "bad line(4): %s", s3);
continue;
}
*s4++ = 0, *s5++ = 0;
memset (&e, 0, sizeof (EMedge_t));
strcpy (e.level1, s1);
strcpy (e.id1, s2);
strcpy (e.level2, s3);
strcpy (e.id2, s4);
if (!(ep = dtsearch (edgedict, &e))) {
if (!(emem = vmalloc (Vmheap, sizeof (EMedge_t)))) {
SUwarning (0, "load", "cannot allocate emem");
return -1;
}
memset (emem, 0, sizeof (EMedge_t));
strcpy (emem->level1, s1);
strcpy (emem->id1, s2);
strcpy (emem->level2, s3);
strcpy (emem->id2, s4);
if (!(ep = dtinsert (edgedict, emem))) {
SUwarning (0, "load", "cannot insert edge");
vmfree (Vmheap, emem);
return -1;
}
}
s1 = s5;
rsp = &ep->recs, rnp = &ep->recn, rmp = &ep->recm;
}
if (!(s2 = strchr (s1, '|'))) {
SUwarning (0, "load", "bad line(5): %s", s1);
continue;
}
*s2++ = 0;
if (*rmp >= *rnp) {
if (!(*rsp = vmresize (
Vmheap, *rsp, (*rnp + 5) * sizeof (EMrec_t), VM_RSCOPY
))) {
SUwarning (0, "load", "cannot grow recs array");
return -1;
}
*rnp += 5;
}
rp = &(*rsp)[*rmp], (*rmp)++;
if (!(rp->id = vmstrdup (Vmheap, id))) {
SUwarning (0, "load", "cannot copy id");
return -1;
}
if (s1[0] == 'I' || s1[0] == 'i') {
if (!(s3 = strchr (s2, '|'))) {
SUwarning (0, "load", "bad line(6): %s", s2);
continue;
}
if (!(s4 = strchr (s3 + 1, '|')) || !(s5 = strchr (s4 + 1, '|'))) {
SUwarning (0, "load", "bad line(7): %s", s3);
continue;
}
if (!(s6 = strchr (s5 + 1, '|')) || !(s7 = strchr (s6 + 1, '|'))) {
SUwarning (0, "load", "bad line(8): %s", s5);
continue;
}
*s3++ = *s4++ = *s5++ = *s6++ = *s7++ = 0;
rp->type = EM_TYPE_I;
if (!(rp->u.i.file = vmstrdup (Vmheap, s2))) {
SUwarning (0, "load", "cannot copy file");
return -1;
}
rp->u.i.x1 = atoi (s3), rp->u.i.y1 = atoi (s4);
rp->u.i.x2 = atoi (s5), rp->u.i.y2 = atoi (s6);
} else if (s1[0] == 'S' || s1[0] == 's') {
if (!(s3 = strchr (s2, '|'))) {
SUwarning (0, "load", "bad line(9): %s", s2);
continue;
}
if (!(s4 = strchr (s3 + 1, '|')) || !(s5 = strchr (s4 + 1, '|'))) {
SUwarning (0, "load", "bad line(10): %s", s3);
continue;
}
if (!(s6 = strchr (s5 + 1, '|')) || !(s7 = strchr (s6 + 1, '|'))) {
SUwarning (0, "load", "bad line(11): %s", s5);
continue;
}
*s3++ = *s4++ = *s5++ = *s6++ = *s7++ = 0;
rp->type = EM_TYPE_S;
if (
!(rp->u.s.fn = vmstrdup (Vmheap, s2)) ||
!(rp->u.s.fs = vmstrdup (Vmheap, s3)) ||
!(rp->u.s.flcl = vmstrdup (Vmheap, s4)) ||
!(rp->u.s.lncl = vmstrdup (Vmheap, s5)) ||
!(rp->u.s.fncl = vmstrdup (Vmheap, s6))
) {
SUwarning (0, "load", "cannot copy style");
return -1;
}
}
if (!(rp->im = vmstrdup (Vmheap, s7))) {
SUwarning (0, "load", "cannot copy image map");
return -1;
}
}
sfclose (fp);
return 0;
}
/* allocate data from the shared memory region */
Void_t* mmmemory(Dt_t* dt, Void_t* data, size_t size, Dtdisc_t* disc)
{
return vmresize(((Mmdisc_t*)disc)->vm, data, size, 0);
}
static void*
memoryf(Dt_t* dt, void* addr, size_t size, Dtdisc_t* disc)
{
return vmresize(((Dc_t*)disc)->vm, addr, size, VM_RSMOVE);
}
