*** empty log message ***

diff --git a/allParam/ca/server/Makefile b/allParam/ca/server/Makefile
index 2bb7f1d6892870f2ca0acc51f4450fbaecf5127c..9e87ad416faff2fb68128578c079bf58d220806a 100644 (file)
--- a/allParam/ca/server/Makefile
+++ b/allParam/ca/server/Makefile
@@ -11,8 +11,8 @@ LOADLIBES = -L$(EPICS_BASE)/lib/$(HOST_ARCH) -lcas -lgdd -lca -lCom
 
 # Objects
 
-OBJS = record.o paramRecord.o paramGetRecord.o paramStoreRecord.o \
-  paramRecordSet.o paramServer.o
+OBJS = record.o paramRecord.o paramIntRecord.o paramStringRecord.o \
+  paramFilenameRecord.o paramBlobRecord.o paramRecordSet.o paramServer.o
 
 ###########
 # Targets #
@@ -44,14 +44,18 @@ daq_param_cas : $(OBJS)
 paramServer.o: paramServer.cc paramRecordSet.h \
   paramRecord.h record.h
 
-paramRecordSet.o: paramRecordSet.cc paramRecordSet.h paramGetRecord.h \
-  paramStoreRecord.h paramRecord.h record.h
+paramRecordSet.o: paramRecordSet.cc paramRecordSet.h \
+  paramIntRecord.h paramStringRecord.h paramFilenameRecord.h paramBlobRecord.h \
+  paramRecord.h record.h
 
 record.o : record.cc record.h
 paramRecord.o: paramRecord.cc paramRecord.h record.h
-paramGetRecord.o: paramGetRecord.cc paramGetRecord.h paramRecord.h record.h
-paramStoreRecord.o: paramStoreRecord.cc paramStoreRecord.h paramRecord.h \
+paramIntRecord.o: paramIntRecord.cc paramIntRecord.h paramRecord.h record.h
+paramStringRecord.o: paramStringRecord.cc paramStringRecord.h paramRecord.h \
   record.h
+paramFilenameRecord.o: paramFilenameRecord.cc paramFilenameRecord.h \
+  paramRecord.h record.h
+paramBlobRecord.o: paramBlobRecord.cc paramBlobRecord.h paramRecord.h record.h
 
 # Libraries as sources for the server
 

diff --git a/allParam/ca/server/paramBlobRecord.cc b/allParam/ca/server/paramBlobRecord.cc
new file mode 100644 (file)
index 0000000..a29b87b
--- /dev/null
+++ b/allParam/ca/server/paramBlobRecord.cc
@@ -0,0 +1,139 @@
+#define _POSIX_C_SOURCE 199509L
+
+extern "C" {
+  #include <string.h>
+}
+
+#include "paramBlobRecord.h"
+
+ParamBlobRecord::ParamBlobRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
+  ParamRecord(cas, p, rn, u)
+{
+       index = 0;
+       funcTable.installReadFunc("units", &Record::readUnits);
+       funcTable.installReadFunc("status", &Record::readStatus);
+       funcTable.installReadFunc("severity", &Record::readSeverity);
+
+       funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl);
+       funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl);
+       funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr);
+       funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr);
+       funcTable.installReadFunc("precision", &ParamRecord::readPrecision);
+
+       funcTable.installReadFunc("value", &ParamBlobRecord::readValue);
+}
+
+ParamBlobRecord::~ParamBlobRecord()
+{
+       for(int k = 0 ; k < index ; k++) {
+               delete ourValue[k];
+       }
+}
+
+aitBool ParamBlobRecord::paramDoesReallyExist()
+{
+       aitBool retVal = aitFalse;
+       for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               ourValue[k] = new char[PARAM_MAX_VALUE_LEN];
+       }
+
+       int rows;
+
+       if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) {
+               index = rows;
+               retVal = aitTrue;
+       }
+
+       for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               delete ourValue[k];
+       }
+       return retVal;
+}
+
+epicsShareFunc unsigned ParamBlobRecord::maxDimension() const
+{
+       return 1u;
+}
+
+epicsShareFunc aitIndex ParamBlobRecord::maxBound(unsigned dimension) const
+{
+       aitIndex retVal;
+       if(dimension == 0) {
+               retVal = index;
+       } else {
+               retVal = 1u;
+       }
+       return retVal;
+}
+
+gddAppFuncTableStatus ParamBlobRecord::readValue(gdd &value)
+{
+       if(index == 1) {
+               aitString stringValue = new aitString;
+
+               stringValue = ourValue[0];
+
+               value.putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               value.putRef(stringValue);
+       }
+
+       return S_casApp_success;
+}
+
+caStatus ParamBlobRecord::scan()
+{
+       caStatus retVal;
+       caServer *pCAS = this->getCAS();
+
+       if(index == 1) {
+               aitString stringValue = new aitString;
+               val = new gddScalar(gddAppType_value, aitEnumString);
+
+               stringValue = ourValue[0];
+
+               val->putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+
+               val = new gddAtomic(gddAppType_value, aitEnumString, 1, index);
+
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               ArrayDestructor *pDest = new ArrayDestructor;
+
+               val->putRef(stringValue, pDest);
+       }
+
+       val->setStat(epicsAlarmNone);
+       val->setSevr(epicsSevNone);
+
+       if (this->interest == aitTrue && pCAS != NULL) {
+               casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask);
+               this->postEvent (select, *val);
+       }
+
+       retVal = S_cas_success;
+
+       return retVal;
+}
+
+caStatus ParamBlobRecord::read(const casCtx &ctx, gdd &prototype)
+{
+       return ((scan() == S_cas_success) && funcTable.read(*this, prototype));
+}
+
+caStatus ParamBlobRecord::write(const casCtx &ctx, gdd &value)
+{
+       return S_cas_noWrite;
+}
+

