diff --git a/src/gdd/dbMapper.cc b/src/gdd/dbMapper.cc index 3adb670b0..fa4147756 100644 --- a/src/gdd/dbMapper.cc +++ b/src/gdd/dbMapper.cc @@ -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 diff --git a/src/gdd/gdd.cc b/src/gdd/gdd.cc index 863fbf75d..598bf2ae4 100644 --- a/src/gdd/gdd.cc +++ b/src/gdd/gdd.cc @@ -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--------------------- diff --git a/src/gdd/gdd.h b/src/gdd/gdd.h index 87be3cb4c..85485ffd7 100644 --- a/src/gdd/gdd.h +++ b/src/gdd/gdd.h @@ -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) diff --git a/src/gdd/gddAppDefs.cc b/src/gdd/gddAppDefs.cc index 74615a575..6bfd10896 100644 --- a/src/gdd/gddAppDefs.cc +++ b/src/gdd/gddAppDefs.cc @@ -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); } diff --git a/src/gdd/gddTest.cc b/src/gdd/gddTest.cc index dbce5ad0a..faa1c1c80 100644 --- a/src/gdd/gddTest.cc +++ b/src/gdd/gddTest.cc @@ -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;