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

Fixed the spelling error with Scalar.

Browse Source
This commit is contained in:
Jim Kowalkowski
1996-07-26 02:23:18 +00:00
parent 72a8c35f55
commit 3c4ffb5cc4
5 changed files with 168 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/gdd/dbMapper.cc
+12 -9
View File
@@ -4,6 +4,9 @@
// $Id$
//
// $Log$
// Revision 1.7 1996/07/24 22:48:06 jhill
// fixed gnu warning int=>size_t
//
// Revision 1.6 1996/07/23 17:13:30 jbk
// various fixes - dbmapper incorrectly worked with enum types
//
@@ -128,7 +131,7 @@ static gdd* mapStringToGdd(void* v,aitIndex count) {
if(count<=1)
{
dd=new gddScaler(to_app,to_type);
dd=new gddScalar(to_app,to_type);
dd->put(*db);
}
else
@@ -156,7 +159,7 @@ static gdd* mapShortToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_SHORT].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_SHORT].app);
dd=new gddScalar(gddDbrToAit[DBR_SHORT].app);
*dd=*sv;
}
return dd;
@@ -184,7 +187,7 @@ static gdd* mapFloatToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_FLOAT].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_FLOAT].app);
dd=new gddScalar(gddDbrToAit[DBR_FLOAT].app);
*dd=*sv;
}
return dd;
@@ -212,7 +215,7 @@ static gdd* mapEnumToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_ENUM].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_ENUM].app);
dd=new gddScalar(gddDbrToAit[DBR_ENUM].app);
*dd=*sv;
}
return dd;
@@ -240,7 +243,7 @@ static gdd* mapCharToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_CHAR].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_CHAR].app);
dd=new gddScalar(gddDbrToAit[DBR_CHAR].app);
*dd=*sv;
}
return dd;
@@ -268,7 +271,7 @@ static gdd* mapLongToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_LONG].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_LONG].app);
dd=new gddScalar(gddDbrToAit[DBR_LONG].app);
*dd=*sv;
}
return dd;
@@ -296,7 +299,7 @@ static gdd* mapDoubleToGdd(void* v,aitIndex count) {
gddDbrToAit[DBR_DOUBLE].type,1,count);
dd->putRef(sv);
} else {
dd=new gddScaler(gddDbrToAit[DBR_DOUBLE].app);
dd=new gddScalar(gddDbrToAit[DBR_DOUBLE].app);
*dd=*sv;
}
return dd;
@@ -329,7 +332,7 @@ static gdd* mapStsStringToGdd(void* v,aitIndex count)
if(count<=1)
{
dd=new gddScaler(to_app,to_type);
dd=new gddScalar(to_app,to_type);
dd->put(*dbv);
}
else
@@ -464,7 +467,7 @@ static gdd* mapTimeStringToGdd(void* v,aitIndex count)
if(count<=1)
{
dd=new gddScaler(to_app,to_type);
dd=new gddScalar(to_app,to_type);
dd->put(*dbv);
}
else
src/gdd/gdd.cc
+16 -12
View File
@@ -4,6 +4,9 @@
// $Id$
//
// $Log$
// Revision 1.4 1996/07/23 17:13:31 jbk
// various fixes - dbmapper incorrectly worked with enum types
//
// Revision 1.3 1996/06/26 21:00:07 jbk
// Fixed up code in aitHelpers, removed unused variables in others
// Fixed potential problem in gddAppTable.cc with the map functions
@@ -137,7 +140,7 @@ gdd::~gdd(void)
// this function need to be corrected for use of aitEnumString!
if(isScaler())
if(isScalar())
{
if(primitiveType()==aitEnumFixedString)
{
@@ -222,7 +225,7 @@ gddStatus gdd::genCopy(aitEnum t, const void* d)
aitInt8* buf;
gddStatus rc=0;
if(isScaler())
if(isScalar())
aitConvert(primitiveType(),&data,t,d,1);
else if(isAtomic())
{
@@ -255,7 +258,7 @@ gddStatus gdd::changeType(int app,aitEnum prim)
// this should only be allowed for setting the type if it is
// undefined or if the data is a scaler
if(isScaler() || primitiveType()==aitEnumInvalid)
if(isScalar() || primitiveType()==aitEnumInvalid)
{
setApplType(app);
setPrimType(prim);
@@ -320,7 +323,7 @@ gddStatus gdd::copyStuff(gdd* dd,int ctype)
{
init(dd->applicationType(),dd->primitiveType(),dd->dimension());
if(dd->isScaler())
if(dd->isScalar())
data=dd->data;
else // atomic
{
@@ -408,7 +411,7 @@ size_t gdd::getTotalSizeBytes(void) const
sz=sizeof(gdd)+(sizeof(gddBounds)*dimension());
// special case the aitString/aitFixedString here - sucks bad
if(isScaler())
if(isScalar())
{
if(primitiveType()==aitEnumString)
{
@@ -519,7 +522,7 @@ size_t gdd::flattenWithAddress(void* buf, size_t size, aitIndex* total_dd)
// aitString or aitFixedString (even if scaler gdd)
// must special case the strings - that really sucks
if(isScaler())
if(isScalar())
{
// here is special case for the string types
if(primitiveType()==aitEnumFixedString)
@@ -658,7 +661,7 @@ gddStatus gdd::flattenData(gdd* dd, int tot_dds, void* buf,size_t size)
dd[i].bounds=NULL;
}
}
else if(dd[i].isScaler())
else if(dd[i].isScalar())
{
// here is special case for String types
if(dd[i].primitiveType()==aitEnumString)
@@ -771,7 +774,7 @@ gddStatus gdd::convertOffsetsToAddress(void)
}
}
}
else if(isScaler())
else if(isScalar())
{
if(primitiveType()==aitEnumFixedString)
if(data.FString) setData(pdd+dp);
@@ -840,7 +843,7 @@ gddStatus gdd::convertAddressToOffsets(void)
setData((gdd*)(dp-pdd));
bounds=(gddBounds*)(bnds-pdd);
}
else if(isScaler())
else if(isScalar())
{
// handle the special string scaler cases
if(primitiveType()==aitEnumFixedString)
@@ -957,12 +960,13 @@ gddStatus gdd::put(const gdd* dd)
if(isContainer() || dd->isContainer())
rc=gddErrorNotSupported;
else if(isScaler() && dd->isScaler())
else if(isScalar() && dd->isScalar())
{
// this is the simple case - just make this scaler look like the other
// not protected against screwing up the string type
setPrimType(dd->primitiveType());
put(((aitType*)dd->dataAddress()));
// set(dd->primitiveType(),dd->dataAddress());
}
else if(isAtomic() && dd->isAtomic())
{
@@ -1028,7 +1032,7 @@ gddStatus gdd::put(const gdd* dd)
#endif
}
}
else if(isScaler())
else if(isScalar())
{
// just put first element of dd into this scaler - sucks
if(dd->getDataSizeElements()>0)
@@ -1121,7 +1125,7 @@ gddStatus gddAtomic::setBoundingBoxOrigin(const aitUint32* const b)
return rc;
}
// --------------------The gddScaler functions---------------------
// --------------------The gddScalar functions---------------------
// --------------------The gddContainer functions---------------------
src/gdd/gdd.h
+35 -32
View File
@@ -8,6 +8,9 @@
* $Id$
*
* $Log$
* Revision 1.4 1996/07/24 22:17:17 jhill
* removed gdd:: from func proto
*
* Revision 1.3 1996/07/23 17:13:33 jbk
* various fixes - dbmapper incorrectly worked with enum types
*
@@ -88,7 +91,7 @@ typedef struct timespec timespec;
class gddContainer;
class gddAtomic;
class gddScaler;
class gddScalar;
// Not Complete in this prototype:
// - Read only DD.
@@ -254,7 +257,7 @@ public:
// ---------------------------------------------------------------------
// class structure for DDs:
//
// gddScaler
// gddScalar
// \
// gddAtomic gddContainer
// \ /
@@ -328,7 +331,7 @@ public:
// scaler or atomic type to container
// copyInfo() will copy DD info only, this means appl, primitive type
// and bounds. Scaler data will be copied, but no arrays.
// and bounds. Scalar data will be copied, but no arrays.
// copy() will copy DD info, bounds, allocate array data buffer and
// copy data into it.
// Dup() will copy DD info. bounds, data references copied only.
@@ -344,7 +347,7 @@ public:
gddStatus convertOffsetsToAddress(void);
gddStatus convertAddressToOffsets(void);
int isScaler(void) const;
int isScalar(void) const;
int isContainer(void) const;
int isAtomic(void) const;
@@ -645,7 +648,7 @@ inline void gdd::setStatSevr(aitInt16 st, aitInt16 se)
inline gdd& gdd::operator=(const gdd& v)
{ memcpy(this,&v,sizeof(gdd)); return *this; }
inline int gdd::isScaler(void) const { return dimension()==0?1:0; }
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
@@ -982,30 +985,30 @@ private:
// Add handling of the special case where the data is a scaler - the
// dimension is zero
class gddScaler : public gddAtomic
class gddScalar : public gddAtomic
{
public:
gddScaler(void) { }
gddScaler(gddScaler* ad) : gddAtomic(ad) { }
gddScaler(int app) : gddAtomic(app) { }
gddScaler(int app,aitEnum prim) : gddAtomic(app,prim) { }
gddScalar(void) { }
gddScalar(gddScalar* ad) : gddAtomic(ad) { }
gddScalar(int app) : gddAtomic(app) { }
gddScalar(int app,aitEnum prim) : gddAtomic(app,prim) { }
void dump(void);
void test(void);
gddScaler& operator=(aitFloat64 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitFloat32 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitUint32 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitInt32 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitUint16 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitInt16 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitUint8 d) { *((gdd*)this)=d; return *this; }
gddScaler& operator=(aitInt8 d) { *((gdd*)this)=d; return *this; }
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:
gddScaler(int app, aitEnum prim, int dimen, aitUint32* size_array):
gddScalar(int app, aitEnum prim, int dimen, aitUint32* size_array):
gddAtomic(app,prim,dimen,size_array) { }
~gddScaler(void) { }
~gddScalar(void) { }
// disallow
const gddBounds* getBounds(void) { return NULL; }
@@ -1054,7 +1057,7 @@ public:
// The following are slow and inefficient
gdd* getDD(aitIndex index);
gdd* getDD(aitIndex index,gddScaler*&);
gdd* getDD(aitIndex index,gddScalar*&);
gdd* getDD(aitIndex index,gddAtomic*&);
gdd* getDD(aitIndex index,gddContainer*&);
gdd* operator[](aitIndex index);
@@ -1083,8 +1086,8 @@ inline int gddContainer::total(void)
{ return bounds->size(); }
inline gdd* gddContainer::operator[](aitIndex index)
{ return getDD(index); }
inline gdd* gddContainer::getDD(aitIndex index,gddScaler*& dd)
{ return (gdd*)(dd=(gddScaler*)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)
@@ -1099,17 +1102,17 @@ public:
gddCursor(const gddContainer* ec);
gdd* first(void);
gdd* first(gddScaler*&);
gdd* first(gddScalar*&);
gdd* first(gddAtomic*&);
gdd* first(gddContainer*&);
gdd* next(void);
gdd* next(gddScaler*&);
gdd* next(gddScalar*&);
gdd* next(gddAtomic*&);
gdd* next(gddContainer*&);
gdd* current(void);
gdd* current(gddScaler*&);
gdd* current(gddScalar*&);
gdd* current(gddAtomic*&);
gdd* current(gddContainer*&);
@@ -1127,8 +1130,8 @@ inline gddCursor::gddCursor(const gddContainer* ec):list(ec)
inline gdd* gddCursor::first(void)
{ curr=list->cData(); curr_index=0; return curr; }
inline gdd* gddCursor::first(gddScaler*& dd)
{ return (gdd*)(dd=(gddScaler*)first()); }
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)
@@ -1136,8 +1139,8 @@ inline gdd* gddCursor::first(gddContainer*& dd)
inline gdd* gddCursor::next(void)
{ if(curr) { curr_index++;curr=curr->next(); } return curr; }
inline gdd* gddCursor::next(gddScaler*& dd)
{ return (gdd*)(dd=(gddScaler*)next()); }
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)
@@ -1145,8 +1148,8 @@ inline gdd* gddCursor::next(gddContainer*& dd)
inline gdd* gddCursor::current(void)
{ return curr; }
inline gdd* gddCursor::current(gddScaler*& dd)
{ return (gdd*)(dd=(gddScaler*)current()); }
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)
src/gdd/gddAppDefs.cc
+89 -86
View File
@@ -4,6 +4,9 @@
// $Id$
//
// $Log$
// Revision 1.2 1996/07/23 17:13:34 jbk
// various fixes - dbmapper incorrectly worked with enum types
//
// Revision 1.1 1996/06/25 19:11:41 jbk
// new in EPICS base
//
@@ -108,147 +111,147 @@ void gddApplicationTypeTable::GenerateTypes(void)
// DBR_GR_SHORT
gddContainer* cdd_gr_short=new gddContainer(0);
cdd_gr_short->insert(new gddScaler(type_value,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_ghigh,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_glow,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_ahigh,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_alow,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_awhigh,aitEnumInt16));
cdd_gr_short->insert(new gddScaler(type_awlow,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_value,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_ghigh,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_glow,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_ahigh,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_alow,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_awhigh,aitEnumInt16));
cdd_gr_short->insert(new gddScalar(type_awlow,aitEnumInt16));
cdd_gr_short->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_gr_short",cdd_gr_short);
// DBR_GR_FLOAT
gddContainer* cdd_gr_float=new gddContainer(0);
cdd_gr_float->insert(new gddScaler(type_value,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_prec,aitEnumInt16));
cdd_gr_float->insert(new gddScaler(type_ghigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_glow,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_ahigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_alow,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_awhigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScaler(type_awlow,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_value,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_prec,aitEnumInt16));
cdd_gr_float->insert(new gddScalar(type_ghigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_glow,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_ahigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_alow,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_awhigh,aitEnumFloat32));
cdd_gr_float->insert(new gddScalar(type_awlow,aitEnumFloat32));
cdd_gr_float->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_gr_float",cdd_gr_float);
// DBR_GR_ENUM
gddContainer* cdd_gr_enum=new gddContainer(0);
cdd_gr_enum->insert(getDD(type_menu));
cdd_gr_enum->insert(new gddScaler(type_value,aitEnumEnum16));
cdd_gr_enum->insert(new gddScalar(type_value,aitEnumEnum16));
registerApplicationTypeWithProto("dbr_gr_enum",cdd_gr_enum);
// DBR_GR_CHAR
gddContainer* cdd_gr_char=new gddContainer(0);
cdd_gr_char->insert(new gddScaler(type_value,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_ghigh,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_glow,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_ahigh,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_alow,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_awhigh,aitEnumInt8));
cdd_gr_char->insert(new gddScaler(type_awlow,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_value,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_ghigh,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_glow,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_ahigh,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_alow,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_awhigh,aitEnumInt8));
cdd_gr_char->insert(new gddScalar(type_awlow,aitEnumInt8));
cdd_gr_char->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_gr_char",cdd_gr_char);
// DBR_GR_LONG
gddContainer* cdd_gr_long=new gddContainer(0);
cdd_gr_long->insert(new gddScaler(type_value,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_ghigh,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_glow,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_ahigh,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_alow,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_awhigh,aitEnumInt32));
cdd_gr_long->insert(new gddScaler(type_awlow,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_value,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_ghigh,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_glow,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_ahigh,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_alow,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_awhigh,aitEnumInt32));
cdd_gr_long->insert(new gddScalar(type_awlow,aitEnumInt32));
cdd_gr_long->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_gr_long",cdd_gr_long);
// DBR_GR_DOUBLE
gddContainer* cdd_gr_double=new gddContainer(0);
cdd_gr_double->insert(new gddScaler(type_value,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_prec,aitEnumInt16));
cdd_gr_double->insert(new gddScaler(type_ghigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_glow,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_ahigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_alow,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_awhigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScaler(type_awlow,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_value,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_prec,aitEnumInt16));
cdd_gr_double->insert(new gddScalar(type_ghigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_glow,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_ahigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_alow,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_awhigh,aitEnumFloat64));
cdd_gr_double->insert(new gddScalar(type_awlow,aitEnumFloat64));
cdd_gr_double->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_gr_double",cdd_gr_double);
// DBR_CTRL_SHORT
gddContainer* cdd_ctrl_short=new gddContainer(0);
cdd_ctrl_short->insert(new gddScaler(type_value,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_ghigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_glow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_chigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_clow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_ahigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_alow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_awhigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScaler(type_awlow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_value,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_ghigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_glow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_chigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_clow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_ahigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_alow,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_awhigh,aitEnumInt16));
cdd_ctrl_short->insert(new gddScalar(type_awlow,aitEnumInt16));
cdd_ctrl_short->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_ctrl_short",cdd_ctrl_short);
// DBR_CTRL_FLOAT
gddContainer* cdd_ctrl_float=new gddContainer(0);
cdd_ctrl_float->insert(new gddScaler(type_value,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_prec,aitEnumInt16));
cdd_ctrl_float->insert(new gddScaler(type_ghigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_glow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_chigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_clow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_ahigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_alow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_awhigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScaler(type_awlow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_value,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_prec,aitEnumInt16));
cdd_ctrl_float->insert(new gddScalar(type_ghigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_glow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_chigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_clow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_ahigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_alow,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_awhigh,aitEnumFloat32));
cdd_ctrl_float->insert(new gddScalar(type_awlow,aitEnumFloat32));
cdd_ctrl_float->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_ctrl_float",cdd_ctrl_float);
// DBR_CTRL_ENUM
gddContainer* cdd_ctrl_enum=new gddContainer(0);
cdd_ctrl_enum->insert(getDD(type_menu));
cdd_ctrl_enum->insert(new gddScaler(type_value,aitEnumEnum16));
cdd_ctrl_enum->insert(new gddScalar(type_value,aitEnumEnum16));
registerApplicationTypeWithProto("dbr_ctrl_enum",cdd_ctrl_enum);
// DBR_CTRL_CHAR
gddContainer* cdd_ctrl_char=new gddContainer(0);
cdd_ctrl_char->insert(new gddScaler(type_value,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_ghigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_glow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_chigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_clow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_ahigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_alow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_awhigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScaler(type_awlow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_value,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_ghigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_glow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_chigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_clow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_ahigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_alow,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_awhigh,aitEnumInt8));
cdd_ctrl_char->insert(new gddScalar(type_awlow,aitEnumInt8));
cdd_ctrl_char->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_ctrl_char",cdd_ctrl_char);
// DBR_CTRL_LONG
gddContainer* cdd_ctrl_long=new gddContainer(0);
cdd_ctrl_long->insert(new gddScaler(type_value,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_ghigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_glow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_chigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_clow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_ahigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_alow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_awhigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScaler(type_awlow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_value,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_ghigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_glow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_chigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_clow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_ahigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_alow,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_awhigh,aitEnumInt32));
cdd_ctrl_long->insert(new gddScalar(type_awlow,aitEnumInt32));
cdd_ctrl_long->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_ctrl_long",cdd_ctrl_long);
// DBR_CTRL_DOUBLE
gddContainer* cdd_ctrl_double=new gddContainer(0);
cdd_ctrl_double->insert(new gddScaler(type_value,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_prec,aitEnumInt16));
cdd_ctrl_double->insert(new gddScaler(type_ghigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_glow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_chigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_clow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_ahigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_alow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_awhigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScaler(type_awlow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_value,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_prec,aitEnumInt16));
cdd_ctrl_double->insert(new gddScalar(type_ghigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_glow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_chigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_clow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_ahigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_alow,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_awhigh,aitEnumFloat64));
cdd_ctrl_double->insert(new gddScalar(type_awlow,aitEnumFloat64));
cdd_ctrl_double->insert(getDD(type_units));
registerApplicationTypeWithProto("dbr_ctrl_double",cdd_ctrl_double);
}
src/gdd/gddTest.cc
+16 -13
View File
@@ -4,6 +4,9 @@
// $Id$
//
// $Log$
// Revision 1.1 1996/06/25 19:11:48 jbk
// new in EPICS base
//
//
// *Revision 1.3 1996/06/24 03:15:38 jbk
@@ -23,13 +26,13 @@ void gdd::dump(void) { }
#else
void gdd::dump(void)
{
gddScaler* sdd;
gddScalar* sdd;
gddAtomic* add;
gddContainer* cdd;
if(isScaler())
if(isScalar())
{
sdd=(gddScaler*)this;
sdd=(gddScalar*)this;
sdd->dump();
return;
}
@@ -73,11 +76,11 @@ void gdd::dumpInfo(void)
fprintf(stderr," (%d) %8.8x first=%d count=%d\n",i,&bounds[i],f,c);
}
if(isScaler()) fprintf(stderr," Is a Scaler\n");
if(isScalar()) fprintf(stderr," Is a Scalar\n");
if(isAtomic()) fprintf(stderr," Is a Atomic\n");
if(isContainer()) fprintf(stderr," Is a Container\n");
if(!isContainer() && !isScaler() && !isAtomic())
if(!isContainer() && !isScalar() && !isAtomic())
fprintf(stderr,"--------------------------------------\n");
}
#endif
@@ -157,9 +160,9 @@ void gddAtomic::dump(void)
#endif
#ifdef NO_DUMP_TEST
void gddScaler::dump(void) { }
void gddScalar::dump(void) { }
#else
void gddScaler::dump(void)
void gddScalar::dump(void)
{
aitFloat64 f64; aitFloat32 f32; aitUint32 ui32; aitInt32 i32;
aitUint16 ui16; aitInt16 i16; aitUint8 ui8; aitInt8 i8;
@@ -319,9 +322,9 @@ void gddAtomic::test(void)
#endif
#ifdef NO_DUMP_TEST
void gddScaler::test(void) { }
void gddScalar::test(void) { }
#else
void gddScaler::test(void)
void gddScalar::test(void)
{
int i;
aitFloat32 fa32,f32 = 32.0;
@@ -400,7 +403,7 @@ void gddContainer::dump(void)
int i;
gdd* dd;
gddAtomic* add;
gddScaler* sdd;
gddScalar* sdd;
gddContainer* cdd;
fprintf(stderr,"----------dumping container:\n");
@@ -412,7 +415,7 @@ void gddContainer::dump(void)
for(i=0;dd=getDD(i);i++)
{
if(dd->isAtomic()) { add=(gddAtomic*)dd; add->dump(); }
if(dd->isScaler()) { sdd=(gddScaler*)dd; sdd->dump(); }
if(dd->isScalar()) { sdd=(gddScalar*)dd; sdd->dump(); }
if(dd->isContainer()) { cdd=(gddContainer*)dd; cdd->dump(); }
}
}
@@ -423,8 +426,8 @@ void gddContainer::test(void) { }
#else
void gddContainer::test(void)
{
gddScaler* sdd1 = new gddScaler(1,aitEnumInt32);
gddScaler* sdd2 = new gddScaler(2,aitEnumInt16);
gddScalar* sdd1 = new gddScalar(1,aitEnumInt32);
gddScalar* sdd2 = new gddScalar(2,aitEnumInt16);
gddAtomic* add1 = new gddAtomic(3,aitEnumFloat32,1,3);
gddContainer* cdd1;