diff --git a/allParam/ca/server/paramBlobRecord.h b/allParam/ca/server/paramBlobRecord.h
new file mode 100644 (file)
index 0000000..f071c22
--- /dev/null
+++ b/allParam/ca/server/paramBlobRecord.h
@@ -0,0 +1,26 @@
+#ifndef PARAMBLOBRECORD_H
+#define PARAMBLOBRECORD_H
+
+#include "paramRecord.h"
+
+class ParamBlobRecord : public ParamRecord {
+  private:
+       aitIndex index;
+       char *ourValue[PARAM_MAX_ARRAY_LEN];
+       gddAppFuncTable<ParamBlobRecord> funcTable;
+
+  public:
+       ParamBlobRecord(caServer&, const Param *, const char *, const char *);
+       ~ParamBlobRecord();
+
+       aitBool paramDoesReallyExist();
+       epicsShareFunc unsigned maxDimension() const;
+       epicsShareFunc aitIndex maxBound(unsigned int) const;
+       gddAppFuncTableStatus readValue(gdd &);
+       caStatus scan();
+       caStatus read(const casCtx &, gdd &);
+       caStatus write(const casCtx &, gdd &);
+};
+
+#endif
+

diff --git a/allParam/ca/server/paramGetRecord.cc b/allParam/ca/server/paramFilenameRecord.cc
similarity index 77%
rename from allParam/ca/server/paramGetRecord.cc
rename to allParam/ca/server/paramFilenameRecord.cc
index 71dbf6bb63e7d3df68f5be74ed39fe15c9b10039..b2d20dd66faca7912d7bb9ff884ae53f55fd265e 100644 (file)
--- a/allParam/ca/server/paramGetRecord.cc
+++ b/allParam/ca/server/paramFilenameRecord.cc
@@ -4,14 +4,9 @@ extern "C" {
   #include <string.h>
 }
 
-#include "paramGetRecord.h"
+#include "paramFilenameRecord.h"
 
-void ArrayDestructor::run(void *todelete) {
-       aitString *pd = (aitString *) todelete;
-       delete [] pd;
-}
-
-ParamGetRecord::ParamGetRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
+ParamFilenameRecord::ParamFilenameRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
   ParamRecord(cas, p, rn, u)
 {
        index = 0;
@@ -25,17 +20,17 @@ ParamGetRecord::ParamGetRecord(caServer& cas, const Param *p, const char *rn, co
        funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr);
        funcTable.installReadFunc("precision", &ParamRecord::readPrecision);
 
-       funcTable.installReadFunc("value", &ParamGetRecord::readValue);
+       funcTable.installReadFunc("value", &ParamFilenameRecord::readValue);
 }
 
-ParamGetRecord::~ParamGetRecord()
+ParamFilenameRecord::~ParamFilenameRecord()
 {
        for(int k = 0 ; k < index ; k++) {
                delete ourValue[k];
        }
 }
 
-aitBool ParamGetRecord::paramDoesReallyExist()
+aitBool ParamFilenameRecord::paramDoesReallyExist()
 {
        aitBool retVal = aitFalse;
        for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) {
@@ -55,12 +50,12 @@ aitBool ParamGetRecord::paramDoesReallyExist()
        return retVal;
 }
 
-epicsShareFunc unsigned ParamGetRecord::maxDimension() const
+epicsShareFunc unsigned ParamFilenameRecord::maxDimension() const
 {
        return 1u;
 }
 
