Skip to content

P
proview
Commit eeec0970 authored by lw's avatar lw
Browse files
Options

*** empty log message ***

parent 4e76c27e
Show whitespace changes
Inline Side-by-side
Showing with 1191 additions and 505 deletions
src/exp/inc/src/pwr.h
View file @ eeec0970
......@@ -228,7 +228,7 @@ typedef union {
typedef struct {
pwr_tOid Objid;
pwr_tClassId Body;
pwr_tCid Body;
pwr_tUInt32 Offset;
pwr_tUInt32 Size;
pwr_mAttrRef Flags;
......@@ -250,6 +250,10 @@ static const pwr_tClassId pwr_cNClassId = 0;
static const pwr_tTypeId pwr_cNTypeId = 0;
static const pwr_tVolumeId pwr_cNVolumeId = 0;
static const pwr_tNodeId pwr_cNNodeId = 0;
static const pwr_tCid pwr_cNCid = 0;
static const pwr_tTid pwr_cNTid = 0;
static const pwr_tVid pwr_cNVid = 0;
static const pwr_tNid pwr_cNNid = 0;
/* Gereral macro definitions */
......
src/lib/co/src/co_cdh.h
View file @ eeec0970
......@@ -68,7 +68,8 @@ typedef struct {
unsigned int vid_3 : 8;
#endif
} cdh_mObjid;
} cdh_mOid;
typedef cdh_mOid cdh_mObjid;
typedef struct {
unsigned int rix : 32;
......@@ -88,7 +89,8 @@ typedef struct {
unsigned int vid_3 : 8;
#endif
} cdh_mRefId;
} cdh_mRid;
typedef cdh_mRid cdh_mRefId;
typedef struct {
#if (pwr_dHost_byteOrder == pwr_dBigEndian)
......@@ -106,7 +108,8 @@ typedef struct {
unsigned int vid_3 : 8;
#endif
} cdh_mVolumeId;
} cdh_mVid;
typedef cdh_mVid cdh_mVolumeId;
typedef struct {
#if (pwr_dHost_byteOrder == pwr_dBigEndian)
......@@ -124,7 +127,8 @@ typedef struct {
unsigned int nid_3 : 8;
#endif
} cdh_mNodeId;
} cdh_mNid;
typedef cdh_mNid cdh_mNodeId;
typedef struct {
#if (pwr_dHost_byteOrder == pwr_dBigEndian)
......@@ -176,7 +180,8 @@ typedef struct {
unsigned int vid_1 : 8;
#endif
} cdh_mClassId;
} cdh_mCid;
typedef cdh_mCid cdh_mClassId;
typedef struct {
#if (pwr_dHost_byteOrder == pwr_dBigEndian)
......@@ -228,35 +233,41 @@ typedef struct {
unsigned int vid_1 : 8;
#endif
} cdh_mTypeId;
} cdh_mTid;
typedef cdh_mTid cdh_mTypeId;
typedef union {
pwr_tObjid pwr;
pwr_tOid pwr;
cdh_mObjid o;
cdh_mClassObjid c;
cdh_mTypeObjid t;
} cdh_uObjid;
} cdh_uOid;
typedef cdh_uOid cdh_uObjid;
typedef union {
pwr_tRefId pwr;
cdh_mRefId r;
} cdh_uRefId;
pwr_tRid pwr;
cdh_mRid r;
} cdh_uRid;
typedef cdh_uRid cdh_uRefId;
typedef union {
pwr_tClassId pwr;
cdh_mClassId c;
cdh_mTypeId t;
} cdh_uTypeId;
pwr_tCid pwr;
cdh_mCid c;
cdh_mTid t;
} cdh_uTid;
typedef cdh_uTid cdh_uTypeId;
typedef union {
pwr_tVolumeId pwr;
cdh_mVolumeId v;
} cdh_uVolumeId;
pwr_tVid pwr;
cdh_mVid v;
} cdh_uVid;
typedef cdh_uVid cdh_uVolumeId;
typedef union {
pwr_tNodeId pwr;
cdh_mNodeId n;
} cdh_uNodeId;
pwr_tNid pwr;
cdh_mNid n;
} cdh_uNid;
typedef cdh_uNid cdh_uNodeId;
typedef enum {
cdh_eId__ = 0,
......@@ -272,11 +283,11 @@ typedef enum {
} cdh_eId;
typedef union {
pwr_tObjectIx oix;
pwr_tObjid oid;
pwr_tClassId cid;
pwr_tVolumeId vid;
pwr_tTypeId tid;
pwr_tOix oix;
pwr_tOid oid;
pwr_tCid cid;
pwr_tVid vid;
pwr_tTid tid;
pwr_tSubid sid;
pwr_tDlid did;
pwr_sAttrRef aref;
......@@ -311,7 +322,7 @@ typedef struct {
typedef struct {
cdh_sObjName name;
pwr_tObjid poid;
pwr_tOid poid;
} cdh_sFamily;
typedef union {
......@@ -527,14 +538,14 @@ typedef union {
} cdh_mName;
typedef struct {
pwr_tObjid poid; /* Parent objid, or NOBJID */
pwr_tOid poid; /* Parent objid, or NOBJID */
cdh_mParseName parseFlags;
cdh_mName flags;
void *ohp;
cdh_eId eId;
cdh_uId uId;
pwr_tTypeId bid;
pwr_tTid bid;
pwr_tUInt32 index;
pwr_tUInt32 offset;
pwr_tUInt32 size;
......@@ -550,30 +561,30 @@ typedef struct {
int
cdh_ObjidCompare (
pwr_tObjid Object_1,
pwr_tObjid Object_2
pwr_tOid Object_1,
pwr_tOid Object_2
);
int
cdh_ObjidIsEqual (
pwr_tObjid Object_1,
pwr_tObjid Object_2
pwr_tOid Object_1,
pwr_tOid Object_2
);
int
cdh_ObjidIsNotEqual (
pwr_tObjid Object_1,
pwr_tObjid Object_2
pwr_tOid Object_1,
pwr_tOid Object_2
);
int
cdh_ObjidIsNull (
pwr_tObjid Object
pwr_tOid Object
);
int
cdh_ObjidIsNotNull (
pwr_tObjid Object
pwr_tOid Object
);
int
......@@ -660,29 +671,29 @@ cdh_DlidIsNotNull (
pwr_tDlid DirectLink
);
pwr_tClassId
pwr_tCid
cdh_ClassObjidToId (
pwr_tObjid Object
pwr_tOid Object
);
pwr_tObjid
pwr_tOid
cdh_ClassIdToObjid (
pwr_tClassId Class
pwr_tCid Class
);
pwr_tTypeId
pwr_tTid
cdh_TypeObjidToId (
pwr_tObjid Object
pwr_tOid Object
);
int
cdh_TypeIdToIndex (
pwr_tTypeId Type
pwr_tTid Type
);
pwr_tObjid
pwr_tOid
cdh_TypeIdToObjid (
pwr_tTypeId Type
pwr_tTid Type
);
pwr_tStatus
......@@ -703,31 +714,31 @@ cdh_StringToAttrValue (
pwr_tStatus
cdh_StringToClassId (
const char *s,
pwr_tClassId *cid
pwr_tCid *cid
);
pwr_tStatus
cdh_StringToTypeId (
const char *s,
pwr_tTypeId *tid
pwr_tTid *tid
);
pwr_tStatus
cdh_StringToVolumeId (
const char *s,
pwr_tVolumeId *tid
pwr_tVid *tid
);
pwr_tStatus
cdh_StringToObjectIx (
const char *s,
pwr_tObjectIx *oix
pwr_tOix *oix
);
pwr_tStatus
cdh_StringToObjid (
const char *s,
pwr_tObjid *oix
pwr_tOid *oid
);
pwr_tStatus
......@@ -745,21 +756,21 @@ cdh_StringToDlid (
char *
cdh_ClassIdToString (
char *s,
pwr_tClassId cid,
pwr_tCid cid,
int prefix
);
char *
cdh_ObjectIxToString (
char *s,
pwr_tObjectIx oix,
pwr_tOix oix,
int prefix
);
char *
cdh_ObjidToString (
char *s,
pwr_tObjid oid,
pwr_tOid oid,
int prefix
);
......@@ -773,25 +784,21 @@ cdh_ArefToString (
char *
cdh_NodeIdToString (
char *s,
pwr_tNodeId nid,
pwr_tNid nid,
int prefix,
int suffix
);
char *
cdh_TypeIdToString (
char *s,
pwr_tTypeId tid,
int prefix
);
cdh_TypeIdToString(char *s, pwr_tTid tid, int prefix);
char *
cdh_VolumeIdToString (
char *s,
pwr_tVolumeId vid,
pwr_tVid vid,
int prefix,
int suffix
);
);
char *
cdh_SubidToString (
......@@ -811,7 +818,7 @@ cdh_sFamily *
cdh_Family (
cdh_sFamily *f,
const char *name,
pwr_tObjid poid
pwr_tOid poid
);
cdh_sObjName *
......@@ -829,7 +836,7 @@ cdh_sParseName *
cdh_ParseName (
pwr_tStatus *sts,
cdh_sParseName *pn,
pwr_tObjid poid,
pwr_tOid poid,
const char *name,
pwr_tUInt32 flags
);
......
src/lib/co/src/co_dbs.c
View file @ eeec0970
......@@ -7,6 +7,12 @@
#include <string.h>
#include <unistd.h>
#include <sys/mman.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <fcntl.h>
#include "pwr.h"
#include "co_dbs.h"
......@@ -15,23 +21,76 @@
#include "co_platform.h"
static pwr_tBoolean
checkQ(const dbs_sEnv *ep, dbs_sQlink *item)
{
dbs_sQlink *link;
if (item == NULL) {
printf("checkQ in volume: %s, item == NULL", "not known");
return NO;
}
if (item->self == dbs_cNref) {
printf("checkQ in volume: %s, item->self == dbs_cNref, item: %u", "not known", (unsigned int)item);
return NO;
}
link = dbs_Address(NULL, ep, item->self);
if (item != link) {
printf("checkQ in volume: %s, item != dbs_Address(NULL, ep, item->self),\n item: %u != %u",
"not known", (unsigned int)item, (unsigned int)link);
return NO;
}
return YES;
}
void *
dbs_Address(pwr_tStatus *sts, dbs_sEnv *ep, dbs_tRef r)
dbs_Address(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_tRef r)
{
#if 0
if (r == dbs_cNRef)
dbs_uRefBits bits;
if (r == dbs_cNref)
return NULL;
if (!ep->flags.b.isMapped)
pwr_ReturnOrBugcheck(NULL, sts, DBS__NOTMAPPED, "");
pwr_Return(NULL, sts, DBS__NOTMAPPED);
bits.m = r;
if (bits.b.sect > dbs_eSect_)
pwr_Return(NULL, sts, DBS__BADSECT);
if (bits.b.offs >= ep->sect[bits.b.sect].size)
pwr_Return(NULL, sts, DBS__BADOFFS);
if (r < ep->size) {
return (void *)(ep->base + r);
return (void *)(ep->base + ep->sect[bits.b.sect].offset + bits.b.offs);
}
void *dbs_Bfind(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sBintab *tp, void *key, int (comp)(void *key, void *record))
{
char *p;
int c;
char *start = dbs_Address(sts, ep, tp->start);
char *end = dbs_Address(sts, ep, tp->end);
int rsize = tp->rsize;
while (start <= end) {
p = start + ((end - start) / (2*rsize)) * rsize;
c = comp(key, p);
if (c > 0) {
start = p + rsize;
} else if (c < 0) {
end = p - rsize;
} else {
return p;
}
pwr_ReturnOrBugcheck(NULL, sts, DBS__BADOFFS, "");
#endif
return NULL;
}
return 0;
}
#if 0
......@@ -65,29 +124,6 @@ dbs_ItemReference(pwr_tStatus*, dbs_sEnv*, void*)
{
}
void *dbs_Bfind(pwr_tStatus *sts, dbs_sEnv *ep, dbs_sBintab *tp, void *key, int (comp)(void *key, void *record))
{
void *p;
int c;
void *start = dbs_Address(sts, ep, tp->start);
void *end = dbs_Address(sts, ep, tp->end);
int rsize = tp->rsize;
while (start < end) {
p = start + ((end - start) / (2*rsize)) * rsize;
c = comp(key, p);
if (c < 0) {
start = p + rsize;
} else if (c > 0) {
end = p - rsize;
} else {
return p;
}
}
return 0;
}
dbs_sQlink *
......@@ -95,27 +131,27 @@ dbs_Qalloc(pwr_tStatus*, dbs_sEnv*)
{
}
#endif
pwr_tBoolean
dbs_QhasOne(pwr_tStatus *sts, dbs_sEnv *ep, dbs_sQlink *item)
dbs_QhasOne(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
dbs_sQlink *pred;
dbs_sQlink *succ;
pwr_Assert(checkQ(ep, item));
pred = dbs_Address(sts, ep, item->blink);
succ = dbs_Address(sts, ep, item->flink);
pred = dbs_Address(sts, ep, item->pred);
succ = dbs_Address(sts, ep, item->succ);
pwr_Assert(checkQ(ep, succ));
pwr_Assert(checkQ(ep, pred));
pwr_Assert(item->blink == pred->self);
pwr_Assert(item->flink == succ->self);
pwr_Assert(pred->flink == item->self);
pwr_Assert(succ->blink == item->self);
pwr_Assert(item->pred == pred->self);
pwr_Assert(item->succ == succ->self);
pwr_Assert(pred->succ == item->self);
pwr_Assert(succ->pred == item->self);
return item->flink == item->blink;
return item->succ == item->pred;
}
#endif
/* Initialize a queue item. */
......@@ -146,124 +182,124 @@ dbs_Qinsert(pwr_tStatus *sts, dbs_sQlink *pred, dbs_sQlink *item, dbs_sQlink *su
#if 0
dbs_sQlink *dbs_QinsertPred(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
dbs_sQlink *dbs_QinsertSucc(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
#endif
#if 1
pwr_tBoolean
dbs_QisEmpty(pwr_tStatus *sts, dbs_sEnv *cp, dbs_sQlink *item)
dbs_QisEmpty(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
dbs_sQlink *pred;
dbs_sQlink *succ;
pwr_Assert(checkQ(php, item));
pwr_Assert(checkQ(ep, item));
pred = dbs_Address(sts, cp, item->blink);
succ = dbs_Address(sts, cp, item->flink);
pred = dbs_Address(sts, ep, item->pred);
succ = dbs_Address(sts, ep, item->succ);
pwr_Assert(checkQ(cp, succ));
pwr_Assert(checkQ(cp, pred));
pwr_Assert(item->blink == pred->self);
pwr_Assert(item->flink == succ->self);
pwr_Assert(pred->flink == item->self);
pwr_Assert(succ->blink == item->self);
pwr_Assert(checkQ(ep, succ));
pwr_Assert(checkQ(ep, pred));
pwr_Assert(item->pred == pred->self);
pwr_Assert(item->succ == succ->self);
pwr_Assert(pred->succ == item->self);
pwr_Assert(succ->pred == item->self);
return item->flink == item->self;
return item->succ == item->self;
}
pwr_tBoolean
dbs_QisLinked(pwr_tStatus *sts, dbs_sEnv *cp, dbs_sQlink *item)
dbs_QisLinked(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
dbs_sQlink *pred;
dbs_sQlink *succ;
pwr_Assert(checkQ(cp, item));
pwr_Assert(checkQ(ep, item));
pred = dbs_Address(sts, cp, item->blink);
succ = dbs_Address(sts, cp, item->flink);
pred = dbs_Address(sts, ep, item->pred);
succ = dbs_Address(sts, ep, item->succ);
pwr_Assert(checkQ(cp, succ));
pwr_Assert(checkQ(cp, pred));
pwr_Assert(item->blink == pred->self);
pwr_Assert(item->flink == succ->self);
pwr_Assert(pred->flink == item->self);
pwr_Assert(succ->blink == item->self);
pwr_Assert(checkQ(ep, succ));
pwr_Assert(checkQ(ep, pred));
pwr_Assert(item->pred == pred->self);
pwr_Assert(item->succ == succ->self);
pwr_Assert(pred->succ == item->self);
pwr_Assert(succ->pred == item->self);
return item->flink != item->self;
return item->succ != item->self;
}
pwr_tBoolean
dbs_QisNull(pwr_tStatus *sts, dbs_sEnv *cp, dbs_sQlink *item)
dbs_QisNull(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
pwr_tBoolean nullQ;
nullQ = (item->self == dbs_cNRef)
|| (item->blink == dbs_cNRef)
|| (item->flink == dbs_cNRef);
nullQ = (item->self == dbs_cNref)
|| (item->pred == dbs_cNref)
|| (item->succ == dbs_cNref);
pwr_Assert(item->blink == dbs_cNRef);
pwr_Assert(item->flink == dbs_cNRef);
pwr_Assert(item->self == dbs_cNRef);
pwr_Assert(item->pred == dbs_cNref);
pwr_Assert(item->succ == dbs_cNref);
pwr_Assert(item->self == dbs_cNref);
return nullQ;
}
dbs_sQlink *
dbs_Qpred(pwr_tStatus *sts, dbs_sEnv *cp, dbs_sQlink *item)
dbs_Qpred(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
dbs_sQlink *pred;
pwr_Assert(checkQ(cp, item));
pwr_Assert(checkQ(ep, item));
pred = dbs_Address(NULL, cp, item->blink);
pred = dbs_Address(NULL, ep, item->pred);
if (pred != NULL) {
pwr_Assert(checkQ(cp, pred));
pwr_Assert(pred->flink == item->self);
pwr_Assert(pred->self == item->blink);
pwr_Assert(checkQ(ep, pred));
pwr_Assert(pred->succ == item->self);
pwr_Assert(pred->self == item->pred);
}
return pred;
}
dbs_sQlink *
dbs_Qsucc(pwr_tStatus *sts, dbs_sEnv *cp, dbs_sQlink *item);
dbs_Qsucc(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sQlink *item)
{
pool_sQlink *succ;
dbs_sQlink *succ;
pwr_Assert(checkQ(cp, item));
pwr_Assert(checkQ(ep, item));
succ = dbs_Address(NULL, cp, item->flink);
succ = dbs_Address(NULL, ep, item->succ);
if (succ != NULL) {
pwr_Assert(checkQ(cp, succ));
pwr_Assert(succ->blink == item->self);
pwr_Assert(item->flink == succ->self);
pwr_Assert(checkQ(ep, succ));
pwr_Assert(succ->pred == item->self);
pwr_Assert(item->succ == succ->self);
}
return succ;
}
dbs_tRef dbs_RefAlloc(pwr_tStatus*, dbs_sEnv*, pwr_tUInt32);
/* Translate a virtual address to a pool reference.
Return a pool_tRef, and signals errors. */
/* Translate a virtual address to a reference.
Return a dbs_tRef, and signals errors. */
dbs_tRef
dbs_Reference(pwr_tStatus sts*, dbs_sEnv *ep, void *adrs)
dbs_Reference(pwr_tStatus *sts, const dbs_sEnv *ep, void *adrs)
{
long iadrs = (long)adrs;
long ofs;
long sect =
long base = cp->sect[]
//long base = ep->sect[]
if (iadrs < (long)cp->base)
return dbs_cNRef;
if (iadrs < (long)ep->base)
return dbs_cNref;
ofs = iadrs - (long)ep->base;
if (ofs >= ep->size)
return dbs_cNRef;
return dbs_cNref;
return (dbs_tRef)ofs;
}
#endif
pwr_tBoolean
dbs_Close(pwr_tStatus *sts, dbs_sEnv *ep)
{
......@@ -318,58 +354,464 @@ dbs_Open(pwr_tStatus *sts, dbs_sEnv *ep, const char *filename)
return ep;
}
pwr_tBoolean
dbs_AlignedRead(pwr_tStatus *sts, void *buf, pwr_tUInt32 size, dbs_sEnv *ep)
dbs_sEnv *
dbs_Map(pwr_tStatus *sts, dbs_sEnv *ep, const char *filename)
{
int offset;
struct stat sb;
int ret, i;
int fd;
//char *buf;
//int c;
dbs_sFile *fp;
dbs_sSect *sp;
dbs_sVolume *vp;
dbs_sObject *op, *eop;
dbs_sName *np, *enp;
dbs_sOid *oidp, *eoidp;
dbs_uRefBits nf, nl, cf, cl, of, ol;
dbs_sClass *cp, *ecp;
if ((ret = stat(filename, &sb)) != 0) {
perror("stat");
return NULL;
}
*sts = DBS__SUCCESS;
memset(ep, 0, sizeof(*ep));
*sts = errno_GetStatus();
printf("st_dev....: %d\t\t%s\n", (int)sb.st_dev, "device");
printf("st_ino....: %d\t%s\n", sb.st_ino, "inode");
printf("st_mode...: %d\t%s\n", sb.st_mode, "protection");
printf("st_nlink..: %d\t\t%s\n", sb.st_nlink, "number of hard links");
printf("st_uid....: %d\t%s\n", sb.st_uid, "user ID of owner");
printf("st_gid....: %d\t\t%s\n", sb.st_gid, "group ID of owner");
printf("st_redv...: %d\t\t%s\n", (int)sb.st_rdev, "device type (if inode device)");
printf("st_size...: %d\t\t%s\n", sb.st_size, "total size, in bytes");
printf("st_blksize: %d\t%s\n", sb.st_blksize, "blocksize for filesystem I/O");
printf("st_blocks.: %d\t\t%s\n", sb.st_blocks, "number of blocks allocated");
printf("st_atime..: %d\t%s\n", sb.st_atime, "time of last access");
printf("st_mtime..: %d\t%s\n", sb.st_mtime, "time of last modification");
printf("st_ctime..: %d\t%s\n", sb.st_ctime, "time of last change");
printf("st_mode...: %d\t%s\n", sb.st_mode, "mode");
fd = open(filename, O_RDWR);
printf("open fd: %d\n", fd);
errno = 0;
ep->base = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, fd, 0);
perror("mmap");
printf("mmap buf: %d\n", ret);
ret = close(fd);
printf("close ret: %d\n", ret);
ep->flags.b.isMapped = 1;
fp = (dbs_sFile*)ep->base;
printf("format.......: %d\n", fp->format.m);
printf("cookie.......: %d\n", fp->cookie);
printf("size.........: %d\n", fp->size);
printf("offset.......: %d\n", fp->offset);
printf("formatVersion: %d\n", fp->formatVersion);
printf("version......: %d\n", fp->version);
printf("sectVersion..: %d\n", fp->sectVersion);
printf("pwrVersion...: %d\n", fp->pwrVersion);
printf("time.........: %ld\n", fp->time.tv_sec);
printf("fileType.....: %d\n", fp->fileType);
printf("userName.....: %s\n", fp->userName);
sp = (dbs_sSect*)((char *)fp + dbs_dAlign(sizeof(dbs_sFile)));
vp = (dbs_sVolume*)((char *)fp + sp[dbs_eSect_volume].offset);
printf("vid........: %d\n", vp->vid);
printf("name.......: %s\n", vp->name);
printf("cid........: %d\n", vp->cid);
printf("className..: %s\n", vp->className);
printf("time.......: %ld\n", vp->time.tv_sec);
printf("cardinality: %d\n", vp->cardinality);
printf("rbodysize..: %d\n", vp->rbodySize);
nf.m = vp->name_bt.start;
nl.m = vp->name_bt.end;
cf.m = vp->class_bt.start;
cl.m = vp->class_bt.end;
of.m = vp->oid_bt.start;
ol.m = vp->oid_bt.end;
printf("name_bt....: %d.%d -> %d.%d %d\n", nf.b.sect, nf.b.offs, nl.b.sect, nl.b.offs, vp->name_bt.rsize);
printf("class_bt...: %d.%d -> %d.%d %d\n", cf.b.sect, cf.b.offs, cl.b.sect, cl.b.offs, vp->class_bt.rsize);
printf("oid_bt.....: %d.%d -> %d.%d %d\n", of.b.sect, of.b.offs, ol.b.sect, ol.b.offs, vp->oid_bt.rsize);
ep->sect = (dbs_sSect*)((char *)fp + dbs_dAlign(sizeof(dbs_sFile)));
sp = (dbs_sSect*)((char *)fp + dbs_dAlign(sizeof(dbs_sFile)));
for (i = 0; i < dbs_eSect_; i++, sp++) {
printf("sect: i:%d, version:%d, type:%d, size:%d, offset:%d\n", i, sp->version,
sp->type, sp->size, sp->offset);
}
if (fread(buf, size, 1, ep->f) == 0)
pwr_Return(NO, sts, errno_GetStatus());
sp = (dbs_sSect*)((char *)fp + dbs_dAlign(sizeof(dbs_sFile)));
op = (dbs_sObject*)((char *)fp + sp[dbs_eSect_object].offset);
eop = (dbs_sObject*)((char *)op + sp[dbs_eSect_object].size);
for (; op < eop; op = (dbs_sObject*)((char *)op + dbs_dAlign(sizeof(dbs_sObject)))) {
dbs_uRefBits r, p, s, bf, bl;
r.m = op->rbody.ref;
p.m = op->pref;
s.m = op->sib_ll.self;
bf.m = op->name_bt.start;
bl.m = op->name_bt.end;
printf("O %s, %d.%d, %d r[%d.%d] p[%d.%d] s[%d.%d] bs[%d.%d] be[%d.%d] %d\n",
op->name, op->oid.vid, op->oid.oix, op->rbody.size, r.b.sect, r.b.offs,
p.b.sect, p.b.offs, s.b.sect, s.b.offs, bf.b.sect, bf.b.offs, bl.b.sect, bl.b.offs, op->name_bt.rsize);
}
if ((offset = dbs_dPadding(size)) > 0)
if(fseek(ep->f, offset, SEEK_CUR))
pwr_Return(NO, sts, errno_GetStatus());
oidp = (dbs_sOid*)((char *)fp + sp[dbs_eSect_oid].offset);
eoidp = (dbs_sOid*)((char *)oidp + sp[dbs_eSect_oid].size);
for (; oidp < eoidp; oidp = (dbs_sOid*)((char *)oidp + dbs_dAlign(sizeof(dbs_sOid)))) {
dbs_uRefBits s;
dbs_sObject *op, *oop, *aop;
pwr_tStatus sts;
s.m = oidp->ref;
op = dbs_Address(&sts, ep, oidp->ref);
oop = dbs_OidToObject(&sts, ep, op->oid);
aop = dbs_After(&sts, ep, op);
printf("Oid %d.%d, [%d.%d] -> %s %d.%d ", oidp->oid.vid, oidp->oid.oix, s.b.sect, s.b.offs,
op->name, op->oid.vid, op->oid.oix);
if (oop == NULL)
printf(" NULL");
else
printf("(%d.%d)", oop->oid.vid, oop->oid.oix);
if (aop == NULL)
printf(" NULL\n");
else
printf(" (%s)\n", aop->name);
}
return YES;
np = (dbs_sName*)((char *)fp + sp[dbs_eSect_name].offset);
enp = (dbs_sName*)((char *)np + sp[dbs_eSect_name].size);
for (; np < enp; np = (dbs_sName*)((char *)np + dbs_dAlign(sizeof(dbs_sName)))) {
dbs_uRefBits r;
dbs_sObject *op, *oop, *nop;
pwr_tStatus sts;
r.m = np->ref;
op = dbs_Address(&sts, ep, np->ref);
oop = dbs_OidToObject(&sts, ep, op->oid);
nop = dbs_NameToObject(&sts, ep, op->poid, op->normname);
printf("N %d %s, [%d.%d] -> %s %d.%d ", np->poix, np->normname, r.b.sect, r.b.offs,
op->name, op->oid.vid, op->oid.oix);
if (oop == NULL)
printf("NULL");
else
printf("(%d.%d)", oop->oid.vid, oop->oid.oix);
if (oop == NULL)
printf(" NULL\n");
else
printf(" (%d.%d)\n", nop->oid.vid, nop->oid.oix);
}
cp = (dbs_sClass*)((char *)fp + sp[dbs_eSect_class].offset);
ecp = (dbs_sClass*)((char *)np + sp[dbs_eSect_class].size);
for (; cp < ecp; cp = (dbs_sClass*)((char *)cp + dbs_dAlign(sizeof(dbs_sClass)))) {
dbs_sObject *op;
pwr_tStatus sts;
printf("C %d\n", cp->cid);
op = dbs_ClassToObject(&sts, ep, cp->cid);
while (op != NULL) {
printf(" %d %d.%d %s\n", op->cid, op->oid.vid, op->oid.oix, op->name);
op = dbs_Next(&sts, ep, op);
}
}
return ep;
}
static int
comp_oid(void *key, void *record)
{
pwr_tOid *k = (pwr_tOid *) key;
dbs_sOid *o = (dbs_sOid *) record;
#if 0
dbs_sFile *
dbsdr_sFile(void *s, dbs_sFile *t)
if (k->vid == o->oid.vid) {
if (k->oix == o->oid.oix)
return 0;
else if (k->oix < o->oid.oix)
return -1;
else
return 1;
} else if (k->vid < o->oid.vid)
return -1;
else
return 1;
}
static int
comp_cid(void *key, void *record)
{
pwr_tCid *k = (pwr_tCid *) key;
dbs_sClass *c = (dbs_sClass *) record;
if (*k == c->cid)
return 0;
else if (*k < c->cid)
return -1;
else
return 1;
}
static int
comp_name(void *key, void *record)
{
dbs_sName *k = (dbs_sName *) key;
dbs_sName *n = (dbs_sName *) record;
if (k->poix < n->poix)
return -1;
else if (k->poix == n->poix)
return strcmp(k->normname, n->normname);
else
return 1;
}
dbs_sObject *
dbs_OidToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tOid oid)
{
encode_oid();
encode_int();
encode_time();
dbs_sOid *oidp;
dbs_sObject *op;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
oidp = (dbs_sOid *)dbs_Bfind(sts, ep, &vp->oid_bt, &oid, comp_oid);
if (oidp == NULL)
return NULL;
op = dbs_Address(sts, ep, oidp->ref);
return op;
}
dbs_sSect *
dbsdr_sSect(void *s, dbs_sFile *t)
dbs_sObject *
dbs_After(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sOid *oidp;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sQlink *ol;
dbs_sObject *pop;
oidp = (dbs_sOid *)dbs_Bfind(sts, ep, &vp->oid_bt, &op->poid, comp_oid);
if (oidp == NULL)
return NULL;
pop = dbs_Address(sts, ep, oidp->ref);
ol = dbs_Qsucc(sts, ep, &op->sib_ll);
if (ol == &pop->sib_lh)
return NULL;
return dbs_Qitem(ol, dbs_sObject, sib_ll);
}
dbs_sObject *
dbs_Before(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sOid *oidp;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sQlink *ol;
dbs_sObject *pop;
oidp = (dbs_sOid *)dbs_Bfind(sts, ep, &vp->oid_bt, &op->poid, comp_oid);
if (oidp == NULL)
return NULL;
pop = dbs_Address(sts, ep, oidp->ref);
ol = dbs_Qpred(sts, ep, &op->sib_ll);
if (ol == &pop->sib_lh)
return NULL;
return dbs_Qitem(ol, dbs_sObject, sib_ll);
}
dbs_sObject *
dbs_First(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sQlink *ol;
if (dbs_QisEmpty(sts, ep, &op->sib_lh))
return NULL;
ol = dbs_Qsucc(sts, ep, &op->sib_lh);
return dbs_Qitem(ol, dbs_sObject, sib_ll);
}
dbs_sObject *
dbs_Last(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sQlink *ol;
if (dbs_QisEmpty(sts, ep, &op->sib_lh))
return NULL;
ol = dbs_Qpred(sts, ep, &op->sib_lh);
return dbs_Qitem(ol, dbs_sObject, sib_ll);
}
dbs_sObject *
dbs_NameToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tOid oid, char *name)
{
dbs_sOid *oidp;
dbs_sObject *op;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sName n;
dbs_sName *np;
oidp = (dbs_sOid *)dbs_Bfind(sts, ep, &vp->oid_bt, &oid, comp_oid);
if (oidp == NULL)
return NULL;
op = dbs_Address(sts, ep, oidp->ref);
if (op == NULL)
return NULL;
n.poix = oid.oix;
strcpy(n.normname, name);
np = (dbs_sName *)dbs_Bfind(sts, ep, &vp->name_bt, &n, comp_name);
if (np == NULL)
return NULL;
op = dbs_Address(sts, ep, np->ref);
return op;
}
dbs_sVolume *
dbsdr_sVolume(void *s, dbs_sVolume *t)
dbs_sObject *
dbs_Child(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op, char *name)
{
dbs_sName n;
dbs_sName *np;
n.poix = op->oid.oix;
strcpy(n.normname, name);
np = (dbs_sName *)dbs_Bfind(sts, ep, &op->name_bt, &n, comp_name);
if (np == NULL)
return NULL;
op = dbs_Address(sts, ep, np->ref);
return op;
}
dbs_sVolRef *
dbsdr_sVolRef(void *s, dbs_sVolRef *t)
dbs_sObject *
dbs_ClassToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tCid cid)
{
dbs_sClass *cp;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sQlink *ol;
cp = (dbs_sClass *)dbs_Bfind(sts, ep, &vp->class_bt, &cid, comp_cid);
if (cp == NULL)
return NULL;
if (dbs_QisEmpty(sts, ep, &cp->o_lh))
return NULL;
ol = dbs_Qsucc(sts, ep, &cp->o_lh);
return dbs_Qitem(ol, dbs_sObject, o_ll);
}
dbs_sObject *
dbs_Next(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sClass *cp;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sQlink *ol;
cp = (dbs_sClass *)dbs_Bfind(sts, ep, &vp->class_bt, &op->cid, comp_cid);
if (cp == NULL)
return NULL;
ol = dbs_Qsucc(sts, ep, &op->o_ll);
if (ol == &cp->o_lh)
return NULL;
return dbs_Qitem(ol, dbs_sObject, o_ll);
}
dbs_sObject *
dbsdr_sObject(void *s, dbs_sObject *t)
dbs_Previous(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
dbs_sClass *cp;
dbs_sVolume *vp = (dbs_sVolume *)(ep->base + ep->sect[dbs_eSect_volume].offset);
dbs_sQlink *ol;
cp = (dbs_sClass *)dbs_Bfind(sts, ep, &vp->class_bt, &op->cid, comp_cid);
if (cp == NULL)
return NULL;
ol = dbs_Qpred(sts, ep, &op->o_ll);
if (ol == &cp->o_lh)
return NULL;
return dbs_Qitem(ol, dbs_sObject, o_ll);
}
dbs_sBody *
dbsdr_sBody(void *s, dbs_sBody *t)
dbs_sObject *
dbs_Ancestor(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op)
{
while (op != NULL) {
if (op->oid.oix == 1)
return NULL;
if (op->poid.oix == 1)
return op;
op = dbs_Address(sts, ep, op->pref);
}
return op;
}
#endif
pwr_tBoolean
dbs_AlignedRead(pwr_tStatus *sts, void *buf, pwr_tUInt32 size, const dbs_sEnv *ep)
{
int offset;
*sts = DBS__SUCCESS;
if (fread(buf, size, 1, ep->f) == 0)
pwr_Return(NO, sts, errno_GetStatus());
if ((offset = dbs_dPadding(size)) > 0)
if(fseek(ep->f, offset, SEEK_CUR))
pwr_Return(NO, sts, errno_GetStatus());
return YES;
}
src/lib/co/src/co_dbs.pdr
View file @ eeec0970
......@@ -49,7 +49,7 @@
% | Information about volumes mounted in this volume. |
% | |
% +====================================================+
% | Oix (Object index) Section |
% | Oid (Object identity) Section |
% +----------------------------------------------------+
% | |
% | |
......@@ -162,7 +162,7 @@
%#define dbs_cAlignInc 7
%#define dbs_dAlign(size) (((size) + dbs_cAlignInc) & ~dbs_cAlignInc)
%#define dbs_dPadding(size) ((((size) + dbs_cAlignInc) & ~dbs_cAlignInc) - (size))
%#define dbs_dMakeRef(sect, offset) (0 & ((sect) << dbs_cOffsBits) & (offset))
%#define dbs_dMakeRef(sect, offset) (0 | ((sect) << dbs_cOffsBits) | (offset))
%
%typedef union {
% struct {
......@@ -175,6 +175,7 @@
%pwr_tBoolean
%pdr_dbs_uRefBits(PDR *pdrs, dbs_uRefBits *objp);
%
%
#endif
struct dbs_sQlink {
......@@ -189,9 +190,9 @@ enum dbs_eSect {
dbs_eSect_dir = 0,
dbs_eSect_volume = 1,
dbs_eSect_volref = 2,
dbs_eSect_oid = 3,
dbs_eSect_object = 4,
dbs_eSect_rbody = 5,
dbs_eSect_oix = 3,
dbs_eSect_name = 6,
dbs_eSect_dbody = 8,
dbs_eSect_class = 10,
......@@ -202,7 +203,7 @@ enum dbs_eSect {
#ifdef PDR_HDR
%#define dbs_mSect_volume pwr_Bit(dbs_eSect_volume)
%#define dbs_mSect_volref pwr_Bit(dbs_eSect_volref)
%#define dbs_mSect_oix pwr_Bit(dbs_eSect_oix)
%#define dbs_mSect_oid pwr_Bit(dbs_eSect_oid)
%#define dbs_mSect_object pwr_Bit(dbs_eSect_object)
%#define dbs_mSect_rbody pwr_Bit(dbs_eSect_rbody)
%#define dbs_mSect_name pwr_Bit(dbs_eSect_name)
......@@ -285,6 +286,12 @@ enum dbs_eFile {
%
#endif
struct dbs_sBintab {
dbs_tRef start;
dbs_tRef end;
pwr_tUInt32 rsize;
};
#ifdef PDR_HDR
%/**
% * @note You can't use pdr_dbs_sFile directly due to the format member.
......@@ -342,6 +349,10 @@ struct dbs_sVolume {
pwr_tTime time; /**< time at which this load file was created */
pwr_tUInt32 cardinality; /**< number objects in this volume */
pwr_tUInt32 rbodySize;
dbs_sBintab name_bt; /**< search for object with parent and name */
dbs_sBintab oid_bt; /**< search for object with identity */
dbs_sBintab class_bt; /**< search for object with class */
};
/**
......@@ -364,19 +375,19 @@ struct dbs_sVolRef {
/**
* Object Index (oix) Section.
* Object Identity (oid) Section.
*
* Layout of an object index table entry.
* Oix entries are stored in oix-sect.
* Used to find an object with object index as key.
* Layout of an object identity table entry.
* Oid entries are stored in oid-sect.
* Used to find an object with object identity as key.
* Table lookup mechanism is binary lookup.
*/
#ifdef PDR_HDR
%#define dbs_cVersionOix 1
%#define dbs_cVersionOid 1
#endif
struct dbs_sOix {
pwr_tOix oix; /**< Object index */
struct dbs_sOid {
pwr_tOid oid; /**< Object identity */
dbs_tRef ref; /**< Address, section relative, to object in object section */
};
......@@ -400,12 +411,6 @@ struct dbs_sOlink {
pwr_tOix succ;
};
struct dbs_sBintab {
dbs_tRef start;
dbs_tRef end;
pwr_tUInt32 rsize;
};
struct dbs_sObject {
pwr_tOid oid; /**< object identifier */
pwr_tCid cid; /**< class identifier */
......@@ -442,6 +447,7 @@ struct dbs_sObject {
struct dbs_sClass {
pwr_tCid cid; /**< class identifier */
pwr_tUInt32 nObjects;
dbs_sQlink o_lh; /**< root of list of all object
of this class within this volume */
};
......@@ -506,7 +512,7 @@ struct dbs_sName {
% FILE *f;
% dbs_sFile file;
% pwr_tUInt32 nSect;
% dbs_sSect sect[dbs_eSect_];
% dbs_sSect *sect;
%
% /* the rest is used only if mapped */
% pwr_tUInt32 size; /**< size of mapped file */
......@@ -518,37 +524,51 @@ struct dbs_sName {
%#define dbs_Qitem(a, b, c) ((b *)((char *)a - offsetof(b, c)))
%#define dbs_Qlink(a, b, c) ((dbs_sQlink *)((char *)a + offsetof(b, c)))
%
%void *dbs_Address(pwr_tStatus*, dbs_sEnv*, dbs_tRef);
%void *dbs_Alloc(pwr_tStatus*, dbs_sEnv*, pwr_tUInt32);
%pwr_tBoolean dbs_AllocLookasideSegment(pwr_tStatus*, dbs_sEnv*, pwr_tUInt32, pwr_tUInt32);
%void *dbs_AllocNamedSegment(pwr_tStatus*, dbs_sEnv*, pwr_tUInt32, char*);
%void *dbs_Address(pwr_tStatus*, const dbs_sEnv*, dbs_tRef);
%void *dbs_Alloc(pwr_tStatus*, const dbs_sEnv*, pwr_tUInt32);
%pwr_tBoolean dbs_AllocLookasideSegment(pwr_tStatus*, const dbs_sEnv*, pwr_tUInt32, pwr_tUInt32);
%void *dbs_AllocNamedSegment(pwr_tStatus*, const dbs_sEnv*, pwr_tUInt32, char*);
%dbs_sEnv *dbs_Create(pwr_tStatus*, dbs_sEnv*, char*, pwr_tUInt32, pwr_tUInt32);
%void dbs_Dump(pwr_tStatus*, dbs_sEnv*);
%pwr_tBoolean dbs_Free(pwr_tStatus*, dbs_sEnv*, void*);
%pwr_tBoolean dbs_FreeReference(pwr_tStatus*, dbs_sEnv*, dbs_tRef);
%dbs_tRef dbs_InDbs(pwr_tStatus*, dbs_sEnv*, void*, pwr_tUInt32);
%dbs_tRef dbs_ItemReference(pwr_tStatus*, dbs_sEnv*, void*);
%dbs_sQlink *dbs_Qalloc(pwr_tStatus*, dbs_sEnv*);
%pwr_tBoolean dbs_QhasOne(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%void dbs_Dump(pwr_tStatus*, const dbs_sEnv*);
%pwr_tBoolean dbs_Free(pwr_tStatus*, const dbs_sEnv*, void*);
%pwr_tBoolean dbs_FreeReference(pwr_tStatus*, const dbs_sEnv*, dbs_tRef);
%dbs_tRef dbs_InDbs(pwr_tStatus*, const dbs_sEnv*, void*, pwr_tUInt32);
%dbs_tRef dbs_ItemReference(pwr_tStatus*, const dbs_sEnv*, void*);
%dbs_sQlink *dbs_Qalloc(pwr_tStatus*, const dbs_sEnv*);
%pwr_tBoolean dbs_QhasOne(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_tRef dbs_Qinit(pwr_tStatus*, dbs_sQlink*, dbs_tRef);
%dbs_sQlink *dbs_Qinsert(pwr_tStatus*, dbs_sQlink*, dbs_sQlink*, dbs_sQlink*);
%dbs_sQlink *dbs_QinsertPred(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%dbs_sQlink *dbs_QinsertSucc(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%pwr_tBoolean dbs_QisEmpty(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%pwr_tBoolean dbs_QisLinked(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%pwr_tBoolean dbs_QisNull(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qmove(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%dbs_sQlink *dbs_Qpred(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qremove(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_QremovePred(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_QremoveSucc(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qsucc(pwr_tStatus*, dbs_sEnv*, dbs_sQlink*);
%dbs_tRef dbs_RefAlloc(pwr_tStatus*, dbs_sEnv*, pwr_tUInt32);
%dbs_tRef dbs_Reference(pwr_tStatus*, dbs_sEnv*, void*);
%
%pwr_tBoolean dbs_AlignedRead(pwr_tStatus *sts, void *buf, pwr_tUInt32 size, dbs_sEnv *ep);
%dbs_sQlink *dbs_QinsertPred(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%dbs_sQlink *dbs_QinsertSucc(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%pwr_tBoolean dbs_QisEmpty(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%pwr_tBoolean dbs_QisLinked(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%pwr_tBoolean dbs_QisNull(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qmove(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*, dbs_sQlink*);
%dbs_sQlink *dbs_Qpred(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qremove(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_QremovePred(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_QremoveSucc(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_sQlink *dbs_Qsucc(pwr_tStatus*, const dbs_sEnv*, dbs_sQlink*);
%dbs_tRef dbs_RefAlloc(pwr_tStatus*, const dbs_sEnv*, pwr_tUInt32);
%dbs_tRef dbs_Reference(pwr_tStatus*, const dbs_sEnv*, void*);
%
%pwr_tBoolean dbs_AlignedRead(pwr_tStatus *sts, void *buf, pwr_tUInt32 size, const dbs_sEnv *ep);
%pwr_tBoolean dbs_Close(pwr_tStatus *sts, dbs_sEnv *ep);
%dbs_sEnv *dbs_Open(pwr_tStatus *sts, dbs_sEnv *ep, const char *filename);
%dbs_sEnv *dbs_Map(pwr_tStatus *sts, dbs_sEnv *ep, const char *filename);
%
%dbs_sObject *dbs_OidToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tOid oid);
%dbs_sObject *dbs_NameToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tOid oid, char *name);
%dbs_sObject *dbs_Parent(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_After(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_Before(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_First(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_Last(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_ClassToObject(pwr_tStatus *sts, const dbs_sEnv *ep, pwr_tCid cid);
%dbs_sObject *dbs_Next(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_Previous(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%dbs_sObject *dbs_Child(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op, char *name);
%dbs_sObject *dbs_Ancestor(pwr_tStatus *sts, const dbs_sEnv *ep, dbs_sObject *op);
%
%
%#ifdef __cplusplus
......
wb/lib/wb/src/wb_bdrep.h
View file @ eeec0970
......@@ -4,7 +4,6 @@
#include "pwr.h"
#include "wb_orep.h"
#include "wb_object.h"
#include "co_dbs.h"
#include "wb_name.h"
class wb_adef;
......
wb/lib/wb/src/wb_cdrep.h
View file @ eeec0970
......@@ -3,7 +3,6 @@
#include "pwr.h"
#include "pwr_class.h"
#include "co_dbs.h"
#include "wb_name.h"
#include "wb_orep.h"
......
wb/lib/wb/src/wb_dbs.cpp
View file @ eeec0970
......@@ -14,6 +14,7 @@
#endif
#include <X11/Intrinsic.h>
#include <assert.h>
#include "pwr.h"
#include "co_cdh.h"
......@@ -35,10 +36,18 @@
static int comp_dbs_name(tree_sTable *tp, tree_sNode *x, tree_sNode *y);
wb_dbs::wb_dbs(wb_vrep *v)
wb_dbs::wb_dbs(wb_vrep *v) :
m_oid(pwr_cNOid), m_warnings(0), m_errors(0),
m_nObjects(0), m_nTreeObjects(0), m_nClassObjects(0),
m_nNameObjects(0), m_nRbodyObjects(0), m_nDbodyObjects(0), m_oep(0)
{
pwr_tStatus sts;
memset(m_name, 0, sizeof(m_name));
memset(&m_volume, 0, sizeof(m_volume));
memset(m_sect, 0, sizeof(m_sect));
clock_gettime(CLOCK_REALTIME, &m_volume.time);
m_v = v;
......@@ -52,10 +61,10 @@ wb_dbs::wb_dbs(wb_vrep *v)
sprintf(m_name, dbs_cNameVolume, dbs_cDirectory, m_v->name());
dcli_translate_filename(m_name, m_name);
m_oix_th = tree_CreateTable(&sts, sizeof(pwr_tOid), offsetof(sOentry, o.oid),
m_oid_th = tree_CreateTable(&sts, sizeof(pwr_tOid), offsetof(sOentry, o.oid),
sizeof(sOentry), 1000, tree_Comp_oid);
m_name_th = tree_CreateTable(&sts, sizeof(dbs_sName), offsetof(sNentry, n.poix),
m_name_th = tree_CreateTable(&sts, sizeof(dbs_sName), offsetof(sNentry, n),
sizeof(sNentry), 1000, comp_dbs_name);
m_class_th = tree_CreateTable(&sts, sizeof(pwr_tCid), offsetof(sCentry, c),
......@@ -66,7 +75,15 @@ wb_dbs::~wb_dbs()
{
pwr_tStatus sts;
tree_DeleteTable(&sts, m_oix_th);
printf("m_nObjects: %d\n", m_nObjects);
printf("m_nTreeObjects: %d\n", m_nTreeObjects);
printf("m_nClassObjects: %d\n", m_nClassObjects);
printf("m_nNameObjects: %d\n", m_nNameObjects);
printf("m_nRbodyObjects: %d\n", m_nRbodyObjects);
printf("m_nDbodyObjects: %d\n", m_nDbodyObjects);
tree_DeleteTable(&sts, m_oid_th);
tree_DeleteTable(&sts, m_name_th);
tree_DeleteTable(&sts, m_class_th);
}
......@@ -75,19 +92,19 @@ wb_dbs::~wb_dbs()
static int
comp_dbs_name(tree_sTable *tp, tree_sNode *x, tree_sNode *y)
{
sNentry *xKey = (sNentry *) (tp->keyOffset + (char *) x);
sNentry *yKey = (sNentry *) (tp->keyOffset + (char *) y);
dbs_sName *xKey = (dbs_sName *) (tp->keyOffset + (char *) x);
dbs_sName *yKey = (dbs_sName *) (tp->keyOffset + (char *) y);
int comp;
if (xKey->n.poix < yKey->n.poix)
if (xKey->poix < yKey->poix)
comp = -1;
else if (xKey->n.poix == yKey->n.poix)
comp = strcmp(xKey->n.normname, yKey->n.normname);
else if (xKey->poix == yKey->poix)
comp = strcmp(xKey->normname, yKey->normname);
else
comp = 1;
// printf("%d:%s %c %d:%s\n", xKey->poix, xKey->normname, (comp == 1 ? '>' : (comp == -1 ? '<' : '=')), yKey->poix, yKey->normname);
//printf("%d:%s %c %d:%s\n", xKey->poix, xKey->normname, (comp == 1 ? '>' : (comp == -1 ? '<' : '=')), yKey->poix, yKey->normname);
return comp;
}
......@@ -98,6 +115,7 @@ wb_dbs::buildFile()
m_v->iterObject(this);
buildSectName();
checkObject(m_oep);
buildSectOid();
buildSectClass();
createFile();
}
......@@ -110,17 +128,19 @@ wb_dbs::checkObject(sOentry *oep)
dbs_sQlink *sib_lh;
dbs_sQlink *sib_ll;
sOentry *sep;
sNentry ne;
dbs_sName n;
sNentry *nep;
// Check object
if (!oep->flags.b.exist) {
printf("Object does not exist!\n");
} else {
m_volume.cardinality++;
}
m_nTreeObjects++;
//printf("tree: %s\n", oep->o.name);
oep->ref = dbs_dMakeRef(dbs_eSect_object, m_sect[dbs_eSect_object].size);
m_sect[dbs_eSect_object].size += dbs_dAlign(sizeof(dbs_sObject));
dbs_Qinit(&sts, &oep->o.sib_lh, oep->ref + offsetof(dbs_sObject, sib_lh));
......@@ -145,26 +165,27 @@ wb_dbs::checkObject(sOentry *oep)
}
/* Check name table, get reference to first and last child in name order. */
memset(&ne, 0, sizeof(ne));
ne.n.poix = oep->o.oid.oix;
nep = (sNentry*)tree_FindSuccessor(&sts, m_name_th, &ne);
memset(&n, 0, sizeof(n));
n.poix = oep->o.oid.oix;
nep = (sNentry*)tree_FindSuccessor(&sts, m_name_th, &n);
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.start = nep->n.ref;
oep->o.name_bt.start = nep->ref;
}
ne.n.poix += 1;
nep = (sNentry*)tree_FindPredecessor(&sts, m_name_th, &ne);
n.poix += 1;
nep = (sNentry*)tree_FindPredecessor(&sts, m_name_th, &n);
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.end = nep->n.ref;
oep->o.name_bt.end = nep->ref;
}
oep->o.name_bt.rsize = dbs_dAlign(sizeof(dbs_sName));
}
pwr_tStatus
wb_dbs::installObject(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid, pwr_tOid boid, pwr_tOid aoid, pwr_tOid foid,
wb_dbs::installObject(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid, pwr_tOid aoid, pwr_tOid boid, pwr_tOid foid,
pwr_tOid loid, pwr_tObjName name, pwr_tObjName normname, pwr_tTime time,
pwr_tTime rbTime, pwr_tTime dbTime, size_t rbSize, size_t dbSize)
{
sNentry ne;
sNentry *nep;
sOentry *oep;
pwr_tStatus sts;
......@@ -172,10 +193,12 @@ wb_dbs::installObject(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid, pwr_tOid boid,
if (cdh_ObjidIsNull(oid))
printf("Error: object is null!\n");
oep = (sOentry *)tree_Insert(&sts, m_oix_th, &oid);
//printf("install: %s o:%d.%d p:%d.%d b:%d.%d a:%d.%d f:%d.%d l:%d.%d \n", name, oid.vid, oid.oix, poid.vid, poid.oix, boid.vid, boid.oix, aoid.vid, aoid.oix, foid.vid, foid.oix, loid.vid, loid.oix);
oep = (sOentry *)tree_Insert(&sts, m_oid_th, &oid);
if (sts == TREE__INSERTED) {
} else {
printf("Error: object is already inserted!\n");
} else if (oep->flags.b.exist) {
printf("*** Error: object is already inserted!\n");
}
if (oid.oix == pwr_cNOix) {
......@@ -187,16 +210,17 @@ wb_dbs::installObject(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid, pwr_tOid boid,
// Link objects to its relatives
if (cdh_ObjidIsNotNull(poid))
oep->poep = (sOentry *)tree_Insert(&sts, m_oix_th, &poid);
oep->poep = (sOentry *)tree_Insert(&sts, m_oid_th, &poid);
if (cdh_ObjidIsNotNull(boid))
oep->boep = (sOentry *)tree_Insert(&sts, m_oix_th, &boid);
oep->boep = (sOentry *)tree_Insert(&sts, m_oid_th, &boid);
if (cdh_ObjidIsNotNull(aoid))
oep->aoep = (sOentry *)tree_Insert(&sts, m_oix_th, &aoid);
oep->aoep = (sOentry *)tree_Insert(&sts, m_oid_th, &aoid);
if (cdh_ObjidIsNotNull(foid))
oep->foep = (sOentry *)tree_Insert(&sts, m_oix_th, &foid);
oep->foep = (sOentry *)tree_Insert(&sts, m_oid_th, &foid);
if (cdh_ObjidIsNotNull(loid))
oep->loep = (sOentry *)tree_Insert(&sts, m_oix_th, &loid);
oep->loep = (sOentry *)tree_Insert(&sts, m_oid_th, &loid);
m_nObjects++;
m_volume.cardinality++;
#if 0
......@@ -214,12 +238,16 @@ wb_dbs::installObject(pwr_tOid oid, pwr_tCid cid, pwr_tOid poid, pwr_tOid boid,
oep->o.time = time;
if (cdh_ObjidIsNotNull(poid)) {
dbs_sName n;
/* insert into name table */
memset(&ne, 0, sizeof(ne));
ne.n.poix = poid.oix;
strcpy(ne.n.normname, normname);
nep = (sNentry*)tree_Insert(&sts, m_name_th, &ne);
memset(&n, 0, sizeof(n));
n.poix = poid.oix;
strcpy(n.normname, normname);
nep = (sNentry*)tree_Insert(&sts, m_name_th, &n);
nep->oep = oep;
}
classInsert(oep);
......@@ -264,6 +292,15 @@ wb_dbs::createFile()
printf("\n-- Working with load file volume '%s'...\n", m_v->name());
/*{
unsigned int i;
for (i = 0; i < (sizeof(m_sect)/sizeof(m_sect[0])); i++) {
printf("sect[%d]: version: %d, type: %d, size: %d, offset: %d\n", i, m_sect[i].version,
m_sect[i].type, m_sect[i].size, m_sect[i].offset);
}
}*/
printf("-- Open file...\n");
sts = openFile();
if (EVEN(sts)) goto error_handler;
......@@ -293,13 +330,13 @@ wb_dbs::createFile()
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_volref].size;
m_sect[dbs_eSect_oix].offset = size;
m_sect[dbs_eSect_oid].offset = size;
printf("-- Writing oix section...\n");
sts = writeSectOix();
printf("-- Writing oid section...\n");
sts = writeSectOid();
if (EVEN(sts)) goto error_handler;
size += m_sect[dbs_eSect_oix].size;
size += m_sect[dbs_eSect_oid].size;
m_sect[dbs_eSect_rbody].offset = size;
printf("-- Writing rbody section...\n");
......@@ -423,7 +460,7 @@ wb_dbs::writeSectDirectory()
m_sect[dbs_eSect_dir].version = dbs_cVersionDirectory;
m_sect[dbs_eSect_volume].version = dbs_cVersionVolume;
m_sect[dbs_eSect_volref].version = dbs_cVersionVolRef;
m_sect[dbs_eSect_oix].version = dbs_cVersionOix;
m_sect[dbs_eSect_oid].version = dbs_cVersionOid;
m_sect[dbs_eSect_object].version = dbs_cVersionObject;
m_sect[dbs_eSect_rbody].version = dbs_cVersionRbody;
m_sect[dbs_eSect_name].version = dbs_cVersionName;
......@@ -433,7 +470,7 @@ wb_dbs::writeSectDirectory()
m_sect[dbs_eSect_dir].type = dbs_eSect_dir;
m_sect[dbs_eSect_volume].type = dbs_eSect_volume;
m_sect[dbs_eSect_volref].type = dbs_eSect_volref;
m_sect[dbs_eSect_oix].type = dbs_eSect_oix;
m_sect[dbs_eSect_oid].type = dbs_eSect_oid;
m_sect[dbs_eSect_object].type = dbs_eSect_object;
m_sect[dbs_eSect_rbody].type = dbs_eSect_rbody;
m_sect[dbs_eSect_name].type = dbs_eSect_name;
......@@ -446,9 +483,20 @@ wb_dbs::writeSectDirectory()
if (fseek(m_fp, m_sect[dbs_eSect_dir].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
/*{
unsigned int i;
for (i = 0; i < (sizeof(m_sect)/sizeof(m_sect[0])); i++) {
printf("sect[%d]: version: %d, type: %d, size: %d, offset: %d\n", i, m_sect[i].version,
m_sect[i].type, m_sect[i].size, m_sect[i].offset);
}
}*/
if (fwrite(&m_sect, sizeof(m_sect), 1, m_fp) < 1)
return LDH__FILEWRITE;
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_dir].offset + m_sect[dbs_eSect_dir].size));
return LDH__SUCCESS;
}
......@@ -459,9 +507,6 @@ wb_dbs::writeSectVolume()
dbs_sVolume *vp = (dbs_sVolume *)v;
if (m_sect[dbs_eSect_volume].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_volume].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
......@@ -479,6 +524,8 @@ wb_dbs::writeSectVolume()
if (fwrite(v, sizeof(v), 1, m_fp) < 1)
return LDH__FILEWRITE;
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_volume].offset + m_sect[dbs_eSect_volume].size));
return LDH__SUCCESS;
}
......@@ -486,48 +533,47 @@ wb_dbs::writeSectVolume()
pwr_tStatus
wb_dbs::writeSectVolref()
{
//dbs_sVolRef volref;
if (m_sect[dbs_eSect_volref].size == 0)
return LDH__SUCCESS;
dbs_sVolRef volref;
cdh_uTid cid;
sCentry *cep;
pwr_tStatus sts;
if (fseek(m_fp, m_sect[dbs_eSect_volref].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
#if 0
memset(&volref, 0, sizeof(volref));
memset(&ce, 0, sizeof(ce));
ce.c.cid = 0;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &ce.c.cid);
cid.pwr = pwr_cNCid;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
while (cep) {
cdh_uTypeId cid;
cdh_uVolumeId vid;
cdh_uVid vid;
vid.pwr = pwr_cNVid;
cid.pwr = cep->c.cid;
vid.pwr = pwr_cNvid;
vid.v.vid_0 = cid.c.vid_0;
vid.v.vid_1 = cid.c.vid_1;
vp->vid = vid.pwr;
vp->cid = pwr_eClass_ClassVolume;
if (vid.pwr != m_volume.vid) {
printf("volref: %d.%d.%d.%d\n", vid.v.vid_0, vid.v.vid_1, vid.v.vid_2, vid.v.vid_3);
volref.vid = vid.pwr;
//volref.name = ?;
volref.cid = pwr_eClass_ClassVolume;
//vp->time = ?;
//volref.size = ?;
//volref.offset = ?;
if (fwrite(&volref, sizeof(volref), 1, m_fp) < 1)
return LDH__FILEWRITE;
m_sect[dbs_eSect_volref].size += sizeof(volref);
}
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.start = nep->n.ref;
vid.pwr++;
cid.pwr = pwr_cNCid;
cid.c.vid_0 = vid.v.vid_0;
cid.c.vid_1 = vid.v.vid_1;
cep = (sCentry*)tree_FindSuccessor(&sts, m_class_th, &cid.pwr);
}
ce.c.cid = 0;
nep = (sNentry*)tree_FindPredecessor(&sts, m_name_th, &ne);
if (nep != NULL && nep->n.poix == oep->o.oid.oix) {
oep->o.name_bt.end = nep->n.ref;
}
#endif
#if 0
sts = OpenSect(dbs_eSect_volref);
if (EVEN(sts)) return sts;
......@@ -561,8 +607,6 @@ wb_dbs::writeSectVolref()
// xdrmem_create(&xdrs, (char *) &VolRef, sizeof(VolRef), XDR_ENCODE);
// if(!xdr_dbs_sVolRef(&xdrs, &VolRef)) return LDH__XDR;
if (fwrite(&VolRef, sizeof(volRef), 1, m_fp) < 1) return LDH__FILEWRITE;
// m_head.SectSize += sizeof(volRef);
}
}
#endif
......@@ -571,38 +615,62 @@ wb_dbs::writeSectVolref()
}
pwr_tStatus
wb_dbs::writeSectOix()
wb_dbs::writeSectOid()
{
sOentry *oep;
char o[dbs_dAlign(sizeof(dbs_sOix))];
dbs_sOix *op = (dbs_sOix*)o;
char o[dbs_dAlign(sizeof(dbs_sOid))];
dbs_sOid *op = (dbs_sOid*)o;
if (m_sect[dbs_eSect_oix].size == 0)
if (m_sect[dbs_eSect_oid].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_oix].offset, SEEK_SET) != 0)
if (fseek(m_fp, m_sect[dbs_eSect_oid].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
memset(o, 0, sizeof(o));
oep = (sOentry*)tree_Minimum(NULL, m_oix_th);
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
op->oix = oep->o.oid.oix;
op->oid = oep->o.oid;
op->ref = oep->ref;
if (fwrite(o, sizeof(o), 1, m_fp) < 1)
return LDH__FILEWRITE;
oep = (sOentry*)tree_Successor(NULL, m_oix_th, (tree_sNode*)oep);
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_oid].offset + m_sect[dbs_eSect_oid].size));
return LDH__SUCCESS;
}
static pwr_tStatus
writeTree(sOentry *oep, FILE *fp)
{
pwr_tStatus sts;
if (!oep)
return 1;
if (fwrite(&oep->o, dbs_dAlign(sizeof(oep->o)), 1, fp) < 1)
return LDH__FILEWRITE;
sts = writeTree(oep->foep, fp);
if (EVEN(sts))
return sts;
sts = writeTree(oep->aoep, fp);
if (EVEN(sts))
return sts;
return 1;
}
pwr_tStatus
wb_dbs::writeSectObject()
{
sOentry *oep;
//sOentry *oep;
if (m_sect[dbs_eSect_object].size == 0)
return LDH__SUCCESS;
......@@ -610,15 +678,9 @@ wb_dbs::writeSectObject()
if (fseek(m_fp, m_sect[dbs_eSect_object].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
// @todo change to tree-order
oep = (sOentry*)tree_Minimum(NULL, m_oix_th);
while (oep != NULL) {
//printf("o.rsize[%s]: %d\n", oep->o.name, oep->rbody.size);
if (fwrite(&oep->o, dbs_dAlign(sizeof(oep->o)), 1, m_fp) < 1)
return LDH__FILEWRITE;
writeTree(m_oep, m_fp);
oep = (sOentry*)tree_Successor(NULL, m_oix_th, (tree_sNode*)oep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_object].offset + m_sect[dbs_eSect_object].size));
return LDH__SUCCESS;
}
......@@ -631,12 +693,19 @@ wb_dbs::installDbody(pwr_tOid oid, void *body)
sOentry *oep;
char b[dbs_dAlign(sizeof(dbs_sBody))];
m_nDbodyObjects++;
memset(b, 0, sizeof(b));
oep = (sOentry *)tree_Find(&sts, m_oix_th, &oid);
oep = (sOentry *)tree_Find(&sts, m_oid_th, &oid);
if (EVEN(sts)) {
}
if (oep->dbody.size == 0) {
if (body != 0) printf("error body size\n");
return 1;
}
oep->o.dbody.ref = dbs_dMakeRef(dbs_eSect_dbody, m_sect[dbs_eSect_dbody].size + dbs_dAlign(sizeof(dbs_sBody)));
m_sect[dbs_eSect_dbody].size += oep->dbody.size + sizeof(b);
......@@ -658,14 +727,13 @@ pwr_tStatus
wb_dbs::writeSectDbody()
{
if (m_sect[dbs_eSect_dbody].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_dbody].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
m_v->iterDbody(this);
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_dbody].offset + m_sect[dbs_eSect_dbody].size));
return LDH__SUCCESS;
}
......@@ -677,13 +745,22 @@ wb_dbs::installRbody(pwr_tOid oid, void *body)
sOentry *oep;
char b[dbs_dAlign(sizeof(dbs_sBody))];
m_nRbodyObjects++;
memset(b, 0, sizeof(b));
oep = (sOentry *)tree_Find(&sts, m_oix_th, &oid);
oep = (sOentry *)tree_Find(&sts, m_oid_th, &oid);
if (EVEN(sts)) {
}
//printf("install body: %u\n", (unsigned int)body);
//printf(" 1 install Rbody %s, bsize: %d, ssize: %d\n", oep->o.name, oep->rbody.size, m_sect[dbs_eSect_rbody].size);
if (oep->rbody.size == 0) {
if (body != 0) printf("error body size\n");
return 1;
}
oep->o.rbody.ref = dbs_dMakeRef(dbs_eSect_rbody, m_sect[dbs_eSect_rbody].size + dbs_dAlign(sizeof(dbs_sBody)));
oep->o.rbody.ref = dbs_dMakeRef(dbs_eSect_rbody, m_sect[dbs_eSect_rbody].size + sizeof(b));
m_sect[dbs_eSect_rbody].size += oep->rbody.size + sizeof(b);
memcpy(b, &oep->rbody, sizeof(oep->rbody));
......@@ -691,11 +768,13 @@ wb_dbs::installRbody(pwr_tOid oid, void *body)
if (fwrite(b, sizeof(b), 1, m_fp) < 1)
return LDH__FILEWRITE;
//printf(" 2 install Rbody %s, bsize: %d, ssize: %d\n", oep->o.name, oep->rbody.size, m_sect[dbs_eSect_rbody].size);
/* @todo!!! objdid_self */
if (fwrite(body, oep->rbody.size, 1, m_fp) < 1)
return LDH__FILEWRITE;
//printf(" 3 install Rbody %s, bsize: %d, ssize: %d\n", oep->o.name, oep->rbody.size, m_sect[dbs_eSect_rbody].size);
return sts;
}
......@@ -704,14 +783,13 @@ pwr_tStatus
wb_dbs::writeSectRbody()
{
if (m_sect[dbs_eSect_rbody].size == 0)
return LDH__SUCCESS;
if (fseek(m_fp, m_sect[dbs_eSect_rbody].offset, SEEK_SET) != 0)
return LDH__FILEPOS;
m_v->iterRbody(this);
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_rbody].offset + m_sect[dbs_eSect_rbody].size));
return LDH__SUCCESS;
}
......@@ -728,12 +806,17 @@ wb_dbs::writeSectName()
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
//printf("name: %s, poix: %d\n", nep->n.normname, nep->n.poix);
nep->n.ref = nep->oep->ref;
if (fwrite(&nep->n, dbs_dAlign(sizeof(nep->n)), 1, m_fp) < 1)
return LDH__FILEWRITE;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_name].offset + m_sect[dbs_eSect_name].size));
return LDH__SUCCESS;
}
......@@ -751,15 +834,40 @@ wb_dbs::writeSectClass()
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
//printf("class: %d, nObjects: %d\n", cep->c.cid, cep->c.nObjects);
if (fwrite(&cep->c, dbs_dAlign(sizeof(cep->c)), 1, m_fp) < 1)
return LDH__FILEWRITE;
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
assert(ftell(m_fp) == (long)(m_sect[dbs_eSect_class].offset + m_sect[dbs_eSect_class].size));
return LDH__SUCCESS;
}
void
wb_dbs::buildSectOid()
{
sOentry *oep;
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
while (oep != NULL) {
oep->oidref = dbs_dMakeRef(dbs_eSect_oid, m_sect[dbs_eSect_oid].size);
m_sect[dbs_eSect_oid].size += dbs_dAlign(sizeof(dbs_sOid));
oep = (sOentry*)tree_Successor(NULL, m_oid_th, (tree_sNode*)oep);
}
oep = (sOentry*)tree_Minimum(NULL, m_oid_th);
if (oep != NULL) {
m_volume.oid_bt.start = oep->oidref;
oep = (sOentry*)tree_Maximum(NULL, m_oid_th);
m_volume.oid_bt.end = oep->oidref;
m_volume.oid_bt.rsize = dbs_dAlign(sizeof(dbs_sOid));
}
}
void
wb_dbs::buildSectName()
{
......@@ -769,11 +877,21 @@ wb_dbs::buildSectName()
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
while (nep != NULL) {
nep->n.ref = dbs_dMakeRef(dbs_eSect_name, m_sect[dbs_eSect_name].size);
nep->ref = dbs_dMakeRef(dbs_eSect_name, m_sect[dbs_eSect_name].size);
m_sect[dbs_eSect_name].size += dbs_dAlign(sizeof(dbs_sName));
m_nNameObjects++;
nep = (sNentry*)tree_Successor(NULL, m_name_th, (tree_sNode*)nep);
}
nep = (sNentry*)tree_Minimum(NULL, m_name_th);
if (nep != NULL) {
m_volume.name_bt.start = nep->ref;
nep = (sNentry*)tree_Maximum(NULL, m_name_th);
m_volume.name_bt.end = nep->ref;
m_volume.name_bt.rsize = dbs_dAlign(sizeof(dbs_sName));
}
}
void
......@@ -790,19 +908,30 @@ wb_dbs::buildSectClass()
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
while (cep != NULL) {
ref = dbs_dMakeRef(dbs_eSect_class, m_sect[dbs_eSect_class].size);
ref = cep->ref = dbs_dMakeRef(dbs_eSect_class, m_sect[dbs_eSect_class].size);
m_sect[dbs_eSect_class].size += dbs_dAlign(sizeof(dbs_sClass));
dbs_Qinit(&sts, &cep->c.o_lh, ref + offsetof(dbs_sClass, o_lh));
// Link all object instances to this class
o_lh = o_ll = &cep->c.o_lh;
for (oep = cep->o_lh; oep != 0; oep = oep->o_ll) {
cep->c.nObjects++;
m_nClassObjects++;
dbs_Qinsert(&sts, o_ll, &oep->o.o_ll, o_lh);
o_ll = &oep->o.o_ll;
}
cep = (sCentry*)tree_Successor(NULL, m_class_th, (tree_sNode*)cep);
}
cep = (sCentry*)tree_Minimum(NULL, m_class_th);
if (cep != NULL) {
m_volume.class_bt.start = cep->ref;
cep = (sCentry*)tree_Maximum(NULL, m_class_th);
m_volume.class_bt.end = cep->ref;
m_volume.class_bt.rsize = dbs_dAlign(sizeof(dbs_sClass));
}
}
void
......
wb/lib/wb/src/wb_dbs.h
View file @ eeec0970
......@@ -31,6 +31,7 @@ struct sOentry {
dbs_sBody dbody;
mOentry flags;
dbs_tRef ref;
dbs_tRef oidref;
sOentry *poep;
sOentry *boep;
......@@ -46,12 +47,14 @@ struct sOentry {
struct sNentry {
tree_sNode node;
dbs_sName n;
dbs_tRef ref;
sOentry *oep;
};
struct sCentry {
tree_sNode node;
dbs_sClass c;
dbs_tRef ref;
sOentry *o_lh; // Header of object list
sOentry *o_lt; // Tail of object list
};
......@@ -73,9 +76,16 @@ public:
unsigned int m_warnings;
unsigned int m_errors;
unsigned int m_nObjects;
unsigned int m_nTreeObjects;
unsigned int m_nClassObjects;
unsigned int m_nNameObjects;
unsigned int m_nRbodyObjects;
unsigned int m_nDbodyObjects;
sOentry *m_oep; /* object entry of volume object */
tree_sTable *m_oix_th;
tree_sTable *m_oid_th;
tree_sTable *m_name_th;
tree_sTable *m_class_th;
......@@ -92,6 +102,7 @@ public:
void buildFile();
void buildSectName();
void buildSectOid();
void buildSectClass();
void checkObject(sOentry *oep);
pwr_tStatus closeFile(pwr_tBoolean doDelete);
......@@ -110,7 +121,7 @@ public:
pwr_tStatus writeSectDirectory();
pwr_tStatus writeSectVolume();
pwr_tStatus writeSectVolref();
pwr_tStatus writeSectOix();
pwr_tStatus writeSectOid();
pwr_tStatus writeSectObject();
pwr_tStatus writeSectRbody();
pwr_tStatus writeSectName();
......
wb/lib/wb/src/wb_orepdbs.cpp
View file @ eeec0970
......@@ -3,17 +3,18 @@
#include "wb_ldh_msg.h"
#include "wb_error.h"
/*
void * wb_orepdbs::operator new(size_t size, wb_vrepdbs *v)
void *
wb_orepdbs::operator new(size_t size, wb_vrepdbs *v)
{
return v->newOrepDbs(size);
return (void *)v->new_wb_repdbs(size);
}
void wb_orepdbs::operator delete(size_t size, void *p, wb_vrepdbs *v)
void
wb_orepdbs::operator delete(void *p, size_t size, wb_vrepdbs *v)
{
v->deleteOrepDbs(size, p);
v->delete_wb_orepdbs(size, p);
}
*/
wb_orepdbs::wb_orepdbs(dbs_sObject *o)
{
......@@ -74,44 +75,50 @@ char * const wb_orepdbs::name()
wb_orep *wb_orepdbs::after(pwr_tStatus *sts) const
{
dbs_sQlink *succ = dbs_Qsucc(sts, m_vrep->m_dbsenv, &m_o->sib_ll);
if (succ == 0)
return 0;
return new (m_vrep) wb_orepdbs(dbs_Qitem(succ, dbs_sObject, sib_ll));
return m_vrep->after(sts, (wb_orep*)this);
}
wb_orep *wb_orepdbs::before(pwr_tStatus *sts) const
{
dbs_sQlink *pred = dbs_Qpred(sts, m_vrep->m_dbsenv, &m_o->sib_ll);
if (pred == 0)
return 0;
return new (m_vrep) wb_orepdbs(dbs_Qitem(pred, dbs_sObject, sib_ll));
return m_vrep->before(sts, (wb_orep*)this);
}
wb_orep *wb_orepdbs::parent(pwr_tStatus *sts) const
{
if (m_o->pref == dbs_cNref) {
*sts = LDH__NO_PARENT;
return 0;
}
return m_vrep->parent(sts, (wb_orep*)this);
}
dbs_sObject *dbs_o = (dbs_sObject*)dbs_Address(sts, m_vrep->m_dbsenv, m_o->pref);
if (dbs_o == 0) {
return 0;
}
wb_orep *wb_orepdbs::first(pwr_tStatus *sts) const
{
return m_vrep->first(sts, (wb_orep*)this);
}
wb_orep *wb_orepdbs::child(pwr_tStatus *sts, char *name) const
{
return m_vrep->child(sts, (wb_orep*)this, name);
}
wb_orep *wb_orepdbs::last(pwr_tStatus *sts) const
{
return m_vrep->last(sts, (wb_orep*)this);
}
return new (m_vrep) wb_orepdbs(dbs_o);
wb_orep *wb_orepdbs::next(pwr_tStatus *sts) const
{
return m_vrep->next(sts, (wb_orep*)this);
}
wb_orep *wb_orepdbs::previous(pwr_tStatus *sts) const
{
return m_vrep->previous(sts, (wb_orep*)this);
}
wb_adrep *attribute(pwr_tStatus *sts)
wb_adrep *wb_orepdbs::attribute(pwr_tStatus *sts)
{
return 0;;
}
wb_adrep *attribute(pwr_tStatus *sts, const char *name)
wb_adrep *wb_orepdbs::attribute(pwr_tStatus *sts, const char *name)
{
return 0;//m_vrep->attribute(sts, cid(), name);
}
wb/lib/wb/src/wb_orepdbs.h
View file @ eeec0970
......@@ -22,8 +22,8 @@ public:
wb_orepdbs(dbs_sObject *o);
~wb_orepdbs();
// void* operator new(size_t size, wb_vrepdbs *v);
// void operator delete(void *p, size_t size, wb_vrepdbs *v);
void* operator new(size_t size, wb_vrepdbs *v);
void operator delete(void *p, size_t size, wb_vrepdbs *v);
virtual pwr_tOid oid() const;
virtual pwr_tVid vid() const;
......@@ -63,6 +63,8 @@ public:
wb_erep *erep() const { return m_vrep->erep();}
wb_vrep *vrep() const { return m_vrep;}
dbs_sObject *o() const { return m_o;}
};
#endif
wb/lib/wb/src/wb_vrep.h
View file @ eeec0970
......@@ -62,23 +62,23 @@ public:
virtual bool writeBody() = 0;
virtual wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *parent(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *parent(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *after(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *after(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *before(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *before(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *first(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *first(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name) const = 0;
virtual wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name) = 0;
virtual wb_orep *last(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *last(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *next(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *next(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_orep *previous(pwr_tStatus *sts, wb_orep *o) const = 0;
virtual wb_orep *previous(pwr_tStatus *sts, wb_orep *o) = 0;
virtual wb_srep *newSession() = 0;
......
wb/lib/wb/src/wb_vrepdbs.cpp
View file @ eeec0970
......@@ -13,18 +13,44 @@ wb_vrep *wb_vrepdbs::ref()
return this;
}
wb_vrepdbs::wb_vrepdbs()
#if 1
wb_vrepdbs::wb_vrepdbs(const char *fileName)
{
pwr_tStatus sts;
dbs_sEnv *ep =dbs_Map(&sts, &m_dbsenv, fileName);
if (!ep)
ep = 0;
}
wb_orep *wb_vrepdbs::object(pwr_tStatus *sts, pwr_tOid oid)
{
//wb_orepdbs *o = new wb_orepdbs();
dbs_sObject *op = dbs_OidToObject(sts, &m_dbsenv, oid);
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::object(pwr_tStatus *sts, wb_orep *parent, wb_name name)
{
#if 0
dbs_sName n;
n.poix = parent->oix();
strcpy(n.normname, name.normName(cdh_mName_object));
dbs_sName *nrp = dbs_Bfind(&sts, &m_dbsenv, m_dbs.name_bt, &n, dbs_CompName);
if (!nrp)
return 0;
dbs_Object *o = dbs_Address(&sts, &m_dbsenv, nrp->ref);
if (!o)
return 0;
return new (this) orepdbs(o);
#endif
return 0;
}
......@@ -108,57 +134,93 @@ bool wb_vrepdbs::writeBody()
}
wb_orep *wb_vrepdbs::ancestor(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::ancestor(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Ancestor(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::parent(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::parent(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Parent(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::after(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::after(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_After(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::before(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::before(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Before(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::first(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::first(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_First(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::child(pwr_tStatus *sts, wb_orep *o, char *name) const
wb_orep *wb_vrepdbs::child(pwr_tStatus *sts, wb_orep *o, char *name)
{
dbs_sObject *op = dbs_Child(sts, &m_dbsenv, ((wb_orepdbs *)o)->o(), name);
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::last(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::last(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Last(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::next(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::next(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Next(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
wb_orep *wb_vrepdbs::previous(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepdbs::previous(pwr_tStatus *sts, wb_orep *o)
{
dbs_sObject *op = dbs_Previous(sts, &m_dbsenv, ((wb_orepdbs *)o)->o());
if (op == 0)
return 0;
return new (this) wb_orepdbs(op);
}
......@@ -166,3 +228,4 @@ wb_srep *wb_vrepdbs::newSession()
{
return (wb_srep*)0;
}
#endif
wb/lib/wb/src/wb_vrepdbs.h
View file @ eeec0970
......@@ -16,10 +16,10 @@ public:
unsigned int m_nSession;
unsigned int m_nRef;
dbs_sEnv *m_dbsenv;
dbs_sEnv m_dbsenv;
wb_vrepdbs();
wb_vrepdbs(const char *fileName);
virtual void unref();
virtual wb_vrep *ref();
......@@ -54,28 +54,31 @@ public:
virtual bool writeBody();
virtual wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *parent(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *parent(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *after(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *after(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *before(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *before(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *first(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *first(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name) const;
virtual wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name);
virtual wb_orep *last(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *last(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *next(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *next(pwr_tStatus *sts, wb_orep *o);
virtual wb_orep *previous(pwr_tStatus *sts, wb_orep *o) const;
virtual wb_orep *previous(pwr_tStatus *sts, wb_orep *o);
virtual wb_srep *newSession();
virtual bool isLocal(wb_orep *o) const;
virtual bool isLocal(wb_orep *o);
virtual pwr_tVid vid() const;
wb_orepdbs *new_wb_repdbs(size_t size);
void delete_wb_orepdbs(size_t size, void *p);
};
#endif
wb/lib/wb/src/wb_vrepwbl.cpp
View file @ eeec0970
......@@ -927,7 +927,7 @@ wb_orep *wb_vrepwbl::object(pwr_tStatus *sts)
return orep;
}
wb_orep *wb_vrepwbl::ancestor(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::ancestor(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -941,7 +941,7 @@ wb_orep *wb_vrepwbl::ancestor(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::parent(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::parent(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -955,7 +955,7 @@ wb_orep *wb_vrepwbl::parent(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::after(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::after(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -968,7 +968,7 @@ wb_orep *wb_vrepwbl::after(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::before(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::before(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -982,7 +982,7 @@ wb_orep *wb_vrepwbl::before(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::first(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::first(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -996,12 +996,12 @@ wb_orep *wb_vrepwbl::first(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::child(pwr_tStatus *sts, wb_orep *o, char *name) const
wb_orep *wb_vrepwbl::child(pwr_tStatus *sts, wb_orep *o, char *name)
{
return 0;
}
wb_orep *wb_vrepwbl::last(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::last(pwr_tStatus *sts, wb_orep *o)
{
wb_orepwbl *orep = 0;
......@@ -1017,12 +1017,12 @@ wb_orep *wb_vrepwbl::last(pwr_tStatus *sts, wb_orep *o) const
return orep;
}
wb_orep *wb_vrepwbl::next(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::next(pwr_tStatus *sts, wb_orep *o)
{
return 0;
}
wb_orep *wb_vrepwbl::previous(pwr_tStatus *sts, wb_orep *o) const
wb_orep *wb_vrepwbl::previous(pwr_tStatus *sts, wb_orep *o)
{
return 0;
}
......
wb/lib/wb/src/wb_vrepwbl.h
View file @ eeec0970
......@@ -150,23 +150,23 @@ public:
bool writeBody() {return false;};
wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *ancestor(pwr_tStatus *sts, wb_orep *o);
wb_orep *parent(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *parent(pwr_tStatus *sts, wb_orep *o);
wb_orep *after(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *after(pwr_tStatus *sts, wb_orep *o);
wb_orep *before(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *before(pwr_tStatus *sts, wb_orep *o);
wb_orep *first(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *first(pwr_tStatus *sts, wb_orep *o);
wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name) const;
wb_orep *child(pwr_tStatus *sts, wb_orep *o, char *name);
wb_orep *last(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *last(pwr_tStatus *sts, wb_orep *o);
wb_orep *next(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *next(pwr_tStatus *sts, wb_orep *o);
wb_orep *previous(pwr_tStatus *sts, wb_orep *o) const;
wb_orep *previous(pwr_tStatus *sts, wb_orep *o);
wb_srep *newSession() {return 0;};
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7