epics/pcas
0
0
Fork 0
Code Issues Pull Requests Projects Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
Jim Kowalkowski
1997-03-21 01:56:12 +00:00
parent 4c99a53852
commit 54e6f9aed1
19 changed files with 1783 additions and 1421 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gdd/Makefile.Host
+14 -4
View File
@@ -7,8 +7,15 @@ include $(TOP)/config/CONFIG_BASE
#OPTIM_YES=-g
INC += gdd.h
INC += gddI.h
INC += gddContainer.h
INC += gddContainerI.h
INC += gddArray.h
INC += gddScalar.h
INC += gddSemaphore.h
INC += gddNewDel.h
INC += gddUtils.h
INC += gddUtilsI.h
INC += gddErrorCodes.h
INC += aitTypes.h
INC += aitConvert.h
@@ -20,13 +27,15 @@ INC += gddAppFuncTable.cc
INC += gddApps.h
LIBSRCS := gdd.cc gddTest.cc gddAppTable.cc gddNewDel.cc \
gddAppDefs.cc aitTypes.c aitConvert.cc aitHelpers.cc dbMapper.cc
gddAppDefs.cc aitTypes.c aitConvert.cc aitHelpers.cc dbMapper.cc \
gddArray.cc gddContainer.cc gddErrorCodes.cc gddUtils.cc
LIBRARY := gdd
# build locally:
TESTPROD:=genApps
TESTPROD_SRCS:=genApps.cc gdd.cc gddTest.cc gddAppTable.cc\
TESTPROD_SRCS:=genApps.cc gdd.cc gddArray.cc gddContainer.cc \
gddTest.cc gddErrorCodes.cc gddUtils.cc gddAppTable.cc\
gddNewDel.cc gddAppDefs.cc \
aitTypes.cc aitConvert.cc aitHelpers.cc
@@ -40,8 +49,9 @@ include $(TOP)/config/RULES.Host
# -> use explicit reference to the uninstalled files in '..'
aitConvert$(OBJ): aitConvert.cc aitConvertGenerated.cc\
../aitConvert.h ../aitTypes.h
dbMapper.cc: ../gdd.h ../gddAppTable.h ../dbMapper.h\
./gddApps.h ../aitTypes.h
dbMapper.cc: ../gdd.h ../gddI.h ../gddContainer.h ../gddContainerI.h \
../gddArray.h ../gddScalar.h ../gddAppTable.h ../dbMapper.h \
./gddApps.h ../aitTypes.h ../gddUtils.h ../gddUtilsI.h
# Rules for generated files
#
src/gdd/Makefile.regular
+17 -5
View File
@@ -5,6 +5,9 @@
# $Id$
#
# $Log$
# Revision 1.1 1996/09/12 11:18:46 jbk
# makefile to build library outside of EPICS tree
#
#
DEPENDS_FLAG = -M # -xM
@@ -17,27 +20,36 @@ CFLAGS = $(CCFLAGS)
AR = ar
SRCS = aitGen.c aitTypes.c aitHelpers.cc \
gdd.cc gddAppDefs.cc gddAppTable.cc gddNewDel.cc \
gddTest.cc genApps.cc
gdd.cc gddTest.cc gddArray.cc gddContainer.cc \
gddAppDefs.cc gddAppTable.cc gddNewDel.cc \
gddErrorCodes.cc gddUtils.cc genApps.cc
MY_OBJS = gdd.o gddTest.o gddAppTable.o gddNewDel.o gddAppDefs.o \
aitTypes.o aitConvert.o aitHelpers.o
aitTypes.o aitConvert.o aitHelpers.o gddArray.o gddContainer.o \
gddUtils.o gddErrorCodes.o
LIBOBJS = $(MY_OBJS) dbMapper.o
LIBNAME = libgdd.a
HEADS = gdd.h gddI.h gddContainer.h gddContainerI.h gddArray.h \
gddScalar.h gddUtils.h
all: $(LIBNAME) dbMapper.o
$(LIBNAME): $(LIBOBJS)
$(AR) r $(LIBNAME) $@
$(AR) r $(LIBNAME) $^
# cannot generate dependencies for aitConvert automatically
gdd.o: gdd.cc
gddTest.o: gddTest.cc
gddArray.o: gddArray.cc
gddContainer.o: gddContainer.cc
gddAppTable.o: gddAppTable.cc
gddAppDefs.o: gddAppDefs.cc
gddNewDel.o: gddNewDel.cc
gddUtils.o: gddUtils.cc
gddErrorCodes.o: gddErrorCodes.cc
aitHelpers.o: aitHelpers.cc
aitTypes.o: aitTypes.c
aitConvert.o: aitConvert.cc aitConvert.h aitConvertGenerated.cc aitTypes.h
@@ -50,7 +62,7 @@ aitGen: aitGen.o aitTypes.o
# cannot generate dependencies for dbMapper.o automatically
dbMapper.o: dbMapper.cc gdd.h gddAppTable.h dbMapper.h gddApps.h aitTypes.h
dbMapper.o: dbMapper.cc $(HEADS) gddAppTable.h dbMapper.h gddApps.h aitTypes.h
$(COMPILE.cc) -I$(HOME)/include $<
$(AR) r $(LIBNAME) $@
src/gdd/aitHelpers.h
+6 -3
View File
@@ -8,6 +8,9 @@
* $Id$
*
* $Log$
* Revision 1.10 1996/11/02 01:28:15 jhill
* removed merge problems
*
* Revision 1.9 1996/11/02 01:24:42 jhill
* strcpy => styrcpy (shuts up purify)
*
@@ -291,7 +294,7 @@ inline int aitString::cset(const char* p,aitUint32 l)
}
inline int aitString::copy(const char* p)
{ return p?cset(p,strlen(p)):-1; }
{ return p?set(p,strlen(p)):-1; }
inline int aitString::copy(char* p)
{ return p?set(p,strlen(p)):-1; }
inline int aitString::copy(aitString* p)
@@ -299,9 +302,9 @@ inline int aitString::copy(aitString* p)
inline int aitString::copy(aitString& p)
{ return set((char*)p,p.length()); }
inline int aitString::copy(const aitString* p)
{ return p?cset((const char*)*p,p->length()):-1; }
{ return p?set((const char*)*p,p->length()):-1; }
inline int aitString::copy(const aitString& p)
{ return cset((const char*)p,p.length()); }
{ return set((const char*)p,p.length()); }
inline void aitString::replaceData(const char* p)
{ if(p && str) strncpy(str,p,len); }
src/gdd/aitTypes.h
+14
View File
@@ -8,6 +8,9 @@
* $Id$
*
* $Log$
* Revision 1.2 1996/08/22 21:05:40 jbk
* More fixes to make strings and fixed string work better.
*
* Revision 1.1 1996/06/25 19:11:33 jbk
* new in EPICS base
*
@@ -67,6 +70,17 @@ typedef struct {
} aitString;
#endif
#ifndef vxWorks
#if (_POSIX_C_SOURCE < 3) && !defined(solaris) && !defined(SOLARIS)
struct timespec
{
time_t tv_sec;
long tv_nsec;
};
typedef struct timespec timespec;
#endif
#endif
/* all normal types */
#define aitTotal 13
#define aitFirst aitEnumInvalid
src/gdd/gdd.cc
+209 -296
View File
@@ -4,6 +4,9 @@
// $Id$
//
// $Log$
// Revision 1.19 1997/03/17 17:14:46 jbk
// fixed a problem with gddDestructor and reference counting
//
// Revision 1.18 1997/01/21 15:13:06 jbk
// free up resources in clearData
//
@@ -74,64 +77,25 @@
#include <stdarg.h>
#include "gdd.h"
gdd_NEWDEL_NEW(gddBounds1D)
gdd_NEWDEL_DEL(gddBounds1D)
gdd_NEWDEL_STAT(gddBounds1D)
gdd_NEWDEL_NEW(gddBounds2D)
gdd_NEWDEL_DEL(gddBounds2D)
gdd_NEWDEL_STAT(gddBounds2D)
gdd_NEWDEL_NEW(gddBounds3D)
gdd_NEWDEL_DEL(gddBounds3D)
gdd_NEWDEL_STAT(gddBounds3D)
gdd_NEWDEL_NEW(gddDestructor)
gdd_NEWDEL_DEL(gddDestructor)
gdd_NEWDEL_STAT(gddDestructor)
gdd_NEWDEL_NEW(gdd)
gdd_NEWDEL_DEL(gdd)
gdd_NEWDEL_STAT(gdd)
// -------------------------- Error messages -------------------------
char* gddErrorMessages[]=
class gddFlattenDestructor : public gddDestructor
{
"Invalid",
"TypeMismatch",
"NotAllowed",
"AlreadyDefined",
"NewFailed",
"OutOfBounds",
"AtLimit",
"NotDefined",
"NotSupported",
"Overflow",
"Underflow"
public:
gddFlattenDestructor(void) { }
gddFlattenDestructor(void* user_arg):gddDestructor(user_arg) { }
void run(void*);
};
// --------------------------The gddBounds functions-------------------
// gddBounds::gddBounds(void) { first=0; count=0; }
// --------------------------The gddDestructor functions-------------------
gddStatus gddDestructor::destroy(void* thing)
class gddContainerCleaner : public gddDestructor
{
if(ref_cnt==0 || --ref_cnt==0)
{
run(thing);
delete this;
}
return 0;
}
void gddDestructor::run(void* thing)
{
aitInt8* pd = (aitInt8*)thing;
delete [] pd;
}
public:
gddContainerCleaner(void) { }
gddContainerCleaner(void* user_arg):gddDestructor(user_arg) { }
void run(void*);
};
void gddFlattenDestructor::run(void*)
{
@@ -315,14 +279,14 @@ gddStatus gdd::replaceDestructor(gddDestructor* dest)
return 0;
}
gddStatus gdd::genCopy(aitEnum t, const void* d)
gddStatus gdd::genCopy(aitEnum t, const void* d, aitDataFormat f)
{
size_t sz;
aitInt8* buf;
gddStatus rc=0;
if(isScalar())
aitConvert(primitiveType(),dataAddress(),t,d,1);
set(t,d,f);
else if(isAtomic())
{
if(!dataPointer())
@@ -338,13 +302,19 @@ gddStatus gdd::genCopy(aitEnum t, const void* d)
setData(buf);
destruct=new gddDestructor;
destruct->reference();
aitConvert(primitiveType(),dataPointer(),t,d,
getDataSizeElements());
}
}
else
aitConvert(primitiveType(),dataPointer(),t,d,
getDataSizeElements());
if(rc==0)
{
if(f==aitLocalDataFormat)
aitConvert(primitiveType(),dataPointer(),t,d,
getDataSizeElements());
else
aitConvertFromNet(primitiveType(),dataPointer(),t,d,
getDataSizeElements());
markLocalDataFormat();
}
}
else
{
@@ -1391,265 +1361,208 @@ gddStatus gdd::put(const gdd* dd)
return rc;
}
// ----------------------The gddAtomic functions-------------------------
gddAtomic::gddAtomic(int app, aitEnum prim, int dimen, ...):
gdd(app,prim,dimen)
size_t gdd::outHeader(void* buf,aitUint32 bufsize)
{
va_list ap;
int i;
aitIndex val;
// simple encoding for now.. will change later
// this is the SLOW, simple version
va_start(ap,dimen);
for(i=0;i<dimen;i++)
aitUint8* b = (aitUint8*)buf;
aitUint8* app = (aitUint8*)&appl_type;
aitUint8* stat = (aitUint8*)&status;
aitUint8* ts_sec = (aitUint8*)&time_stamp.tv_sec;
aitUint8* ts_nsec = (aitUint8*)&time_stamp.tv_nsec;
int i,j,sz;
aitIndex ff,ss;
aitUint8 *f,*s;
// verify that header will fit into buffer first
sz=4+sizeof(status)+sizeof(time_stamp)+sizeof(appl_type)+
sizeof(prim_type)+sizeof(dim)+(dim*sizeof(gddBounds));
if(sz>bufsize) return 0; // blow out here!
*(b++)='H'; *(b++)='E'; *(b++)='A'; *(b++)='D';
// how's this for putrid
*(b++)=dim;
*(b++)=prim_type;
if(aitLocalNetworkDataFormatSame)
{
val=va_arg(ap,aitUint32);
bounds[i].set(0,val);
*(b++)=app[0]; *(b++)=app[1];
for(i=0;i<sizeof(status);i++) *(b++)=stat[i];
for(i=0;i<sizeof(time_stamp.tv_sec);i++) *(b++)=ts_sec[i];
for(i=0;i<sizeof(time_stamp.tv_nsec);i++) *(b++)=ts_nsec[i];
}
va_end(ap);
}
gddStatus gddAtomic::getBoundingBoxSize(aitUint32* b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) b[i]=bounds[i].size();
else
{
gddAutoPrint("gddAtomic::getBoundingBoxSize()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
*(b++)=app[1]; *(b++)=app[0];
for(i=sizeof(status)-1;i>=0;i--) *(b++)=stat[i];
for(i=sizeof(time_stamp.tv_sec)-1;i>=0;i--) *(b++)=ts_sec[i];
for(i=sizeof(time_stamp.tv_nsec)-1;i>=0;i--) *(b++)=ts_nsec[i];
}
return rc;
}
gddStatus gddAtomic::setBoundingBoxSize(const aitUint32* const b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) bounds[i].setSize(b[i]);
else
// put out the bounds info
for(j=0;j<dim;j++)
{
gddAutoPrint("gddAtomic::setBoundingBoxSize()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
gddStatus gddAtomic::getBoundingBoxOrigin(aitUint32* b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) b[i]=bounds[i].first();
else
{
gddAutoPrint("gddAtomic::getBoundingBoxOrigin()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
gddStatus gddAtomic::setBoundingBoxOrigin(const aitUint32* const b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) bounds[i].setFirst(b[i]);
else
{
gddAutoPrint("gddAtomic::setBoundingBoxOrigin",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
// --------------------The gddScalar functions---------------------
// --------------------The gddContainer functions---------------------
gddCursor gddContainer::getCursor(void) const
{
gddCursor ec(this);
return ec;
}
gddContainer::gddContainer(void):gdd(0,aitEnumContainer,1) { }
gddContainer::gddContainer(int app):gdd(app,aitEnumContainer,1) { }
gddContainer::gddContainer(int app,int tot) : gdd(app,aitEnumContainer,1)
{ cInit(tot); }
void gddContainer::cInit(int tot)
{
int i;
gdd* dd_list;
gdd* temp;
setBound(0,0,tot);
dd_list=NULL;
for(i=0;i<tot;i++)
{
temp=new gdd;
temp->noReferencing();
temp->setNext(dd_list);
dd_list=temp;
}
setData(dd_list);
}
gddContainer::gddContainer(gddContainer* ec)
{
unsigned i;
gdd* dd_list;
gdd* temp;
copy(ec);
dd_list=NULL;
// this needs to recursively add to the container, only copy the
// info and bounds information and scaler data, not arrays
for(i=0;i<dimension();i++)
{
temp=new gdd(getDD(i));
temp->noReferencing();
temp->setNext(dd_list);
dd_list=temp;
}
setData(dd_list);
}
gdd* gddContainer::getDD(aitIndex index)
{
if (index==0u) {
return this;
}
else if(index>getDataSizeElements())
return NULL;
else
{
aitIndex i;
gdd* dd=(gdd*)dataPointer();
for(i=1u;i<index;i++) {
dd=(gdd*)dd->next();
ff=bounds[j].first(); f=(aitUint8*)&ff;
ss=bounds[j].size(); s=(aitUint8*)&ss;
if(aitLocalNetworkDataFormatSame)
{
for(i=0;i<sizeof(aitIndex);i++) *(b++)=s[i];
for(i=0;i<sizeof(aitIndex);i++) *(b++)=f[i];
}
return dd;
}
}
gddStatus gddContainer::insert(gdd* dd)
{
dd->setNext(cData());
setData(dd);
bounds->setSize(bounds->size()+1);
return 0;
}
gddStatus gddContainer::remove(aitIndex index)
{
gddCursor cur = getCursor();
gdd *dd,*prev_dd;
aitIndex i;
prev_dd=NULL;
for(i=0; (dd=cur[i]) && i!=index; i++) prev_dd=dd;
if(i==index && dd)
{
if(prev_dd)
prev_dd->setNext(dd->next());
else
setData(dd->next());
dd->unreference();
bounds->setSize(bounds->size()-1);
return 0;
}
else
{
gddAutoPrint("gddContainer::remove()",gddErrorOutOfBounds);
return gddErrorOutOfBounds;
{
for(i=sizeof(aitIndex)-1;i>=0;i--) *(b++)=s[i];
for(i=sizeof(aitIndex)-1;i>=0;i--) *(b++)=f[i];
}
}
return sz;
}
// ------------------------cursor functions-------------------------------
gdd* gddCursor::operator[](int index)
size_t gdd::outData(void* buf,aitUint32 bufsize, aitEnum e, aitDataFormat f)
{
int i,start;
gdd* dd;
// put data into user's buffer in the format that the user wants (e/f).
// if e is invalid, then use whatever format this gdd describes.
if(index>=curr_index)
aitUint32 sz = getDataSizeElements();
aitUint32 len = getDataSizeBytes();
aitEnum type=(e==aitEnumInvalid)?primitiveType():e;
if(len>bufsize) return 0; // blow out early
if(sz>0)
{
start=curr_index;
dd=curr;
if(f==aitLocalDataFormat)
aitConvert(type,buf,primitiveType(),dataVoid(),sz);
else
aitConvertToNet(type,buf,primitiveType(),dataVoid(),sz);
}
return len;
}
size_t gdd::out(void* buf,aitUint32 bufsize,aitDataFormat f)
{
size_t index = outHeader(buf,bufsize);
size_t rc;
if(index>0)
rc=outData(((char*)buf)+index,bufsize-index,aitEnumInvalid,f)+index;
else
rc=0;
return rc;
}
size_t gdd::inHeader(void* buf)
{
// simple encoding for now.. will change later
// this is the SLOW, simple version
aitUint16 inapp;
aitUint8 inprim;
aitUint8 indim;
aitUint8* b = (aitUint8*)buf;
aitUint8* b1 = b;
aitUint8* app = (aitUint8*)&inapp;
aitUint8* stat = (aitUint8*)&status;
aitUint8* ts_sec = (aitUint8*)&time_stamp.tv_sec;
aitUint8* ts_nsec = (aitUint8*)&time_stamp.tv_nsec;
int i,j;
aitIndex ff,ss;
aitUint8 *f,*s;
if(strncmp((char*)b,"HEAD",4)!=0) return 0;
b+=4;
indim=*(b++);
inprim=*(b++);
if(aitLocalNetworkDataFormatSame)
{
app[0]=*(b++); app[1]=*(b++);
init(inapp,(aitEnum)inprim,indim);
for(i=0;i<sizeof(status);i++) stat[i]=*(b++);
for(i=0;i<sizeof(time_stamp.tv_sec);i++) ts_sec[i]=*(b++);
for(i=0;i<sizeof(time_stamp.tv_nsec);i++) ts_nsec[i]=*(b++);
}
else
{
start=0;
dd=list->cData();
app[1]=*(b++); app[0]=*(b++);
init(inapp,(aitEnum)inprim,indim);
for(i=sizeof(status)-1;i>=0;i--) stat[i]=*(b++);
for(i=sizeof(time_stamp.tv_sec)-1;i>=0;i--) ts_sec[i]=*(b++);
for(i=sizeof(time_stamp.tv_nsec)-1;i>=0;i--) ts_nsec[i]=*(b++);
}
for(i=start;i<index;i++) dd=dd->next();
curr_index=index;
curr=dd;
return dd;
// read in the bounds info
f=(aitUint8*)&ff;
s=(aitUint8*)&ss;
for(j=0;j<dim;j++)
{
if(aitLocalNetworkDataFormatSame)
{
for(i=0;i<sizeof(aitIndex);i++) s[i]=*(b++);
for(i=0;i<sizeof(aitIndex);i++) f[i]=*(b++);
}
else
{
for(i=sizeof(aitIndex)-1;i>=0;i--) s[i]=*(b++);
for(i=sizeof(aitIndex)-1;i>=0;i--) f[i]=*(b++);
}
bounds[j].setFirst(ff);
bounds[j].setSize(ss);
}
return (size_t)(b-b1);
}
size_t gdd::inData(void* buf,aitUint32 tot, aitEnum e, aitDataFormat f)
{
size_t rc;
// Get data from a buffer and put it into this gdd. Lots of rules here.
// 1) tot is the total number of elements to copy from buf to this gdd.
// * if tot is zero, then use the element count described in the gdd.
// * if tot is not zero, then set the gdd up as a 1 dimensional array
// with tot elements in it.
// 2) e is the primitive data type of the incoming data.
// * if e is aitEnumInvalid, then use the gdd primitive type.
// * if e is valid and gdd primitive type is invalid, set the gdd
// primitive type to e.
// * if e is valid and so is this gdd primitive type, then convert the
// incoming data from type e to gdd primitive type.
// Bad error condition, don't do anything.
if(e==aitEnumInvalid && primitiveType()==aitEnumInvalid)
return 0;
aitIndex sz=tot;
aitEnum src_type=(e==aitEnumInvalid)?primitiveType():e;
aitEnum dest_type=(primitiveType()==aitEnumInvalid)?e:primitiveType();
// I'm not sure if this is the best way to do this.
if(sz>0)
reset(dest_type,dimension(),&sz);
if(genCopy(src_type,buf,f)==0)
rc=getDataSizeBytes();
else
rc=0;
return rc;
}
size_t gdd::in(void* buf, aitDataFormat f)
{
size_t index = inHeader(buf);
size_t rc;
if(index>0)
rc=inData(((char*)buf)+index,0,aitEnumInvalid,f)+index;
else
rc=0;
return rc;
}
#if 0
code section for handling transfer of element from
multidimensional space
// should handle single dimensional array as a special case
const Bounds* b = dd->getBounds();
const Bounds* bs = getBounds();
aitIndex x[dd->dimension()];
aitIndex offset,mult;
aitUint8* arr_dest=(aitUint8*)dataPointer();
aitUint8* arr_src=(aitUint8*)dd->dataPointer();
int d = dd->dimension();
int i,j;
for(i=0;i<d;i++) x[i]=b[i].first();
// look at this ugly mess - slow and horrible, but generic
// this is so unbelievably sucky, I hate it
j=0;
while(x[d-1]<b[d-1].size())
{
// modify coordinate here
for(offset=x[0],mult=1,i=1;i<d;i++)
{
mult*=bs[i];
offset+=x[i]*mult;
}
aitConvert(primitiveType(),
arr_dest[offset*aitSize[dd->primitiveType()],
dd->primitiveType(),arr_src[j],1);
if(++x[0]>=b[0].size())
{
for(i=0;i<(d-1);i++)
{
if(x[i]>=b[i].size())
{
++x[i+1];
x[i]=b[i].first();
}
}
}
j++;
}
#endif
src/gdd/gdd.h
+82 -1020
View File
File diff suppressed because it is too large Load Diff
src/gdd/gddArray.cc
+94
View File
@@ -0,0 +1,94 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
// Author: Jim Kowalkowski
// Date: 3/97
//
// $Id$
// $Log$
#include "gdd.h"
// ----------------------The gddAtomic functions-------------------------
gddAtomic::gddAtomic(int app, aitEnum prim, int dimen, ...):
gdd(app,prim,dimen)
{
va_list ap;
int i;
aitIndex val;
va_start(ap,dimen);
for(i=0;i<dimen;i++)
{
val=va_arg(ap,aitUint32);
bounds[i].set(0,val);
}
va_end(ap);
}
gddStatus gddAtomic::getBoundingBoxSize(aitUint32* b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) b[i]=bounds[i].size();
else
{
gddAutoPrint("gddAtomic::getBoundingBoxSize()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
gddStatus gddAtomic::setBoundingBoxSize(const aitUint32* const b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) bounds[i].setSize(b[i]);
else
{
gddAutoPrint("gddAtomic::setBoundingBoxSize()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
gddStatus gddAtomic::getBoundingBoxOrigin(aitUint32* b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) b[i]=bounds[i].first();
else
{
gddAutoPrint("gddAtomic::getBoundingBoxOrigin()",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
gddStatus gddAtomic::setBoundingBoxOrigin(const aitUint32* const b)
{
unsigned i;
gddStatus rc=0;
if(dimension()>0)
for(i=0;i<dimension();i++) bounds[i].setFirst(b[i]);
else
{
gddAutoPrint("gddAtomic::setBoundingBoxOrigin",gddErrorOutOfBounds);
rc=gddErrorOutOfBounds;
}
return rc;
}
src/gdd/gddArray.h
+52
View File
@@ -0,0 +1,52 @@
#ifndef GDD_ARRAY_H
#define GDD_ARRAY_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
* ***********************************************************************
* Adds ability to put array data into a DD, get it out, and adjust it
* ***********************************************************************
*/
#define gddAtomic gddArray
class gddArray : public gdd
{
public:
gddArray(void) { }
gddArray(gddArray* ad) : gdd(ad) { }
gddArray(int app) : gdd(app) { }
gddArray(int app, aitEnum prim) : gdd(app,prim) { }
gddArray(int app, aitEnum prim, int dimen, aitUint32* size_array):
gdd(app,prim,dimen,size_array) { }
gddArray(int app, aitEnum prim, int dimen, ...);
// view dimension size info as a bounding box instead of first/count
gddStatus getBoundingBoxSize(aitUint32* put_info_here);
gddStatus setBoundingBoxSize(const aitUint32* const get_info_from_here);
gddStatus getBoundingBoxOrigin(aitUint32* put_info_here);
gddStatus setBoundingBoxOrigin(const aitUint32* const get_info_from_here);
void dump(void);
void test(void);
gddArray& operator=(aitFloat64* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitFloat32* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitUint32* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitInt32* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitUint16* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitInt16* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitUint8* v) { *((gdd*)this)=v; return *this; }
gddArray& operator=(aitInt8* v) { *((gdd*)this)=v; return *this; }
protected:
~gddArray(void) { }
private:
};
#endif
src/gdd/gddContainer.cc
+146
View File
@@ -0,0 +1,146 @@
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
// Author: Jim Kowalkowski
// Date: 3/97
//
// $Id$
// $Log$
#include "gdd.h"
// --------------------The gddContainer functions---------------------
gddCursor gddContainer::getCursor(void) const
{
gddCursor ec(this);
return ec;
}
gddContainer::gddContainer(void):gdd(0,aitEnumContainer,1) { }
gddContainer::gddContainer(int app):gdd(app,aitEnumContainer,1) { }
gddContainer::gddContainer(int app,int tot) : gdd(app,aitEnumContainer,1)
{ cInit(tot); }
void gddContainer::cInit(int tot)
{
int i;
gdd* dd_list;
gdd* temp;
setBound(0,0,tot);
dd_list=NULL;
for(i=0;i<tot;i++)
{
temp=new gdd;
temp->noReferencing();
temp->setNext(dd_list);
dd_list=temp;
}
setData(dd_list);
}
gddContainer::gddContainer(gddContainer* ec)
{
unsigned i;
gdd* dd_list;
gdd* temp;
copy(ec);
dd_list=NULL;
// this needs to recursively add to the container, only copy the
// info and bounds information and scaler data, not arrays
for(i=0;i<dimension();i++)
{
temp=new gdd(getDD(i));
temp->noReferencing();
temp->setNext(dd_list);
dd_list=temp;
}
setData(dd_list);
}
gdd* gddContainer::getDD(aitIndex index)
{
if (index==0u) {
return this;
}
else if(index>getDataSizeElements())
return NULL;
else
{
aitIndex i;
gdd* dd=(gdd*)dataPointer();
for(i=1u;i<index;i++) {
dd=(gdd*)dd->next();
}
return dd;
}
}
gddStatus gddContainer::insert(gdd* dd)
{
dd->setNext(cData());
setData(dd);
bounds->setSize(bounds->size()+1);
return 0;
}
gddStatus gddContainer::remove(aitIndex index)
{
gddCursor cur = getCursor();
gdd *dd,*prev_dd;
aitIndex i;
prev_dd=NULL;
for(i=0; (dd=cur[i]) && i!=index; i++) prev_dd=dd;
if(i==index && dd)
{
if(prev_dd)
prev_dd->setNext(dd->next());
else
setData(dd->next());
dd->unreference();
bounds->setSize(bounds->size()-1);
return 0;
}
else
{
gddAutoPrint("gddContainer::remove()",gddErrorOutOfBounds);
return gddErrorOutOfBounds;
}
}
// ------------------------cursor functions-------------------------------
gdd* gddCursor::operator[](int index)
{
int i,start;
gdd* dd;
if(index>=curr_index)
{
start=curr_index;
dd=curr;
}
else
{
start=0;
dd=list->cData();
}
for(i=start;i<index;i++) dd=dd->next();
curr_index=index;
curr=dd;
return dd;
}
src/gdd/gddContainer.h
+93
View File
@@ -0,0 +1,93 @@
#ifndef GDD_CONTAINER_H
#define GDD_CONTAINER_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
*/
class gddCursor;
/* this class needs to be able to register a destructor for the container */
class gddContainer : public gdd
{
public:
gddContainer(void);
gddContainer(int app);
gddContainer(gddContainer* ac);
gddContainer(int app,int number_of_things_in_it);
gddStatus insert(gdd*);
gddStatus remove(aitIndex index);
int total(void);
void dump(void);
void test(void);
// The following are slow and inefficient
gdd* getDD(aitIndex index);
gdd* getDD(aitIndex index,gddScalar*&);
gdd* getDD(aitIndex index,gddAtomic*&);
gdd* getDD(aitIndex index,gddContainer*&);
gdd* operator[](aitIndex index);
// preferred method for looking into a container
gddCursor getCursor(void) const;
gdd* cData(void) const;
protected:
gddContainer(int,int,int,int*) { }
~gddContainer(void) { }
void cInit(int num_things_within);
gddStatus changeType(int,aitEnum) {
gddAutoPrint("gddContainer::changeType()",gddErrorNotAllowed);
return gddErrorNotAllowed; }
gddStatus setBound(int,aitIndex,aitIndex) {
gddAutoPrint("setBound()",gddErrorNotAllowed);
return gddErrorNotAllowed; }
gddStatus getBound(int,aitIndex&,aitIndex&) {
gddAutoPrint("getBound()",gddErrorNotAllowed);
return gddErrorNotAllowed; }
gddStatus setBound(aitIndex,aitIndex);
private:
friend class gddCursor;
};
class gddCursor
{
public:
gddCursor(void);
gddCursor(const gddContainer* ec);
gdd* first(void);
gdd* first(gddScalar*&);
gdd* first(gddAtomic*&);
gdd* first(gddContainer*&);
gdd* next(void);
gdd* next(gddScalar*&);
gdd* next(gddAtomic*&);
gdd* next(gddContainer*&);
gdd* current(void);
gdd* current(gddScalar*&);
gdd* current(gddAtomic*&);
gdd* current(gddContainer*&);
gdd* operator[](int index);
private:
const gddContainer* list;
gdd* curr;
int curr_index;
};
#include "gddContainerI.h"
#endif
src/gdd/gddContainerI.h
+60
View File
@@ -0,0 +1,60 @@
#ifndef GDD_CONTAINERI_H
#define GDD_CONTAINERI_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
*/
inline gdd* gddContainer::cData(void) const
{ return (gdd*)dataPointer(); }
inline int gddContainer::total(void)
{ return bounds->size(); }
inline gdd* gddContainer::operator[](aitIndex index)
{ return getDD(index); }
inline gdd* gddContainer::getDD(aitIndex index,gddScalar*& dd)
{ return (gdd*)(dd=(gddScalar*)getDD(index)); }
inline gdd* gddContainer::getDD(aitIndex index,gddAtomic*& dd)
{ return (gdd*)(dd=(gddAtomic*)getDD(index)); }
inline gdd* gddContainer::getDD(aitIndex index,gddContainer*& dd)
{ return (gdd*)(dd=(gddContainer*)getDD(index)); }
inline gddStatus gddContainer::setBound(aitIndex f, aitIndex c)
{ bounds->set(f,c); return 0; }
inline gddCursor::gddCursor(void):list(NULL)
{ curr=NULL; }
inline gddCursor::gddCursor(const gddContainer* ec):list(ec)
{ curr=ec->cData(); curr_index=0; }
inline gdd* gddCursor::first(void)
{ curr=list->cData(); curr_index=0; return curr; }
inline gdd* gddCursor::first(gddScalar*& dd)
{ return (gdd*)(dd=(gddScalar*)first()); }
inline gdd* gddCursor::first(gddAtomic*& dd)
{ return (gdd*)(dd=(gddAtomic*)first()); }
inline gdd* gddCursor::first(gddContainer*& dd)
{ return (gdd*)(dd=(gddContainer*)first()); }
inline gdd* gddCursor::next(void)
{ if(curr) { curr_index++;curr=curr->next(); } return curr; }
inline gdd* gddCursor::next(gddScalar*& dd)
{ return (gdd*)(dd=(gddScalar*)next()); }
inline gdd* gddCursor::next(gddAtomic*& dd)
{ return (gdd*)(dd=(gddAtomic*)next()); }
inline gdd* gddCursor::next(gddContainer*& dd)
{ return (gdd*)(dd=(gddContainer*)next()); }
inline gdd* gddCursor::current(void)
{ return curr; }
inline gdd* gddCursor::current(gddScalar*& dd)
{ return (gdd*)(dd=(gddScalar*)current()); }
inline gdd* gddCursor::current(gddAtomic*& dd)
{ return (gdd*)(dd=(gddAtomic*)current()); }
inline gdd* gddCursor::current(gddContainer*& dd)
{ return (gdd*)(dd=(gddContainer*)current()); }
#endif
src/gdd/gddErrorCodes.cc
+24
View File
@@ -0,0 +1,24 @@
// Author: Jim Kowalkowski
// Date: 3/97
//
// $Id$
// $Log$
// -------------------------- Error messages -------------------------
char* gddErrorMessages[]=
{
"Invalid",
"TypeMismatch",
"NotAllowed",
"AlreadyDefined",
"NewFailed",
"OutOfBounds",
"AtLimit",
"NotDefined",
"NotSupported",
"Overflow",
"Underflow"
};
src/gdd/gddI.h
+611
View File
@@ -0,0 +1,611 @@
#ifndef GDDI_H
#define GDDI_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
*
* $Log$
*/
inline void gdd::setData(void* d) { data.Pointer=d; }
inline gddDestructor* gdd::destructor(void) const { return destruct; }
inline gdd::gdd(void) { init(0,aitEnumInvalid,0); }
inline gdd::gdd(int app) { init(app,aitEnumInvalid,0); }
inline gdd::gdd(int app,aitEnum prim) { init(app,prim,0); }
inline unsigned gdd::applicationType(void) const{ return appl_type; }
inline aitEnum gdd::primitiveType(void) const { return (aitEnum)prim_type; }
inline const gddBounds* gdd::getBounds(void) const { return bounds; }
inline const gddBounds* gdd::getBounds(int bn) const { return &bounds[bn]; }
inline gdd* gdd::next(void) { return nextgdd; }
inline void gdd::setNext(gdd* n) { nextgdd=n; }
inline unsigned gdd::dimension(void) const { return dim; }
inline aitType& gdd::getData(void) { return data; }
inline aitType* gdd::dataUnion(void) { return &data; }
inline void gdd::setPrimType(aitEnum t) { prim_type=(aitUint8)t; }
inline void gdd::setApplType(int t) { appl_type=(aitUint16)t; }
inline gddStatus gdd::copyInfo(gdd* dd) { return copyStuff(dd,0); }
inline gddStatus gdd::copy(gdd* dd) { return copyStuff(dd,1); }
inline gddStatus gdd::Dup(gdd* dd) { return copyStuff(dd,2); }
inline void* gdd::dataAddress(void) const { return (void*)&data; }
inline void* gdd::dataPointer(void) const { return data.Pointer; }
inline void* gdd::dataVoid(void) const
{
return (dimension()||primitiveType()==aitEnumFixedString)?
dataPointer():dataAddress();
}
inline aitUint32 gdd::align8(unsigned long count) const
{
unsigned long tmp=count&(~((unsigned long)0x07));
return (tmp!=count)?tmp+8:tmp;
}
inline void* gdd::dataPointer(aitIndex f) const
{ return (void*)(((aitUint8*)dataPointer())+aitSize[primitiveType()]*f); }
inline int gdd::isManaged(void) const { return flags&GDD_MANAGED_MASK; }
inline int gdd::isFlat(void) const { return flags&GDD_FLAT_MASK; }
inline int gdd::isNoRef(void) const { return flags&GDD_NOREF_MASK; }
inline int gdd::isConstant(void) const { return flags&GDD_CONSTANT_MASK; }
inline int gdd::isLocalDataFormat(void) const { return !(flags&GDD_NET_MASK); }
inline int gdd::isNetworkDataFormat(void) const
{ return !isLocalDataFormat() || aitLocalNetworkDataFormatSame; }
inline void gdd::markConstant(void) { flags|=GDD_CONSTANT_MASK; }
inline void gdd::markFlat(void) { flags|=GDD_FLAT_MASK; }
inline void gdd::markManaged(void) { flags|=GDD_MANAGED_MASK; }
inline void gdd::markUnmanaged(void) { flags&=~GDD_MANAGED_MASK; }
inline void gdd::markLocalDataFormat(void) { flags&=~GDD_NET_MASK; }
inline void gdd::markNotLocalDataFormat(void) { flags|=GDD_NET_MASK; }
inline void gdd::getTimeStamp(struct timespec* const ts) const
{ ts->tv_sec=time_stamp.tv_sec; ts->tv_nsec=time_stamp.tv_nsec; }
inline void gdd::setTimeStamp(const struct timespec* const ts) {
time_stamp.tv_sec=(aitUint32)ts->tv_sec;
time_stamp.tv_nsec=(aitUint32)ts->tv_nsec; }
inline void gdd::getTimeStamp(aitTimeStamp* const ts) const { *ts=time_stamp; }
inline void gdd::setTimeStamp(const aitTimeStamp* const ts) { time_stamp=*ts; }
inline void gdd::setStatus(aitUint32 s) { status=s; }
inline void gdd::getStatus(aitUint32& s) { s=status; }
inline void gdd::setStatus(aitUint16 high, aitUint16 low)
{ status=(((aitUint32)high)<<16)|low; }
inline void gdd::getStatus(aitUint16& high, aitUint16& low)
{ high=(aitUint16)(status>>16); low=(aitUint16)(status&0x0000ffff); }
inline void gdd::setStat(aitUint16 s)
{ aitUint16* x = (aitUint16*)&status; x[0]=s; }
inline void gdd::setSevr(aitUint16 s)
{ aitUint16* x = (aitUint16*)&status; x[1]=s; }
inline aitUint16 gdd::getStat(void) const
{ aitUint16* x = (aitUint16*)&status; return x[0]; }
inline aitUint16 gdd::getSevr(void) const
{ aitUint16* x = (aitUint16*)&status; return x[1]; }
inline void gdd::getStatSevr(aitInt16& st, aitInt16& se)
{ st=getStat(); se=getSevr(); }
inline void gdd::setStatSevr(aitInt16 st, aitInt16 se)
{ setStat(st); setSevr(se); }
inline gdd& gdd::operator=(const gdd& v)
{ memcpy(this,&v,sizeof(gdd)); return *this; }
inline int gdd::isScalar(void) const { return dimension()==0?1:0; }
inline int gdd::isContainer(void) const
{ return (primitiveType()==aitEnumContainer)?1:0; }
inline int gdd::isAtomic(void) const
{ return (dimension()>0&&primitiveType()!=aitEnumContainer)?1:0; }
inline gddStatus gdd::noReferencing(void)
{
int rc=0;
if(ref_cnt>1)
{
gddAutoPrint("gdd::noReferencing()",gddErrorNotAllowed);
rc=gddErrorNotAllowed;
}
else flags|=GDD_NOREF_MASK;
return rc;
}
inline gddStatus gdd::reference(void)
{
int rc=0;
if(isNoRef())
{
gddAutoPrint("gdd::reference()",gddErrorNotAllowed);
rc=gddErrorNotAllowed;
}
else ref_cnt++;
if(ref_cnt>((1u<<(sizeof(ref_cnt)*CHAR_BIT))-2u))
{
fprintf(stderr,"gdd reference count overflow!!\n");
gddAutoPrint("gdd::reference()",gddErrorOverflow);
rc=gddErrorOverflow;
}
return rc;
}
inline gddStatus gdd::unreference(void)
{
int rc=0;
if(ref_cnt==0u)
{
fprintf(stderr,"gdd reference count underflow!!\n");
gddAutoPrint("gdd::unreference()",gddErrorUnderflow);
rc=gddErrorUnderflow;
}
else if(--ref_cnt<=0u)
{
if(isManaged())
{
// managed dd always destroys the entire thing
ref_cnt=1;
if(destruct) destruct->destroy(this);
destruct=NULL;
}
else if(!isFlat())
delete this;
}
return rc;
}
inline void gdd::destroyData(void)
{
if(destruct)
{
if(isContainer())
destruct->destroy(this);
else
destruct->destroy(dataPointer());
freeBounds(); // must be done here
destruct=NULL;
setData(NULL);
}
else
{
if(primitiveType()==aitEnumString && isScalar())
{
aitString* str = (aitString*)dataAddress();
str->clear();
}
}
}
inline void gdd::adjust(gddDestructor* d, void* v, aitEnum type,aitDataFormat)
{
if(destruct) destruct->destroy(dataPointer());
destruct=d;
if(destruct) destruct->reference();
setPrimType(type);
setData(v);
}
// These function do NOT work well for aitFixedString because
// fixed strings are always stored by reference. You WILL get
// into trouble is the gdd does not contain a fixed string
// before you putConvert() something into it.
#if aitLocalNetworkDataFormatSame == AIT_FALSE
inline void gdd::get(aitEnum t,void* v,aitDataFormat f)
#else
inline void gdd::get(aitEnum t,void* v,aitDataFormat)
#endif
{
if(primitiveType()==aitEnumFixedString)
{
if(dataPointer()) aitConvert(t,v,primitiveType(),dataPointer(),1);
}
else
{
#if aitLocalNetworkDataFormatSame == AIT_FALSE
if(f!=aitLocalDataFormat)
aitConvertToNet(t,v,primitiveType(),dataAddress(),1);
else
#endif
aitConvert(t,v,primitiveType(),dataAddress(),1);
}
}
#if aitLocalNetworkDataFormatSame == AIT_FALSE
inline void gdd::set(aitEnum t,const void* v,aitDataFormat f)
#else
inline void gdd::set(aitEnum t,const void* v,aitDataFormat)
#endif
{
if(primitiveType()==aitEnumFixedString)
{
if(dataPointer()==NULL)
data.FString=new aitFixedString;
aitConvert(primitiveType(),dataPointer(),t,v,1);
}
else
{
#if aitLocalNetworkDataFormatSame == AIT_FALSE
if(f!=aitLocalDataFormat)
aitConvertFromNet(primitiveType(),dataAddress(),t,v,1);
else
#endif
aitConvert(primitiveType(),dataAddress(),t,v,1);
markLocalDataFormat();
}
}
// -------------------getRef(data pointer) functions----------------
inline void gdd::getRef(aitFloat64*& d) { d=(aitFloat64*)dataVoid(); }
inline void gdd::getRef(aitFloat32*& d) { d=(aitFloat32*)dataVoid(); }
inline void gdd::getRef(aitUint32*& d) { d=(aitUint32*)dataVoid(); }
inline void gdd::getRef(aitInt32*& d) { d=(aitInt32*)dataVoid(); }
inline void gdd::getRef(aitUint16*& d) { d=(aitUint16*)dataVoid(); }
inline void gdd::getRef(aitInt16*& d) { d=(aitInt16*)dataVoid(); }
inline void gdd::getRef(aitUint8*& d) { d=(aitUint8*)dataVoid(); }
inline void gdd::getRef(aitInt8*& d) { d=(aitInt8*)dataVoid(); }
inline void gdd::getRef(void*& d) { d=dataVoid(); }
inline void gdd::getRef(aitFixedString*& d) { d=(aitFixedString*)dataVoid(); }
inline void gdd::getRef(aitString*& d) { d=(aitString*)dataVoid(); }
// -------------------putRef(data pointer) functions----------------
inline void gdd::putRef(void* v,aitEnum code, gddDestructor* d)
{ adjust(d, v, code); }
inline void gdd::putRef(aitFloat64* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFloat64); }
inline void gdd::putRef(aitFloat32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFloat32); }
inline void gdd::putRef(aitUint8* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint8); }
inline void gdd::putRef(aitInt8* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt8); }
inline void gdd::putRef(aitUint16* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint16); }
inline void gdd::putRef(aitInt16* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt16); }
inline void gdd::putRef(aitUint32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint32); }
inline void gdd::putRef(aitInt32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt32); }
inline void gdd::putRef(aitString* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumString); }
inline void gdd::putRef(aitFixedString* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFixedString); }
// -------------------putRef(const data pointer) functions----------------
inline void gdd::putRef(const aitFloat64* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFloat64); markConstant(); }
inline void gdd::putRef(const aitFloat32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFloat32); markConstant(); }
inline void gdd::putRef(const aitUint8* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint8); markConstant(); }
inline void gdd::putRef(const aitInt8* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt8); markConstant(); }
inline void gdd::putRef(const aitUint16* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint16); markConstant(); }
inline void gdd::putRef(const aitInt16* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt16); markConstant(); }
inline void gdd::putRef(const aitUint32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumUint32); markConstant(); }
inline void gdd::putRef(const aitInt32* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumInt32); markConstant(); }
inline void gdd::putRef(const aitString* v, gddDestructor* d)
{ adjust(d, (void*)v, aitEnumString); markConstant(); }
inline void gdd::putRef(const aitFixedString* v,gddDestructor* d)
{ adjust(d, (void*)v, aitEnumFixedString); markConstant(); }
// -------------------getConvert(scalar) functions ----------------------
inline void gdd::getConvert(aitFloat64& d) { get(aitEnumFloat64,&d); }
inline void gdd::getConvert(aitFloat32& d) { get(aitEnumFloat32,&d); }
inline void gdd::getConvert(aitUint32& d) { get(aitEnumUint32,&d); }
inline void gdd::getConvert(aitInt32& d) { get(aitEnumInt32,&d); }
inline void gdd::getConvert(aitUint16& d) { get(aitEnumUint16,&d); }
inline void gdd::getConvert(aitInt16& d) { get(aitEnumInt16,&d); }
inline void gdd::getConvert(aitUint8& d) { get(aitEnumUint8,&d); }
inline void gdd::getConvert(aitInt8& d) { get(aitEnumInt8,&d); }
// -------------------putConvert(scalar) functions ----------------------
inline void gdd::putConvert(aitFloat64 d){ set(aitEnumFloat64,&d); }
inline void gdd::putConvert(aitFloat32 d){ set(aitEnumFloat32,&d); }
inline void gdd::putConvert(aitUint32 d) { set(aitEnumUint32,&d); }
inline void gdd::putConvert(aitInt32 d) { set(aitEnumInt32,&d); }
inline void gdd::putConvert(aitUint16 d) { set(aitEnumUint16,&d); }
inline void gdd::putConvert(aitInt16 d) { set(aitEnumInt16,&d); }
inline void gdd::putConvert(aitUint8 d) { set(aitEnumUint8,&d); }
inline void gdd::putConvert(aitInt8 d) { set(aitEnumInt8,&d); }
// ------------------------put(pointer) functions----------------------
inline gddStatus gdd::put(const aitFloat64* const d)
{ return genCopy(aitEnumFloat64,d); }
inline gddStatus gdd::put(const aitFloat32* const d)
{ return genCopy(aitEnumFloat32,d); }
inline gddStatus gdd::put(const aitUint32* const d)
{ return genCopy(aitEnumUint32,d); }
inline gddStatus gdd::put(const aitInt32* const d)
{ return genCopy(aitEnumInt32,d); }
inline gddStatus gdd::put(const aitUint16* const d)
{ return genCopy(aitEnumUint16,d); }
inline gddStatus gdd::put(const aitInt16* const d)
{ return genCopy(aitEnumInt16,d); }
inline gddStatus gdd::put(const aitUint8* const d)
{ return genCopy(aitEnumUint8,d); }
// special case for aitInt8 array to aitString scalar
inline gddStatus gdd::put(const aitInt8* const d)
{
gddStatus rc=0;
if(primitiveType()==aitEnumString && dim==0)
{
aitString* p = (aitString*)dataAddress();
p->installString((char*)d);
}
else if(primitiveType()==aitEnumFixedString && dim==0) {
strncpy(data.FString->fixed_string,(char*)d,
sizeof(aitFixedString));
data.FString->fixed_string[sizeof(aitFixedString)-1u]='\0';
}
else
rc=genCopy(aitEnumInt8,d);
return rc;
}
// ----------------put(scalar) functions----------------
inline gddStatus gdd::put(aitFloat64 d) {
gddStatus rc=0;
if(isScalar()) { data.Float64=d; setPrimType(aitEnumFloat64); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitFloat32 d) {
gddStatus rc=0;
if(isScalar()) { data.Float32=d;setPrimType(aitEnumFloat32); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitUint32 d) {
gddStatus rc=0;
if(isScalar()) { data.Uint32=d; setPrimType(aitEnumUint32); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitInt32 d) {
gddStatus rc=0;
if(isScalar()) { data.Int32=d; setPrimType(aitEnumInt32); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitUint16 d) {
gddStatus rc=0;
if(isScalar()) { data.Uint16=d; setPrimType(aitEnumUint16); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitInt16 d) {
gddStatus rc=0;
if(isScalar()) { data.Int16=d; setPrimType(aitEnumInt16); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitUint8 d) {
gddStatus rc=0;
if(isScalar()) { data.Uint8=d; setPrimType(aitEnumUint8); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitInt8 d) {
gddStatus rc=0;
if(isScalar()) { data.Int8=d; setPrimType(aitEnumInt8); }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
inline gddStatus gdd::put(aitType* d) {
gddStatus rc=0;
if(isScalar()) { data=*d; }
else { rc=gddErrorNotAllowed; gddAutoPrint("gdd:put()",rc); }
return rc;
}
// ---------------------get(pointer) functions--------------------------
inline void gdd::get(void* d) {
if(isScalar())
aitConvert(primitiveType(),d,primitiveType(),dataAddress(),1);
else
aitConvert(primitiveType(),d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(void* d,aitEnum e) {
if(isScalar())
aitConvert(e,d,primitiveType(),dataAddress(),1);
else
aitConvert(e,d,primitiveType(),dataPointer(),getDataSizeElements());
}
inline void gdd::get(aitFloat64* d)
{
if(isScalar())
aitConvert(aitEnumFloat64,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumFloat64,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitFloat32* d) {
if(isScalar())
aitConvert(aitEnumFloat32,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumFloat32,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitUint32* d) {
if(isScalar())
aitConvert(aitEnumUint32,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumUint32,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitInt32* d) {
if(isScalar())
aitConvert(aitEnumInt32,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumInt32,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitUint16* d) {
if(isScalar())
aitConvert(aitEnumUint16,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumUint16,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitInt16* d) {
if(isScalar())
aitConvert(aitEnumInt16,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumInt16,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitUint8* d) {
if(isScalar())
aitConvert(aitEnumUint8,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumUint8,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitString* d) {
if(isScalar())
aitConvert(aitEnumString,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumString,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
inline void gdd::get(aitFixedString* d) {
if(isScalar())
aitConvert(aitEnumFixedString,d,primitiveType(),dataAddress(),1);
else
aitConvert(aitEnumFixedString,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
// special case for string scalar to aitInt8 array!
inline void gdd::get(aitInt8* d)
{
if(primitiveType()==aitEnumString && dim==0)
{
aitString* str = (aitString*)dataAddress();
strcpy((char*)d,str->string());
}
else if(primitiveType()==aitEnumFixedString && dim==0)
strcpy((char*)d,data.FString->fixed_string);
else
aitConvert(aitEnumInt8,d,primitiveType(),dataPointer(),
getDataSizeElements());
}
// ------------------get(scalar) functions-----------------
inline void gdd::get(aitFloat64& d) {
if(primitiveType()==aitEnumFloat64) d=getData().Float64;
else get(aitEnumFloat64,&d);
}
inline void gdd::get(aitFloat32& d) {
if(primitiveType()==aitEnumFloat32) d=getData().Float32;
else get(aitEnumFloat32,&d);
}
inline void gdd::get(aitUint32& d) {
if(primitiveType()==aitEnumUint32) d=getData().Uint32;
else get(aitEnumUint32,&d);
}
inline void gdd::get(aitInt32& d) {
if(primitiveType()==aitEnumInt32) d=getData().Int32;
else get(aitEnumInt32,&d);
}
inline void gdd::get(aitUint16& d) {
if(primitiveType()==aitEnumUint16) d=getData().Uint16;
else get(aitEnumUint16,&d);
}
inline void gdd::get(aitInt16& d) {
if(primitiveType()==aitEnumInt16) d=getData().Int16;
else get(aitEnumInt16,&d);
}
inline void gdd::get(aitUint8& d) {
if(primitiveType()==aitEnumUint8) d=getData().Uint8;
else get(aitEnumUint8,&d);
}
inline void gdd::get(aitInt8& d) {
if(primitiveType()==aitEnumInt8) d=getData().Int8;
else get(aitEnumInt8,&d);
}
inline void gdd::get(aitType& d) { d=data; }
// ---------- gdd x = primitive data type pointer functions----------
inline gdd& gdd::operator=(aitFloat64* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitFloat32* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitUint32* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitInt32* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitUint16* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitInt16* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitUint8* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitInt8* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitString* v) { putRef(v); return *this;}
inline gdd& gdd::operator=(aitFixedString* v){ putRef(v); return *this;}
// ----------------- gdd x = primitive data type functions----------------
inline gdd& gdd::operator=(aitFloat64 d)
{ data.Float64=d; setPrimType(aitEnumFloat64); return *this; }
inline gdd& gdd::operator=(aitFloat32 d)
{ data.Float32=d;setPrimType(aitEnumFloat32); return *this; }
inline gdd& gdd::operator=(aitUint32 d)
{ data.Uint32=d; setPrimType(aitEnumUint32); return *this; }
inline gdd& gdd::operator=(aitInt32 d)
{ data.Int32=d; setPrimType(aitEnumInt32); return *this; }
inline gdd& gdd::operator=(aitUint16 d)
{ data.Uint16=d; setPrimType(aitEnumUint16); return *this; }
inline gdd& gdd::operator=(aitInt16 d)
{ data.Int16=d; setPrimType(aitEnumInt16); return *this; }
inline gdd& gdd::operator=(aitUint8 d)
{ data.Uint8=d; setPrimType(aitEnumUint8); return *this; }
inline gdd& gdd::operator=(aitInt8 d)
{ data.Int8=d; setPrimType(aitEnumInt8); return *this; }
inline gdd& gdd::operator=(aitString& d)
{ put(d); return *this; }
inline gdd& gdd::operator=(const aitString& d)
{ put(d); return *this; }
// ------------- primitive type pointer = gdd x functions --------------
inline gdd::operator aitFloat64*(void) const
{ return (aitFloat64*)dataPointer(); }
inline gdd::operator aitFloat32*(void) const
{ return (aitFloat32*)dataPointer(); }
inline gdd::operator aitUint32*(void) const
{ return (aitUint32*)dataPointer(); }
inline gdd::operator aitInt32*(void) const
{ return (aitInt32*)dataPointer(); }
inline gdd::operator aitUint16*(void) const
{ return (aitUint16*)dataPointer(); }
inline gdd::operator aitInt16*(void) const
{ return (aitInt16*)dataPointer(); }
inline gdd::operator aitUint8*(void) const
{ return (aitUint8*)dataPointer(); }
inline gdd::operator aitInt8*(void) const
{ return (aitInt8*)dataPointer(); }
inline gdd::operator aitString*(void) const
{ return (aitString*)dataPointer(); }
inline gdd::operator aitFixedString*(void) const
{ return (aitFixedString*)dataPointer(); }
// ------------- primitive type = gdd x functions --------------
inline gdd::operator aitFloat64(void) { aitFloat64 d; get(d); return d; }
inline gdd::operator aitFloat32(void) { aitFloat32 d; get(d); return d; }
inline gdd::operator aitUint32(void) { aitUint32 d; get(d); return d; }
inline gdd::operator aitInt32(void) { aitInt32 d; get(d); return d; }
inline gdd::operator aitUint16(void) { aitUint16 d; get(d); return d; }
inline gdd::operator aitInt16(void) { aitInt16 d; get(d); return d; }
inline gdd::operator aitUint8(void) { aitUint8 d; get(d); return d; }
inline gdd::operator aitInt8(void) { aitInt8 d; get(d); return d; }
inline gdd::operator aitString(void) { aitString d; get(d); return d; }
#endif
src/gdd/gddNewDel.h
+51 -45
View File
@@ -8,6 +8,9 @@
* $Id$
*
* $Log$
* Revision 1.1 1996/06/25 19:11:47 jbk
* new in EPICS base
*
*
* *Revision 1.2 1996/06/24 03:15:37 jbk
* *name changes and fixes for aitString and fixed string functions
@@ -19,7 +22,7 @@
// this file if formatted with tab stop = 4
#include <stdlib.h>
#include "gddUtils.h"
#include "gddSemaphore.h"
// Avoid using templates at the cost of very poor readability.
// This forces the user to have a static data member named "gddNewDel_freelist"
@@ -45,61 +48,64 @@
#define gdd_CHUNK(mine) (gdd_CHUNK_NUM*sizeof(mine))
// private data to add to a class
#define gdd_NEWDEL_DATA(clas) \
clas* newdel_next; \
static clas* newdel_freelist; \
static gddSemaphore lock;
#define gdd_NEWDEL_DATA \
static char* newdel_freelist; \
static gddSemaphore newdel_lock;
// public interface for the new/delete stuff
#define gdd_NEWDEL_FUNC(clas) void* operator new(size_t); \
void operator delete(void*); \
clas* next(void) { return newdel_next; } \
void setNext(clas* n) { newdel_next=n; }
#define gdd_NEWDEL_FUNC(fld) \
void* operator new(size_t); \
void operator delete(void*); \
char* newdel_next(void) { return (char*)fld; } \
void newdel_setNext(char* n) { char** x=(char**)&fld; *x=n; }
// declaration of the static variable for the free list
#define gdd_NEWDEL_STAT(clas) \
clas* clas::newdel_freelist=NULL; \
gddSemaphore clas::lock;
char* clas::newdel_freelist=NULL; \
gddSemaphore clas::newdel_lock;
// code for the delete function
#define gdd_NEWDEL_DEL(clas) void clas::operator delete(void* v) { \
clas* dn = (clas*)v; \
if(dn->newdel_next==(clas*)(-1)) free((char*)v); \
else { \
clas::lock.take(); \
dn->newdel_next=clas::newdel_freelist; clas::newdel_freelist=dn; \
clas::lock.give(); \
} \
}
#define gdd_NEWDEL_DEL(clas) \
void clas::operator delete(void* v) { \
clas* dn = (clas*)v; \
if(dn->newdel_next()==(char*)(-1)) free((char*)v); \
else { \
clas::newdel_lock.take(); \
dn->newdel_setNext(clas::newdel_freelist); \
clas::newdel_freelist=(char*)dn; \
clas::newdel_lock.give(); \
} \
}
// following function assumes that reading/writing address is atomic
// code for the new function
#define gdd_NEWDEL_NEW(clas) void* clas::operator new(size_t size) { \
int tot; \
clas *nn,*dn; \
if(!clas::newdel_freelist) { \
tot=gdd_CHUNK_NUM; \
nn=(clas*)malloc(gdd_CHUNK(clas)); \
gddCleanUp::Add(nn); \
for(dn=nn;--tot;dn++) dn->newdel_next=dn+1; \
clas::lock.take(); \
(dn)->newdel_next=clas::newdel_freelist; \
clas::newdel_freelist=nn; \
clas::lock.give(); \
} \
if(size==sizeof(clas)) { \
clas::lock.take(); \
dn=clas::newdel_freelist; \
clas::newdel_freelist=clas::newdel_freelist->newdel_next; \
clas::lock.give(); \
dn->newdel_next=NULL; \
} else { \
dn=(clas*)malloc(size); \
dn->newdel_next=(clas*)(-1); \
} \
return (void*)dn; \
}
#define gdd_NEWDEL_NEW(clas) \
void* clas::operator new(size_t size) { \
int tot; \
clas *nn,*dn; \
if(!clas::newdel_freelist) { \
tot=gdd_CHUNK_NUM; \
nn=(clas*)malloc(gdd_CHUNK(clas)); \
gddCleanUp::Add(nn); \
for(dn=nn;--tot;dn++) dn->newdel_setNext((char*)(dn+1)); \
clas::newdel_lock.take(); \
(dn)->newdel_setNext(clas::newdel_freelist); \
clas::newdel_freelist=(char*)nn; \
clas::newdel_lock.give(); \
} \
if(size==sizeof(clas)) { \
clas::newdel_lock.take(); \
dn=(clas*)clas::newdel_freelist; \
clas::newdel_freelist=((clas*)clas::newdel_freelist)->newdel_next(); \
clas::newdel_lock.give(); \
dn->newdel_setNext(NULL); \
} else { \
dn=(clas*)malloc(size); \
dn->newdel_setNext((char*)(-1)); \
} \
return (void*)dn; \
}
class gddCleanUpNode
{
src/gdd/gddScalar.h
+45
View File
@@ -0,0 +1,45 @@
#ifndef GDD_SCALAR_H
#define GDD_SCALAR_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
*/
// ------------------------------------------------------------------------
// Add handling of the special case where the data is a scaler - the
// dimension is zero
class gddScalar : public gdd
{
public:
gddScalar(void) { }
gddScalar(gddScalar* ad) : gdd(ad) { }
gddScalar(int app) : gdd(app) { }
gddScalar(int app,aitEnum prim) : gdd(app,prim) { }
void dump(void);
void test(void);
gddScalar& operator=(aitFloat64 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitFloat32 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitUint32 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitInt32 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitUint16 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitInt16 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitUint8 d) { *((gdd*)this)=d; return *this; }
gddScalar& operator=(aitInt8 d) { *((gdd*)this)=d; return *this; }
protected:
gddScalar(int app, aitEnum prim, int dimen, aitUint32* size_array):
gdd(app,prim,dimen,size_array) { }
~gddScalar(void) { }
private:
};
#endif
src/gdd/gddSemaphore.h
+79
View File
@@ -0,0 +1,79 @@
#ifndef GDD_SEMAPHORE
#define GDD_SEMAPHORE
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
*/
#include "aitTypes.h"
// ------------------------- semaphores ---------------------------
typedef enum { gddSemEmpty, gddSemFull } gddSemType;
#if 0
#ifdef vxWorks
#undef vxWorks
#define __temp_vxWorks__ 1
#endif
#endif
// Semaphores default to "Full"
class gddSemaphore
{
public:
gddSemaphore(void);
gddSemaphore(gddSemType);
~gddSemaphore(void);
void give(void);
void take(void);
void take(aitUint32 usec);
private:
#ifdef vxWorks
SEM_ID sem;
#endif
};
#ifdef vxWorks
inline gddSemaphore::gddSemaphore(void)
{ sem=semBCreate(SEM_Q_PRIORITY,SEM_FULL); }
inline gddSemaphore::gddSemaphore(gddSemType s)
{
if(s==gddSemEmpty) sem=semBCreate(SEM_Q_PRIORITY,SEM_EMPTY);
else sem=semBCreate(SEM_Q_PRIORITY,SEM_FULL);
}
inline gddSemaphore::~gddSemaphore(void) { semDelete(sem); }
inline void gddSemaphore::give(void) { semGive(sem); }
inline void gddSemaphore::take(void) { semTake(sem,WAIT_FOREVER); }
inline void gddSemaphore::take(aitUint32 usec)
{ semTake(sem,usec/(sysClkRateGet()*1000000)); }
#else
inline gddSemaphore::gddSemaphore(void) { }
inline gddSemaphore::gddSemaphore(gddSemType) { }
inline gddSemaphore::~gddSemaphore(void) { }
inline void gddSemaphore::give(void) { }
inline void gddSemaphore::take(void) { }
inline void gddSemaphore::take(aitUint32) { }
#endif
#if 0
class gddIntLock
{
public:
private:
};
#endif
#ifdef __temp_vxWorks__
#define vxWorks 1
#undef __temp_vxWorks__
#endif
#endif
src/gdd/gddUtils.cc
+52
View File
@@ -0,0 +1,52 @@
// Author: Jim Kowalkowski
// Date: 3/97
//
// $Id$
// $Log$
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "gddNewDel.h"
#include "gddUtils.h"
gdd_NEWDEL_NEW(gddBounds1D)
gdd_NEWDEL_DEL(gddBounds1D)
gdd_NEWDEL_STAT(gddBounds1D)
gdd_NEWDEL_NEW(gddBounds2D)
gdd_NEWDEL_DEL(gddBounds2D)
gdd_NEWDEL_STAT(gddBounds2D)
gdd_NEWDEL_NEW(gddBounds3D)
gdd_NEWDEL_DEL(gddBounds3D)
gdd_NEWDEL_STAT(gddBounds3D)
gdd_NEWDEL_NEW(gddDestructor)
gdd_NEWDEL_DEL(gddDestructor)
gdd_NEWDEL_STAT(gddDestructor)
// --------------------------The gddBounds functions-------------------
// gddBounds::gddBounds(void) { first=0; count=0; }
// --------------------------The gddDestructor functions-------------------
gddStatus gddDestructor::destroy(void* thing)
{
if(ref_cnt==0 || --ref_cnt==0)
{
run(thing);
delete this;
}
return 0;
}
void gddDestructor::run(void* thing)
{
aitInt8* pd = (aitInt8*)thing;
delete [] pd;
}
src/gdd/gddUtils.h
+106 -48
View File
@@ -8,6 +8,9 @@
* $Id$
*
* $Log$
* Revision 1.1 1996/06/25 19:11:50 jbk
* new in EPICS base
*
*
* *Revision 1.2 1996/06/24 03:15:39 jbk
* *name changes and fixes for aitString and fixed string functions
@@ -24,68 +27,123 @@
#endif
#include "aitTypes.h"
#include "gddErrorCodes.h"
#include "gddNewDel.h"
typedef enum { gddSemEmpty, gddSemFull } gddSemType;
// ---------------------------------------------------------------------
// Describe the bounds of a single dimension in terms of the first
// element and the number of elements in the dimension.
#if 0
#ifdef vxWorks
#undef vxWorks
#define __temp_vxWorks__ 1
#endif
#endif
// Semaphores default to "Full"
class gddSemaphore
class gddBounds
{
public:
gddSemaphore(void);
gddSemaphore(gddSemType);
~gddSemaphore(void);
// I found a weird memory management quirk with SunOS when constructors
// are present in a class that is used as an array in another class
// as it is in gddBounds2D. The memory manager reallocates the entire
// gddBounds2D in some sort of buffer pool which stays allocated when the
// program completes
// gddBounds(void);
// gddBounds(aitIndex c);
// gddBounds(aitIndex f, aitIndex c);
void setSize(aitIndex c);
void setFirst(aitIndex c);
void set(aitIndex f, aitIndex c);
void get(aitIndex& f, aitIndex& c);
aitIndex size(void) const;
aitIndex first(void) const;
void give(void);
void take(void);
void take(aitUint32 usec);
private:
#ifdef vxWorks
SEM_ID sem;
#endif
aitIndex start;
aitIndex count;
};
#ifdef vxWorks
inline gddSemaphore::gddSemaphore(void)
{ sem=semBCreate(SEM_Q_PRIORITY,SEM_FULL); }
inline gddSemaphore::gddSemaphore(gddSemType s)
{
if(s==gddSemEmpty) sem=semBCreate(SEM_Q_PRIORITY,SEM_EMPTY);
else sem=semBCreate(SEM_Q_PRIORITY,SEM_FULL);
}
inline gddSemaphore::~gddSemaphore(void) { semDelete(sem); }
inline void gddSemaphore::give(void) { semGive(sem); }
inline void gddSemaphore::take(void) { semTake(sem,WAIT_FOREVER); }
inline void gddSemaphore::take(aitUint32 usec)
{ semTake(sem,usec/(sysClkRateGet()*1000000)); }
#else
inline gddSemaphore::gddSemaphore(void) { }
inline gddSemaphore::gddSemaphore(gddSemType) { }
inline gddSemaphore::~gddSemaphore(void) { }
inline void gddSemaphore::give(void) { }
inline void gddSemaphore::take(void) { }
inline void gddSemaphore::take(aitUint32) { }
#endif
#if 0
class gddIntLock
// ---------------------------------------------------------------------
// This is a class for managing the destruction of user data held within
// a DD. It allows multiple DDs to reference the same chunk of user
// data. The data would remain alive until the reference count goes to
// zero, at this time the user destructor function will be called with
// a pointer to the piece of data to deal with. The intention here is
// that user will create a subclass of this and supply the virtual
// function run(void*). The default behavior will be to treat the void*
// data as an array of aitInt8 and call remove.
// **** WARNING!
// The reference count is initialized to zero. This means that if you
// create one and want to keep it, you must reference it twice - the
// initial time and a time for your personal use. This is because the
// gdd library automatically increments the reference count on
// destructors when data is referenced into a gdd with a destructor.
// Remember the rule: if you pass a destructor to someone, then that
// someone now owns the destructor. A reference count of 1 indicates that
// the thing will go away when unreferenced - which is what you will
// have if you only reference the destructor once after it is created.
class gddDestructor
{
public:
gddDestructor(void);
gddDestructor(void* user_arg);
void reference(void);
int refCount(void) const;
gddStatus destroy(void* thing_to_remove);
virtual void run(void* thing_to_remove);
gdd_NEWDEL_FUNC(arg); // for using generic new and remove
protected:
aitUint16 ref_cnt;
void* arg;
private:
gdd_NEWDEL_DATA
};
#endif
#ifdef __temp_vxWorks__
#define vxWorks 1
#undef __temp_vxWorks__
#endif
#include "gddUtilsI.h"
// ---------------------------------------------------------------------
// Special managment for 1D-2D-3D bounds - others use normal new/remove.
// Since bounds are maintained as arrays, where the length of the array is
// the dimension of the data, we will manage the normal cases using
// free lists.
class gddBounds1D
{
public:
gddBounds1D(void) { }
gddBounds* boundArray(void);
gdd_NEWDEL_FUNC(b); // required for using generic new and remove
private:
gddBounds b[1];
gdd_NEWDEL_DATA // required for using generic new/remove
};
inline gddBounds* gddBounds1D::boundArray(void) { return (gddBounds*)b; }
class gddBounds2D
{
public:
gddBounds2D(void) { }
gddBounds* boundArray(void);
gdd_NEWDEL_FUNC(b); // required for using generic new and remove
private:
gddBounds b[2];
gdd_NEWDEL_DATA // required for using generic new/remove
};
inline gddBounds* gddBounds2D::boundArray(void) { return (gddBounds*)b; }
class gddBounds3D
{
public:
gddBounds3D(void) { }
gddBounds* boundArray(void);
gdd_NEWDEL_FUNC(b); // for using generic new and remove
private:
gddBounds b[3];
gdd_NEWDEL_DATA // required for using generic new/remove
};
inline gddBounds* gddBounds3D::boundArray(void) { return (gddBounds*)b; }
#endif
src/gdd/gddUtilsI.h
+28
View File
@@ -0,0 +1,28 @@
#ifndef GDD_UTILSI_H
#define GDD_UTILSI_H
/*
* Author: Jim Kowalkowski
* Date: 3/97
*
* $Id$
* $Log$
*
*/
// inline gddBounds::gddBounds(aitIndex c) { start=0; count=c; }
// inline gddBounds::gddBounds(aitIndex f, aitIndex c) { start=f; count=c; }
inline void gddBounds::setSize(aitIndex c) { count=c; }
inline void gddBounds::setFirst(aitIndex f) { start=f; }
inline void gddBounds::set(aitIndex f, aitIndex c) { start=f; count=c; }
inline void gddBounds::get(aitIndex& f, aitIndex& c){ f=start; c=count; }
inline aitIndex gddBounds::size(void) const { return count; }
inline aitIndex gddBounds::first(void) const { return start; }
inline gddDestructor::gddDestructor(void) { ref_cnt=0; arg=NULL; }
inline gddDestructor::gddDestructor(void* usr_arg) { ref_cnt=1; arg=usr_arg; }
inline void gddDestructor::reference(void) { ref_cnt++; }
inline int gddDestructor::refCount(void) const { return ref_cnt; }
#endif