-epicsShareFunc aitIndex ParamGetRecord::maxBound(unsigned dimension) const
+epicsShareFunc aitIndex ParamFilenameRecord::maxBound(unsigned dimension) const
 {
        aitIndex retVal;
        if(dimension == 0) {
@@ -71,7 +66,7 @@ epicsShareFunc aitIndex ParamGetRecord::maxBound(unsigned dimension) const
        return retVal;
 }
 
-gddAppFuncTableStatus ParamGetRecord::readValue(gdd &value)
+gddAppFuncTableStatus ParamFilenameRecord::readValue(gdd &value)
 {
        if(index == 1) {
                aitString stringValue = new aitString;
@@ -92,7 +87,7 @@ gddAppFuncTableStatus ParamGetRecord::readValue(gdd &value)
        return S_casApp_success;
 }
 
-caStatus ParamGetRecord::scan()
+caStatus ParamFilenameRecord::scan()
 {
        caStatus retVal;
        caServer *pCAS = this->getCAS();
@@ -132,12 +127,12 @@ caStatus ParamGetRecord::scan()
        return retVal;
 }
 
-caStatus ParamGetRecord::read(const casCtx &ctx, gdd &prototype)
+caStatus ParamFilenameRecord::read(const casCtx &ctx, gdd &prototype)
 {
        return ((scan() == S_cas_success) && funcTable.read(*this, prototype));
 }
 
-caStatus ParamGetRecord::write(const casCtx &ctx, gdd &value)
+caStatus ParamFilenameRecord::write(const casCtx &ctx, gdd &value)
 {
        return S_cas_noWrite;
 }

diff --git a/allParam/ca/server/paramFilenameRecord.h b/allParam/ca/server/paramFilenameRecord.h
new file mode 100644 (file)
index 0000000..6e32a09
--- /dev/null
+++ b/allParam/ca/server/paramFilenameRecord.h
@@ -0,0 +1,26 @@
+#ifndef PARAMFILENAMERECORD_H
+#define PARAMFILENAMERECORD_H
+
+#include "paramRecord.h"
+
+class ParamFilenameRecord : public ParamRecord {
+  private:
+       aitIndex index;
+       char *ourValue[PARAM_MAX_ARRAY_LEN];
+       gddAppFuncTable<ParamFilenameRecord> funcTable;
+
+  public:
+       ParamFilenameRecord(caServer&, const Param *, const char *, const char *);
+       ~ParamFilenameRecord();
+
+       aitBool paramDoesReallyExist();
+       epicsShareFunc unsigned maxDimension() const;
+       epicsShareFunc aitIndex maxBound(unsigned int) const;
+       gddAppFuncTableStatus readValue(gdd &);
+       caStatus scan();
+       caStatus read(const casCtx &, gdd &);
+       caStatus write(const casCtx &, gdd &);
+};
+
+#endif
+

diff --git a/allParam/ca/server/paramIntRecord.cc b/allParam/ca/server/paramIntRecord.cc
new file mode 100644 (file)
index 0000000..7d37f3f
--- /dev/null
+++ b/allParam/ca/server/paramIntRecord.cc
@@ -0,0 +1,150 @@
+#define _POSIX_C_SOURCE 199509L
+
+extern "C" {
+  #include <string.h>
+}
+
+#include "paramIntRecord.h"
+
+ParamIntRecord::ParamIntRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
+  ParamRecord(cas, p, rn, u)
+{
+       index = 0;
+       funcTable.installReadFunc("units", &Record::readUnits);
+       funcTable.installReadFunc("status", &Record::readStatus);
+       funcTable.installReadFunc("severity", &Record::readSeverity);
+
+       funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl);
+       funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl);
+       funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr);
+       funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr);
+       funcTable.installReadFunc("precision", &ParamRecord::readPrecision);
+
+       funcTable.installReadFunc("value", &ParamIntRecord::readValue);
+}
+
+ParamIntRecord::~ParamIntRecord()
+{
+       for(int k = 0 ; k < index ; k++) {
+               delete ourValue[k];
+       }
+}
+
+aitBool ParamIntRecord::paramDoesReallyExist()
+{
+       aitBool retVal = aitFalse;
+       for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               ourValue[k] = new char[PARAM_MAX_VALUE_LEN];
+       }
+
+       int rows;
+
+       if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) {
+               index = rows;
+               retVal = aitTrue;
+       }
+
+       for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               delete ourValue[k];
+       }
+       return retVal;
+}
+
+epicsShareFunc unsigned ParamIntRecord::maxDimension() const
+{
+       return 1u;
+}
+
+epicsShareFunc aitIndex ParamIntRecord::maxBound(unsigned dimension) const
+{
+       aitIndex retVal;
+       if(dimension == 0) {
+               retVal = index;
+       } else {
+               retVal = 1u;
+       }
+       return retVal;
+}
+
+gddAppFuncTableStatus ParamIntRecord::readValue(gdd &value)
+{
+       if(index == 1) {
+               aitString stringValue = new aitString;
+
+               stringValue = ourValue[0];
+
+               value.putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               value.putRef(stringValue);
+       }
+
+       return S_casApp_success;
+}
+
+caStatus ParamIntRecord::scan()
+{
+       caStatus retVal;
+       caServer *pCAS = this->getCAS();
+
+       if(index == 1) {
+               aitString stringValue = new aitString;
+               val = new gddScalar(gddAppType_value, aitEnumString);
+
+               stringValue = ourValue[0];
+
+               val->putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+
+               val = new gddAtomic(gddAppType_value, aitEnumString, 1, index);
+
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               ArrayDestructor *pDest = new ArrayDestructor;
+
+               val->putRef(stringValue, pDest);
+       }
+
+       val->setStat(epicsAlarmNone);
+       val->setSevr(epicsSevNone);
+
+       if (this->interest == aitTrue && pCAS != NULL) {
+               casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask);
+               this->postEvent (select, *val);
+       }
+
+       retVal = S_cas_success;
+
+       return retVal;
+}
+
+caStatus ParamIntRecord::read(const casCtx &ctx, gdd &prototype)
+{
+       return ((scan() == S_cas_success) && funcTable.read(*this, prototype));
+}
+
+caStatus ParamIntRecord::write(const casCtx &ctx, gdd &value)
+{
+       caServer *pCAS = this->getCAS();
+
+       aitString stringValue;
+
+       value.getConvert(stringValue);
+
+       char ourValue[PARAM_MAX_VALUE_LEN];
+       strcpy(ourValue, (const char *) stringValue);
+
+       Param_storeString(param, name, idx, ourValue);
+
+       return S_cas_success;
+}
+

diff --git a/allParam/ca/server/paramGetRecord.h b/allParam/ca/server/paramIntRecord.h
similarity index 56%
rename from allParam/ca/server/paramGetRecord.h
rename to allParam/ca/server/paramIntRecord.h
index ae9ada5cf44d3815fd9b50b48fcd4df510153646..5f7e6b5e93d78cb8c71d9f0daf01f3d3154041e8 100644 (file)
--- a/allParam/ca/server/paramGetRecord.h
+++ b/allParam/ca/server/paramIntRecord.h
@@ -1,21 +1,17 @@
-#ifndef PARAMGETRECORD_H
-#define PARAMGETRECORD_H
+#ifndef PARAMINTRECORD_H
+#define PARAMINTRECORD_H
 
 #include "paramRecord.h"
 
-class ArrayDestructor : public gddDestructor {
-       virtual void run(void *);
-};
-
-class ParamGetRecord : public ParamRecord {
+class ParamIntRecord : public ParamRecord {
   private:
        aitIndex index;
        char *ourValue[PARAM_MAX_ARRAY_LEN];
-       gddAppFuncTable<ParamGetRecord> funcTable;
+       gddAppFuncTable<ParamIntRecord> funcTable;
 
   public:
-       ParamGetRecord(caServer&, const Param *, const char *, const char *);
-       ~ParamGetRecord();
+       ParamIntRecord(caServer&, const Param *, const char *, const char *);
+       ~ParamIntRecord();
 
        aitBool paramDoesReallyExist();
        epicsShareFunc unsigned maxDimension() const;

diff --git a/allParam/ca/server/paramRecord.cc b/allParam/ca/server/paramRecord.cc
index b3e663078919dbcd9f48b5515be5edd6718630c5..5b77e8c6424101cc806e4dcabc7ced28e636a73f 100644 (file)
--- a/allParam/ca/server/paramRecord.cc
+++ b/allParam/ca/server/paramRecord.cc
@@ -8,6 +8,11 @@ extern "C" {
 
 #include "paramRecord.h"
 
+void ArrayDestructor::run(void *todelete) {
+       aitString *pd = (aitString *) todelete;
+       delete [] pd;
+}
+
 ParamRecord::ParamRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
   Record(cas, rn, u, aitEnumString), param(p)
 {
@@ -16,10 +21,11 @@ ParamRecord::ParamRecord(caServer& cas, const Param *p, const char *rn, const ch
        char buf2[PARAM_MAX_NAME_LEN];
        char buf3[PARAM_MAX_NAME_LEN];
 
+       strcpy(pPVName, rn);
        strcpy(buf1, "");
        strcpy(buf2, "");
        strcpy(buf3, "");
-       sscanf(rn, "HAD:P%c:%[^:]:%[^:]:%[^:]", &tmp, buf1, buf2, buf3);
+       sscanf(pPVName, "HAD:P%c:%[^:]:%[^:]:%[^:]", &tmp, buf1, buf2, buf3);
        if(strcmp(buf3, "") == 0) {
                strcpy(name, buf1);
                strcpy(idx, buf2);
@@ -46,6 +52,11 @@ epicsShareFunc aitEnum ParamRecord::bestExternalType() const
        return aitEnumString;
 }
 
+const char *ParamRecord::getPVName()
+{
+       return pPVName;
+}
+
 gddAppFuncTableStatus ParamRecord::readLowCtrl(gdd &value)
 {
        value.putConvert(0);

diff --git a/allParam/ca/server/paramRecord.h b/allParam/ca/server/paramRecord.h
index 4eb555141ab2705fa8312548b48f23518355b066..af6e703b8a196c7e1732cc714f4f2c1dab09b1e1 100644 (file)
--- a/allParam/ca/server/paramRecord.h
+++ b/allParam/ca/server/paramRecord.h
@@ -9,15 +9,21 @@ extern "C" {
 
 #include "record.h"
 
+class ArrayDestructor : public gddDestructor {
+       virtual void run(void *);
+};
+
 class ParamRecord : public Record {
   protected:
        const Param *param;
+       char pPVName[PARAM_MAX_VALUE_LEN];
        char name[PARAM_MAX_VALUE_LEN];
        char idx[PARAM_MAX_VALUE_LEN];
   public:
        ParamRecord(caServer&, const Param *, const char *, const char *);
        ~ParamRecord();
 
+       const char *getPVName();
        epicsShareFunc aitEnum bestExternalType() const;
 
        virtual gddAppFuncTableStatus readLowCtrl(gdd &);

diff --git a/allParam/ca/server/paramRecordSet.cc b/allParam/ca/server/paramRecordSet.cc
index 8c2d3ecc7f75ad911787022339ec5754c19daa9b..760b9df59b3af2611110e7165293fe851795d4ce 100644 (file)
--- a/allParam/ca/server/paramRecordSet.cc
+++ b/allParam/ca/server/paramRecordSet.cc
@@ -9,8 +9,10 @@ extern "C" {
 }
 
 #include "paramRecordSet.h"
-#include "paramGetRecord.h"
-#include "paramStoreRecord.h"
+#include "paramIntRecord.h"
+#include "paramStringRecord.h"
+#include "paramFilenameRecord.h"
+#include "paramBlobRecord.h"
 
 ParamRecordSet::ParamRecordSet(unsigned int pvCountEstimate) :
   caServer(pvCountEstimate)
@@ -46,6 +48,7 @@ Param *ParamRecordSet::pParam(const char *setup)
 pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName)
 {
        char *setup;
+       char type;
        char buf1[PARAM_MAX_NAME_LEN];
        char buf2[PARAM_MAX_NAME_LEN];
        char buf3[PARAM_MAX_NAME_LEN];
@@ -53,37 +56,20 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName
        strcpy(buf1, "");
        strcpy(buf2, "");
        strcpy(buf3, "");
-       if(strncmp(pPVName, "HAD:PS:", strlen("HAD:PS:")) == 0) {
-               sscanf(pPVName, "HAD:PS:[^:]:[^:]:[^:]", buf1, buf2, buf3);
-               if (strcmp(buf3, "") == 0) {
-                       setup = NULL;
-               } else {
-                       setup = buf1;
-                       for (int i = 0 ; i < strlen(setup) ; i++) {
-                               setup[i] = tolower(setup[i]);
-                       }
-               }
-               if(pParam(setup) == NULL) {
-                       param[numParamSrc] = new Param;
-                       if (conSetupParam(param[numParamSrc], setup) == 0) {
-                               numParamSrc++;
-                       } else {
-                               desParam(param[numParamSrc]);
-                               delete param[numParamSrc];
-                       }
-               }
-               if(pParam(setup) != NULL) {
+
+       for (int i = 0 ; i < numPv ; i++) {
+               if(strcmp(pPVName, pvs[i]->getPVName()) == 0) {
                        return pverExistsHere;
-               } else {
-                       return pverDoesNotExistHere;
                }
-       } else if(strncmp(pPVName, "HAD:PG:", strlen("HAD:PG:")) == 0) {
-               sscanf(pPVName, "HAD:PG:[^:]:[^:]:[^:]", buf1, buf2, buf3);
+       }
+
+       if(strncmp(pPVName, "HAD:P", strlen("HAD:P")) == 0) {
+               sscanf(pPVName, "HAD:P%c:[^:]:[^:]:[^:]", &type, buf1, buf2, buf3);
                if (strcmp(buf3, "") == 0) {
                        setup = NULL;
                } else {
                        setup = buf1;
-                       for (int i = 0 ; i < strlen(setup) ; i++) {
+                       for (unsigned int i = 0 ; i < strlen(setup) ; i++) {
                                setup[i] = tolower(setup[i]);
                        }
                }
@@ -97,14 +83,7 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName
                        }
                }
                if(pParam(setup) != NULL) {
-                       ParamGetRecord *record = new ParamGetRecord(*this, pParam(setup), pPVName, "String Array");
-                       if(record->paramDoesReallyExist()) {
-                               delete record;
-                               return pverExistsHere;
-                       } else {
-                               delete record;
-                               return pverDoesNotExistHere;
-                       }
+                       return pverExistsHere;
                } else {
                        return pverDoesNotExistHere;
                }
@@ -114,51 +93,47 @@ pvExistReturn ParamRecordSet::pvExistTest(const casCtx &ctx, const char *pPVName
 
 pvCreateReturn ParamRecordSet::createPV(const casCtx &ctx, const char *pPVName)
 {
-       pvCreateReturn retVal(S_casApp_pvNotFound);
        char *setup;
+       char type;
        char buf1[PARAM_MAX_NAME_LEN];
        char buf2[PARAM_MAX_NAME_LEN];
        char buf3[PARAM_MAX_NAME_LEN];
 
-       strcpy(buf1, "");
-       strcpy(buf2, "");
-       strcpy(buf3, "");
-       if(strncmp(pPVName, "HAD:PS:", strlen("HAD:PS:")) == 0) {
-               sscanf(pPVName, "HAD:PS:[^:]:[^:]:[^:]", buf1, buf2, buf3);
-               if (strcmp(buf3, "") == 0) {
-                       setup = NULL;
-               } else {
-                       setup = buf1;
-                       for (int i = 0 ; i < strlen(setup) ; i++) {
-                               setup[i] = tolower(setup[i]);
-                       }
-               }
-               if(pParam(setup) != NULL) {
-                       retVal = (pvs[numPv++] = new ParamStoreRecord(*this, pParam(setup), pPVName, "String"));
+       pvCreateReturn retVal(S_casApp_pvNotFound);
+
+       for (int i = 0 ; i < numPv ; i++) {
+               if(strcmp(pPVName, pvs[i]->getPVName()) == 0) {
+                       retVal = pvs[i];
                        return retVal;
-               } else {
-                       return S_casApp_pvNotFound;
                }
-       } else if(strncmp(pPVName, "HAD:PG:", strlen("HAD:PG:")) == 0) {
-               sscanf(pPVName, "HAD:PG:[^:]:[^:]:[^:]", buf1, buf2, buf3);
+       }
+
+       if(strncmp(pPVName, "HAD:P", strlen("HAD:P")) == 0) {
+               sscanf(pPVName, "HAD:P%c:[^:]:[^:]:[^:]", &type, buf1, buf2, buf3);
                if (strcmp(buf3, "") == 0) {
                        setup = NULL;
                } else {
                        setup = buf1;
-                       for (int i = 0 ; i < strlen(setup) ; i++) {
+                       for (unsigned int i = 0 ; i < strlen(setup) ; i++) {
                                setup[i] = tolower(setup[i]);
                        }
                }
                if(pParam(setup) != NULL) {
-                       ParamGetRecord *record = new ParamGetRecord(*this, pParam(setup), pPVName, "String Array");
-                       if(record->paramDoesReallyExist()) {
-                               pvs[numPv++] = record;
-                               retVal = record;
-                               return retVal;
-                       } else {
-                               delete record;
-                               return S_casApp_pvNotFound;
+                       switch (type) {
+                               case('I'):
+                                       retVal = (pvs[numPv++] = new ParamIntRecord(*this, pParam(setup), pPVName, "Integer"));
+                                       break;
+                               case('S'):
+                                       retVal = (pvs[numPv++] = new ParamStringRecord(*this, pParam(setup), pPVName, "String"));
+                                       break;
+                               case('F'):
+                                       retVal = (pvs[numPv++] = new ParamFilenameRecord(*this, pParam(setup), pPVName, "Filename"));
+                                       break;
+                               case('B'):
+                                       retVal = (pvs[numPv++] = new ParamBlobRecord(*this, pParam(setup), pPVName, "Binary Large OBject"));
+                                       break;
                        }
+                       return retVal;
                } else {
                        return S_casApp_pvNotFound;
                }

diff --git a/allParam/ca/server/paramRecordSet.h b/allParam/ca/server/paramRecordSet.h
index d1b3662b4c46173e824321d6063926103d287213..cf72ddf97eb2d5588153ed121182a95be2428128 100644 (file)
--- a/allParam/ca/server/paramRecordSet.h
+++ b/allParam/ca/server/paramRecordSet.h
@@ -10,12 +10,12 @@ extern "C" {
 #include "paramRecord.h"
 
 #define MAX_PARAM_SRC 16
-#define PV_COUNT_EST 1024
+#define MAX_NUM_PV 1024
 
 class ParamRecordSet : public caServer {
   private:
     int numPv;
-    ParamRecord *pvs[PV_COUNT_EST];
+    ParamRecord *pvs[MAX_NUM_PV];
 
     int numParamSrc;
     Param *param[MAX_PARAM_SRC];

diff --git a/allParam/ca/server/paramServer.cc b/allParam/ca/server/paramServer.cc
index c0d2a519da8e3c6d348ba1ae7024216c8d8ebeb1..ee7d7e88e602769ef2c8bc0f208deacc49058c43 100644 (file)
--- a/allParam/ca/server/paramServer.cc
+++ b/allParam/ca/server/paramServer.cc
@@ -19,7 +19,7 @@ int main(int argc, char *argv[]) {
 
        ParamRecordSet *cas;
 
-       if (NULL == (cas = new ParamRecordSet(PV_COUNT_EST))) {
+       if (NULL == (cas = new ParamRecordSet(MAX_NUM_PV))) {
                syslog(LOG_ERR, "Cannot allocate memory for the RecordSet. Exiting.\n");
                exit(-1);
        }                                                                       

diff --git a/allParam/ca/server/paramStoreRecord.cc b/allParam/ca/server/paramStoreRecord.cc
deleted file mode 100644 (file)
index e226e3e..0000000
--- a/allParam/ca/server/paramStoreRecord.cc
+++ /dev/null
@@ -1,62 +0,0 @@
-#define _POSIX_C_SOURCE 199509L
-
-extern "C" {
-  #include <string.h>
-}
-
-#include "paramStoreRecord.h"
-
-ParamStoreRecord::ParamStoreRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
-  ParamRecord(cas, p, rn, u)
-{
-       funcTable.installReadFunc("units", &Record::readUnits);
-       funcTable.installReadFunc("status", &Record::readStatus);
-       funcTable.installReadFunc("severity", &Record::readSeverity);
-
-       funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl);
-       funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl);
-       funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr);
-       funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr);
-       funcTable.installReadFunc("precision", &ParamRecord::readPrecision);
-
-       funcTable.installReadFunc("value", &ParamStoreRecord::readValue);
-}
-
-ParamStoreRecord::~ParamStoreRecord()
-{
-}
-
-gddAppFuncTableStatus ParamStoreRecord::readValue(gdd &value)
-{
-       return S_casApp_noSupport;
-}
-
-caStatus ParamStoreRecord::scan()
-{
-       return S_casApp_noSupport;
-}
-
-caStatus ParamStoreRecord::read(const casCtx &ctx, gdd &prototype)
-{
-       return S_casApp_noSupport;
-}
-
-caStatus ParamStoreRecord::write(const casCtx &ctx, gdd &value)
-{
-       fprintf(stderr, "Entered ParamStoreRecord::write\n");
-       caServer *pCAS = this->getCAS();
-
-       aitString stringValue;
-
-       value.getConvert(stringValue);
-
-       char ourValue[PARAM_MAX_VALUE_LEN];
-       strcpy(ourValue, (const char *) stringValue);
-       fprintf(stderr, "ourValue to write: %s\n", ourValue);
-
-       Param_storeString(param, name, idx, ourValue);
-
-       fprintf(stderr, "Leaving ParamStoreRecord::write\n");
-       return S_cas_success;
-}
-

diff --git a/allParam/ca/server/paramStoreRecord.h b/allParam/ca/server/paramStoreRecord.h
deleted file mode 100644 (file)
index 154a871..0000000
--- a/allParam/ca/server/paramStoreRecord.h
+++ /dev/null
@@ -1,22 +0,0 @@
-#ifndef PARAMSTORERECORD_H
-#define PARAMSTORERECORD_H
-
-#include "paramRecord.h"
-
-class ParamStoreRecord : public ParamRecord {
-  private:
-       aitIndex index;
-       gddAppFuncTable<ParamStoreRecord> funcTable;
-
-  public:
-       ParamStoreRecord(caServer&, const Param *, const char *, const char *);
-       ~ParamStoreRecord();
-
-       gddAppFuncTableStatus readValue(gdd &);
-       caStatus scan();
-       caStatus read(const casCtx &, gdd &);
-       caStatus write(const casCtx &, gdd &);
-};
-
-#endif
-

diff --git a/allParam/ca/server/paramStringRecord.cc b/allParam/ca/server/paramStringRecord.cc
new file mode 100644 (file)
index 0000000..438ea07
--- /dev/null
+++ b/allParam/ca/server/paramStringRecord.cc
@@ -0,0 +1,150 @@
+#define _POSIX_C_SOURCE 199509L
+
+extern "C" {
+  #include <string.h>
+}
+
+#include "paramStringRecord.h"
+
+ParamStringRecord::ParamStringRecord(caServer& cas, const Param *p, const char *rn, const char *u) :
+  ParamRecord(cas, p, rn, u)
+{
+       index = 0;
+       funcTable.installReadFunc("units", &Record::readUnits);
+       funcTable.installReadFunc("status", &Record::readStatus);
+       funcTable.installReadFunc("severity", &Record::readSeverity);
+
+       funcTable.installReadFunc("controlLow", &ParamRecord::readLowCtrl);
+       funcTable.installReadFunc("controlHigh", &ParamRecord::readHighCtrl);
+       funcTable.installReadFunc("graphicLow", &ParamRecord::readLopr);
+       funcTable.installReadFunc("graphicHigh", &ParamRecord::readHopr);
+       funcTable.installReadFunc("precision", &ParamRecord::readPrecision);
+
+       funcTable.installReadFunc("value", &ParamStringRecord::readValue);
+}
+
+ParamStringRecord::~ParamStringRecord()
+{
+       for(int k = 0 ; k < index ; k++) {
+               delete ourValue[k];
+       }
+}
+
+aitBool ParamStringRecord::paramDoesReallyExist()
+{
+       aitBool retVal = aitFalse;
+       for (int k = 0 ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               ourValue[k] = new char[PARAM_MAX_VALUE_LEN];
+       }
+
+       int rows;
+
+       if((Param_getStringArray(param, name, idx, PARAM_MAX_ARRAY_LEN, &rows, ourValue) == 0) && (rows > 0)) {
+               index = rows;
+               retVal = aitTrue;
+       }
+
+       for(int k = index ; k < PARAM_MAX_ARRAY_LEN ; k++) {
+               delete ourValue[k];
+       }
+       return retVal;
+}
+
+epicsShareFunc unsigned ParamStringRecord::maxDimension() const
+{
+       return 1u;
+}
+
+epicsShareFunc aitIndex ParamStringRecord::maxBound(unsigned dimension) const
+{
+       aitIndex retVal;
+       if(dimension == 0) {
+               retVal = index;
+       } else {
+               retVal = 1u;
+       }
+       return retVal;
+}
+
+gddAppFuncTableStatus ParamStringRecord::readValue(gdd &value)
+{
+       if(index == 1) {
+               aitString stringValue = new aitString;
+
+               stringValue = ourValue[0];
+
+               value.putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               value.putRef(stringValue);
+       }
+
+       return S_casApp_success;
+}
+
+caStatus ParamStringRecord::scan()
+{
+       caStatus retVal;
+       caServer *pCAS = this->getCAS();
+
+       if(index == 1) {
+               aitString stringValue = new aitString;
+               val = new gddScalar(gddAppType_value, aitEnumString);
+
+               stringValue = ourValue[0];
+
+               val->putConvert(stringValue);
+       } else {
+               aitString *stringValue;
+
+               val = new gddAtomic(gddAppType_value, aitEnumString, 1, index);
+
+               stringValue = new aitString[index];
+               for (int k = 0 ; k < index ; k++) {
+                       stringValue[k] = ourValue[k];
+               }
+
+               ArrayDestructor *pDest = new ArrayDestructor;
+
+               val->putRef(stringValue, pDest);
+       }
+
+       val->setStat(epicsAlarmNone);
+       val->setSevr(epicsSevNone);
+
+       if (this->interest == aitTrue && pCAS != NULL) {
+               casEventMask select(pCAS->valueEventMask|pCAS->logEventMask|pCAS->alarmEventMask);
+               this->postEvent (select, *val);
+       }
+
+       retVal = S_cas_success;
+
+       return retVal;
+}
+
+caStatus ParamStringRecord::read(const casCtx &ctx, gdd &prototype)
+{
+       return ((scan() == S_cas_success) && funcTable.read(*this, prototype));
+}
+
+caStatus ParamStringRecord::write(const casCtx &ctx, gdd &value)
+{
+       caServer *pCAS = this->getCAS();
+
+       aitString stringValue;
+
+       value.getConvert(stringValue);
+
+       char ourValue[PARAM_MAX_VALUE_LEN];
+       strcpy(ourValue, (const char *) stringValue);
+
+       Param_storeString(param, name, idx, ourValue);
+
+       return S_cas_success;
+}
+

diff --git a/allParam/ca/server/paramStringRecord.h b/allParam/ca/server/paramStringRecord.h
new file mode 100644 (file)
index 0000000..83512b6
--- /dev/null
+++ b/allParam/ca/server/paramStringRecord.h
@@ -0,0 +1,26 @@
+#ifndef PARAMSTRINGRECORD_H
+#define PARAMSTRINGRECORD_H
+
+#include "paramRecord.h"
+
+class ParamStringRecord : public ParamRecord {
+  private:
+       aitIndex index;
+       char *ourValue[PARAM_MAX_ARRAY_LEN];
+       gddAppFuncTable<ParamStringRecord> funcTable;
+
+  public:
+       ParamStringRecord(caServer&, const Param *, const char *, const char *);
+       ~ParamStringRecord();
+
+       aitBool paramDoesReallyExist();
+       epicsShareFunc unsigned maxDimension() const;
+       epicsShareFunc aitIndex maxBound(unsigned int) const;
+       gddAppFuncTableStatus readValue(gdd &);
+       caStatus scan();
+       caStatus read(const casCtx &, gdd &);
+       caStatus write(const casCtx &, gdd &);
+};
+
+#endif
+