diff --git a/documentation/RELEASE_NOTES.html b/documentation/RELEASE_NOTES.html
index 9cd899604..4ec06ada0 100644
--- a/documentation/RELEASE_NOTES.html
+++ b/documentation/RELEASE_NOTES.html
@@ -15,6 +15,14 @@ EPICS Base 3.15.0.x releases are not intended for use in production systems.</p>
 <h2 align="center">Changes between 3.14.x and 3.15.0.x</h2>
 <!-- Insert new items immediately below here ... -->
 
+<h3>Attributes of Non-VAL Fields</h3>
+
+<p>Non-VAL fields now report meaningful information for precision, units,
+graphic limits, control limits, and alarm limits instead of simply using
+PREC, EGU, HOPR, LOPR, DRVL, DRVH, HIHI, HIGH, LOW, and LOLO. All delay
+fields have precision 2 and units "s". Input fields like A-L of the calc record
+read these information from the corresponding INPn link if possible.
+
 <h3>
 Changes to epicsVersion.h</h3>
 
diff --git a/src/std/rec/aSubRecord.c b/src/std/rec/aSubRecord.c
index 24447cee3..1c033b3ba 100644
--- a/src/std/rec/aSubRecord.c
+++ b/src/std/rec/aSubRecord.c
@@ -53,14 +53,14 @@ static long special(DBADDR *, int);
 static long cvt_dbaddr(DBADDR *);
 static long get_array_info(DBADDR *, long *, long *);
 static long put_array_info(DBADDR *, long );
-#define get_units          NULL
+static long get_units(DBADDR *, char *);
 static long get_precision(DBADDR *, long *);
 #define get_enum_str       NULL
 #define get_enum_strs      NULL
 #define put_enum_str       NULL
-#define get_graphic_double NULL
-#define get_control_double NULL
-#define get_alarm_double   NULL
+static long get_graphic_double(DBADDR *, struct dbr_grDouble *);
+static long get_control_double(DBADDR *, struct dbr_ctrlDouble *);
+static long get_alarm_double(DBADDR *, struct dbr_alDouble *);
 
 rset aSubRSET = {
     RSETNUMBER,
@@ -330,15 +330,116 @@ static long fetch_values(aSubRecord *prec)
     return 0;
 }
 
-static long get_precision(DBADDR *paddr, long *precision)
+#define indexof(field) aSubRecord##field
+
+static long get_inlinkNumber(int fieldIndex) {
+    if (fieldIndex >= indexof(A) && fieldIndex <= indexof(U))
+        return fieldIndex - indexof(A);
+    return -1;
+}
+
+static long get_outlinkNumber(int fieldIndex) {
+    if (fieldIndex >= indexof(VALA) && fieldIndex <= indexof(VALU))
+        return fieldIndex - indexof(VALA);
+    return -1;
+}
+
+static long get_units(DBADDR *paddr, char *units)
 {
     aSubRecord *prec = (aSubRecord *)paddr->precord;
+    int linkNumber;
 
-    *precision = prec->prec;
-    recGblGetPrec(paddr, precision);
+    linkNumber = get_inlinkNumber(dbGetFieldIndex(paddr));
+    if (linkNumber >= 0) {
+        dbGetUnits(&prec->inpa + linkNumber, units, DB_UNITS_SIZE);
+        return 0;
+    }
+    linkNumber = get_outlinkNumber(dbGetFieldIndex(paddr));
+    if (linkNumber >= 0) {
+        dbGetUnits(&prec->outa + linkNumber, units, DB_UNITS_SIZE);
+    }
     return 0;
 }
 
+static long get_precision(DBADDR *paddr, long *pprecision)
+{
+    aSubRecord *prec = (aSubRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
+    short precision;
+
+    *pprecision = prec->prec;
+    linkNumber = get_inlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        if (dbGetPrecision(&prec->inpa + linkNumber, &precision) == 0)
+            *pprecision = precision;
+        return 0;
+    } 
+    linkNumber = get_outlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        if (dbGetPrecision(&prec->outa + linkNumber, &precision) == 0)
+            *pprecision = precision;
+        return 0;
+    } 
+    recGblGetPrec(paddr, pprecision);
+    return 0;
+}
+
+static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
+{
+    aSubRecord *prec = (aSubRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
+    
+    linkNumber = get_inlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        dbGetGraphicLimits(&prec->inpa + linkNumber,
+            &pgd->lower_disp_limit,
+            &pgd->upper_disp_limit);
+        return 0;
+    }
+    linkNumber = get_outlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        dbGetGraphicLimits(&prec->outa + linkNumber,
+            &pgd->lower_disp_limit,
+            &pgd->upper_disp_limit);
+    }
+    return 0;
+}
+
+static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
+{
+    recGblGetControlDouble(paddr,pcd);
+    return 0;
+}
+
+static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
+{
+    aSubRecord *prec = (aSubRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
+
+    linkNumber = get_inlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        dbGetAlarmLimits(&prec->inpa + linkNumber,
+            &pad->lower_alarm_limit,
+            &pad->lower_warning_limit,
+            &pad->upper_warning_limit,
+            &pad->upper_alarm_limit);
+        return 0;
+    }
+    linkNumber = get_outlinkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        dbGetAlarmLimits(&prec->outa + linkNumber,
+            &pad->lower_alarm_limit,
+            &pad->lower_warning_limit,
+            &pad->upper_warning_limit,
+            &pad->upper_alarm_limit);
+        return 0;
+    }
+    recGblGetAlarmDouble(paddr, pad);
+    return 0;
+}
 
 static void monitor(aSubRecord *prec)
 {
diff --git a/src/std/rec/aaiRecord.c b/src/std/rec/aaiRecord.c
index 5c88791c4..428916de9 100644
--- a/src/std/rec/aaiRecord.c
+++ b/src/std/rec/aaiRecord.c
@@ -109,7 +109,7 @@ static long init_record(aaiRecord *prec, int pass)
         recGblRecordError(S_dev_noDSET, prec, "aai: init_record");
         return S_dev_noDSET;
     }
-    
+
     if (pass == 0) {
         if (prec->nelm <= 0)
             prec->nelm = 1;
@@ -120,12 +120,12 @@ static long init_record(aaiRecord *prec, int pass)
         } else {
             prec->nord = 0;
         }
-            
+
         /* we must call pdset->init_record in pass 0
            because it may set prec->bptr which must
            not change after links are established before pass 1
         */
-           
+
         if (pdset->init_record) {
             /* init_record may set the bptr to point to the data */
             if ((status = pdset->init_record(prec)))
@@ -141,7 +141,7 @@ static long init_record(aaiRecord *prec, int pass)
     
     /* SIML must be a CONSTANT or a PV_LINK or a DB_LINK */
     if (prec->siml.type == CONSTANT) {
-	recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm);
+        recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm);
     }
     
     /* must have read_aai function defined */
@@ -210,11 +210,20 @@ static long put_array_info(DBADDR *paddr, long nNew)
     return 0;
 }
 
+#define indexof(field) aaiRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     aaiRecord *prec = (aaiRecord *)paddr->precord;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            if (prec->ftvl == DBF_STRING || prec->ftvl == DBF_ENUM)
+                break; 
+        case indexof(HOPR):
+        case indexof(LOPR):
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
@@ -223,8 +232,8 @@ static long get_precision(DBADDR *paddr, long *precision)
     aaiRecord *prec = (aaiRecord *)paddr->precord;
 
     *precision = prec->prec;
-    if (paddr->pfield == prec->bptr) return 0;
-    recGblGetPrec(paddr, precision);
+    if (dbGetFieldIndex(paddr) != indexof(VAL))
+        recGblGetPrec(paddr, precision);
     return 0;
 }
 
@@ -232,10 +241,18 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     aaiRecord *prec = (aaiRecord *)paddr->precord;
 
-    if (paddr->pfield == prec->bptr) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr, pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        case indexof(NORD):
+            pgd->upper_disp_limit = prec->nelm;
+            pgd->lower_disp_limit = 0;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr, pgd);
+    }
     return 0;
 }
 
@@ -243,10 +260,18 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     aaiRecord *prec = (aaiRecord *)paddr->precord;
 
-    if (paddr->pfield == prec->bptr) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr, pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        case indexof(NORD):
+            pcd->upper_ctrl_limit = prec->nelm;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        default:
+            recGblGetControlDouble(paddr, pcd);
+    }
     return 0;
 }
 
diff --git a/src/std/rec/aaoRecord.c b/src/std/rec/aaoRecord.c
index 695f8e1b1..46c837310 100644
--- a/src/std/rec/aaoRecord.c
+++ b/src/std/rec/aaoRecord.c
@@ -109,7 +109,7 @@ static long init_record(aaoRecord *prec, int pass)
         recGblRecordError(S_dev_noDSET, prec, "aao: init_record");
         return S_dev_noDSET;
     }
-    
+
     if (pass == 0) {
         if (prec->nelm <= 0)
             prec->nelm = 1;
@@ -120,12 +120,12 @@ static long init_record(aaoRecord *prec, int pass)
         } else {
             prec->nord = 0;
         }
-            
+
         /* we must call pdset->init_record in pass 0
            because it may set prec->bptr which must
            not change after links are established before pass 1
         */
-           
+
         if (pdset->init_record) {
             /* init_record may set the bptr to point to the data */
             if ((status = pdset->init_record(prec)))
@@ -138,12 +138,12 @@ static long init_record(aaoRecord *prec, int pass)
         }
         return 0;
     }
-    
+
     /* SIML must be a CONSTANT or a PV_LINK or a DB_LINK */
     if (prec->siml.type == CONSTANT) {
-	recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm);
+        recGblInitConstantLink(&prec->siml,DBF_USHORT,&prec->simm);
     }
-    
+
     /* must have write_aao function defined */
     if (pdset->number < 5 || pdset->write_aao == NULL) {
         recGblRecordError(S_dev_missingSup, prec, "aao: init_record");
@@ -210,11 +210,20 @@ static long put_array_info(DBADDR *paddr, long nNew)
     return 0;
 }
 
+#define indexof(field) aaoRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     aaoRecord *prec = (aaoRecord *)paddr->precord;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            if (prec->ftvl == DBF_STRING || prec->ftvl == DBF_ENUM)
+                break; 
+        case indexof(HOPR):
+        case indexof(LOPR):
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
@@ -223,8 +232,8 @@ static long get_precision(DBADDR *paddr, long *precision)
     aaoRecord *prec = (aaoRecord *)paddr->precord;
 
     *precision = prec->prec;
-    if (paddr->pfield == (void *)prec->bptr) return 0;
-    recGblGetPrec(paddr, precision);
+    if (dbGetFieldIndex(paddr) != indexof(VAL))
+        recGblGetPrec(paddr, precision);
     return 0;
 }
 
@@ -232,10 +241,18 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     aaoRecord *prec = (aaoRecord *)paddr->precord;
 
-    if (paddr->pfield == prec->bptr) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        case indexof(NORD):
+            pgd->upper_disp_limit = prec->nelm;
+            pgd->lower_disp_limit = 0;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr, pgd);
+    }
     return 0;
 }
 
@@ -243,10 +260,18 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     aaoRecord *prec = (aaoRecord *)paddr->precord;
 
-    if(paddr->pfield == prec->bptr){
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        case indexof(NORD):
+            pcd->upper_ctrl_limit = prec->nelm;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        default:
+            recGblGetControlDouble(paddr, pcd);
+    }
     return 0;
 }
 
diff --git a/src/std/rec/aiRecord.c b/src/std/rec/aiRecord.c
index 343d62126..158456e88 100644
--- a/src/std/rec/aiRecord.c
+++ b/src/std/rec/aiRecord.c
@@ -217,11 +217,22 @@ static long special(DBADDR *paddr,int after)
     }
 }
 
+#define indexof(field) aiRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     aiRecord	*prec=(aiRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        switch (dbGetFieldIndex(paddr)) {
+            case indexof(ASLO):
+            case indexof(AOFF):
+            case indexof(SMOO):
+                break;
+            default:
+                strncpy(units,prec->egu,DB_UNITS_SIZE);
+        }
+    }
     return(0);
 }
 
@@ -230,7 +241,7 @@ static long get_precision(DBADDR *paddr, long *precision)
     aiRecord	*prec=(aiRecord *)paddr->precord;
 
     *precision = prec->prec;
-    if(paddr->pfield == (void *)&prec->val) return(0);
+    if (dbGetFieldIndex(paddr) == indexof(VAL)) return(0);
     recGblGetPrec(paddr,precision);
     return(0);
 }
@@ -238,43 +249,54 @@ static long get_precision(DBADDR *paddr, long *precision)
 static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     aiRecord	*prec=(aiRecord *)paddr->precord;
-    int		fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == aiRecordVAL
-    || fieldIndex == aiRecordHIHI
-    || fieldIndex == aiRecordHIGH
-    || fieldIndex == aiRecordLOW
-    || fieldIndex == aiRecordLOLO
-    || fieldIndex == aiRecordHOPR
-    || fieldIndex == aiRecordLOPR) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+        case indexof(SVAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
 static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
 {
     aiRecord	*prec=(aiRecord *)paddr->precord;
-    int		fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == aiRecordVAL
-    || fieldIndex == aiRecordHIHI
-    || fieldIndex == aiRecordHIGH
-    || fieldIndex == aiRecordLOW
-    || fieldIndex == aiRecordLOLO) {
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+        case indexof(SVAL):
+	    pcd->upper_ctrl_limit = prec->hopr;
+	    pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
 
 static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad)
 {
     aiRecord	*prec=(aiRecord *)paddr->precord;
-    int		fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == aiRecordVAL) {
+    if (dbGetFieldIndex(paddr) == indexof(VAL)) {
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
         pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
diff --git a/src/std/rec/aoRecord.c b/src/std/rec/aoRecord.c
index 5f8436ab2..5b77b607e 100644
--- a/src/std/rec/aoRecord.c
+++ b/src/std/rec/aoRecord.c
@@ -276,11 +276,21 @@ static long special(DBADDR *paddr, int after)
     }
 }
 
+#define indexof(field) aoRecord##field
+
 static long get_units(DBADDR * paddr,char *units)
 {
     aoRecord	*prec=(aoRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        switch (dbGetFieldIndex(paddr)) {
+            case indexof(ASLO):
+            case indexof(AOFF):
+                break;
+            default:
+                strncpy(units,prec->egu,DB_UNITS_SIZE);
+        }
+    }
     return(0);
 }
 
@@ -289,10 +299,14 @@ static long get_precision(DBADDR *paddr,long *precision)
     aoRecord	*prec=(aoRecord *)paddr->precord;
 
     *precision = prec->prec;
-    if(paddr->pfield == (void *)&prec->val
-    || paddr->pfield == (void *)&prec->oval
-    || paddr->pfield == (void *)&prec->pval) return(0);
-    recGblGetPrec(paddr,precision);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(OVAL):
+        case indexof(PVAL):
+            break;
+        default:
+            recGblGetPrec(paddr,precision);
+    }
     return(0);
 }
 
@@ -300,16 +314,24 @@ static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     aoRecord	*prec=(aoRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo
-    || paddr->pfield==(void *)&prec->oval
-    || paddr->pfield==(void *)&prec->pval){
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(OVAL):
+        case indexof(PVAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+        case indexof(IVOV):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
@@ -317,23 +339,30 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     aoRecord	*prec=(aoRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo
-    || paddr->pfield==(void *)&prec->oval
-    || paddr->pfield==(void *)&prec->pval){
-        pcd->upper_ctrl_limit = prec->drvh;
-        pcd->lower_ctrl_limit = prec->drvl;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(OVAL):
+        case indexof(PVAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pcd->upper_ctrl_limit = prec->drvh;
+            pcd->lower_ctrl_limit = prec->drvl;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
 static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
 {
     aoRecord	*prec=(aoRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val){
+    if(dbGetFieldIndex(paddr) == indexof(VAL)){
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
         pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
diff --git a/src/std/rec/boRecord.c b/src/std/rec/boRecord.c
index 5248bd661..e0e361c6f 100644
--- a/src/std/rec/boRecord.c
+++ b/src/std/rec/boRecord.c
@@ -51,13 +51,13 @@ static long process(boRecord *);
 #define cvt_dbaddr NULL
 #define get_array_info NULL
 #define put_array_info NULL
-#define get_units NULL
+static long get_units(DBADDR *, char *);
 static long get_precision(DBADDR *, long *);
 static long get_enum_str(DBADDR *, char *);
 static long get_enum_strs(DBADDR *, struct dbr_enumStrs *);
 static long put_enum_str(DBADDR *, char *);
 #define get_graphic_double NULL
-#define get_control_double NULL
+static long get_control_double(DBADDR *, struct dbr_ctrlDouble *);
 #define get_alarm_double NULL
 
 rset boRSET={
@@ -268,12 +268,31 @@ static long process(boRecord *prec)
 	return(status);
 }
 
+#define indexof(field) boRecord##field
+
+static long get_units(DBADDR *paddr, char *units)
+{
+    if(dbGetFieldIndex(paddr) == indexof(HIGH))
+        strcpy(units, "s");
+    return(0);
+}
+
 static long get_precision(DBADDR *paddr, long *precision)
 {
-    boRecord	*prec=(boRecord *)paddr->precord;
+    if(dbGetFieldIndex(paddr) == indexof(HIGH))
+        *precision = 2;
+    else
+        recGblGetPrec(paddr,precision);
+    return(0);
+}
 
-    if(paddr->pfield == (void *)&prec->high) *precision=2;
-    else recGblGetPrec(paddr,precision);
+static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
+{
+    if(dbGetFieldIndex(paddr) == indexof(HIGH)) {
+        pcd->lower_ctrl_limit = 0.0;
+        pcd->upper_ctrl_limit = 10.0;
+    } else
+        recGblGetControlDouble(paddr,pcd);
     return(0);
 }
 
@@ -285,7 +304,7 @@ static long get_enum_str(DBADDR *paddr, char *pstring)
 
 
     index = dbGetFieldIndex(paddr);
-    if(index!=boRecordVAL) {
+    if(index!=indexof(VAL)) {
 	strcpy(pstring,"Illegal_Value");
     } else if(*pfield==0) {
 	strncpy(pstring,prec->znam,sizeof(prec->znam));
diff --git a/src/std/rec/calcRecord.c b/src/std/rec/calcRecord.c
index 722ce0698..85e66f538 100644
--- a/src/std/rec/calcRecord.c
+++ b/src/std/rec/calcRecord.c
@@ -54,28 +54,28 @@ static long get_precision(DBADDR *paddr, long *precision);
 #define get_enum_strs NULL
 #define put_enum_str NULL
 static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd);
-static long get_ctrl_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd);
+static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd);
 static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad);
 
 rset calcRSET={
-	RSETNUMBER,
-	report,
-	initialize,
-	init_record,
-	process,
-	special,
-	get_value,
-	cvt_dbaddr,
-	get_array_info,
-	put_array_info,
-	get_units,
-	get_precision,
-	get_enum_str,
-	get_enum_strs,
-	put_enum_str,
-	get_graphic_double,
-	get_ctrl_double,
-	get_alarm_double
+    RSETNUMBER,
+    report,
+    initialize,
+    init_record,
+    process,
+    special,
+    get_value,
+    cvt_dbaddr,
+    get_array_info,
+    put_array_info,
+    get_units,
+    get_precision,
+    get_enum_str,
+    get_enum_strs,
+    put_enum_str,
+    get_graphic_double,
+    get_control_double,
+    get_alarm_double
 };
 epicsExportAddress(rset, calcRSET);
 
@@ -96,15 +96,15 @@ static long init_record(calcRecord *prec, int pass)
     plink = &prec->inpa;
     pvalue = &prec->a;
     for (i = 0; i < CALCPERFORM_NARGS; i++, plink++, pvalue++) {
-	if (plink->type == CONSTANT) {
-	    recGblInitConstantLink(plink, DBF_DOUBLE, pvalue);
-	}
+        if (plink->type == CONSTANT) {
+            recGblInitConstantLink(plink, DBF_DOUBLE, pvalue);
+        }
     }
     if (postfix(prec->calc, prec->rpcl, &error_number)) {
-	recGblRecordError(S_db_badField, (void *)prec,
-			  "calc: init_record: Illegal CALC field");
-	errlogPrintf("%s.CALC: %s in expression \"%s\"\n",
-		     prec->name, calcErrorStr(error_number), prec->calc);
+        recGblRecordError(S_db_badField, (void *)prec,
+                          "calc: init_record: Illegal CALC field");
+        errlogPrintf("%s.CALC: %s in expression \"%s\"\n",
+                     prec->name, calcErrorStr(error_number), prec->calc);
     }
     return 0;
 }
@@ -112,10 +112,11 @@ static long init_record(calcRecord *prec, int pass)
 static long process(calcRecord *prec)
 {
     prec->pact = TRUE;
-    if (fetch_values(prec)==0) {
-	if (calcPerform(&prec->a, &prec->val, prec->rpcl)) {
-	    recGblSetSevr(prec, CALC_ALARM, INVALID_ALARM);
-	} else prec->udf = isnan(prec->val);
+    if (fetch_values(prec) == 0) {
+        if (calcPerform(&prec->a, &prec->val, prec->rpcl)) {
+            recGblSetSevr(prec, CALC_ALARM, INVALID_ALARM);
+        } else
+            prec->udf = isnan(prec->val);
     }
     recGblGetTimeStamp(prec);
     /* check for alarms */
@@ -135,24 +136,41 @@ static long special(DBADDR *paddr, int after)
 
     if (!after) return 0;
     if (paddr->special == SPC_CALC) {
-	if (postfix(prec->calc, prec->rpcl, &error_number)) {
-	    recGblRecordError(S_db_badField, (void *)prec,
-			      "calc: Illegal CALC field");
-	    errlogPrintf("%s.CALC: %s in expression \"%s\"\n",
-			 prec->name, calcErrorStr(error_number), prec->calc);
-	    return S_db_badField;
-	}
-	return 0;
+        if (postfix(prec->calc, prec->rpcl, &error_number)) {
+            recGblRecordError(S_db_badField, (void *)prec,
+                              "calc: Illegal CALC field");
+            errlogPrintf("%s.CALC: %s in expression \"%s\"\n",
+                         prec->name, calcErrorStr(error_number), prec->calc);
+            return S_db_badField;
+        }
+        return 0;
     }
     recGblDbaddrError(S_db_badChoice, paddr, "calc::special - bad special value!");
     return S_db_badChoice;
 }
 
+#define indexof(field) calcRecord##field
+
+static long get_linkNumber(int fieldIndex) {
+    if (fieldIndex >= indexof(A) && fieldIndex <= indexof(L))
+        return fieldIndex - indexof(A);
+    if (fieldIndex >= indexof(LA) && fieldIndex <= indexof(LL))
+        return fieldIndex - indexof(LA);
+    return -1;
+}
+
 static long get_units(DBADDR *paddr, char *units)
 {
     calcRecord *prec = (calcRecord *)paddr->precord;
+    int linkNumber;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        linkNumber = get_linkNumber(dbGetFieldIndex(paddr));
+        if (linkNumber >= 0)
+            dbGetUnits(&prec->inpa + linkNumber, units, DB_UNITS_SIZE);
+        else
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
@@ -160,86 +178,97 @@ static long get_precision(DBADDR *paddr, long *pprecision)
 {
     calcRecord *prec = (calcRecord *)paddr->precord;
     int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
     *pprecision = prec->prec;
-
-    if (fieldIndex != calcRecordVAL)
-	recGblGetPrec(paddr, pprecision);
-
+    if (fieldIndex == indexof(VAL)) {
+        return 0;
+    }
+    linkNumber = get_linkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        short precision;
+        if (dbGetPrecision(&prec->inpa + linkNumber, &precision) == 0)
+            *pprecision = precision;
+        else
+            *pprecision = 15;
+    } else
+        recGblGetPrec(paddr, pprecision);
     return 0;
 }
 
 static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     calcRecord *prec = (calcRecord *)paddr->precord;
-
-    if (paddr->pfield == (void *)&prec->val ||
-	paddr->pfield == (void *)&prec->hihi ||
-	paddr->pfield == (void *)&prec->high ||
-	paddr->pfield == (void *)&prec->low ||
-	paddr->pfield == (void *)&prec->lolo) {
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return 0;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
+    
+    switch (fieldIndex) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pgd->lower_disp_limit = prec->lopr;
+            pgd->upper_disp_limit = prec->hopr;
+            break;
+        default:
+            linkNumber = get_linkNumber(fieldIndex);
+            if (linkNumber >= 0) {
+                dbGetGraphicLimits(&prec->inpa + linkNumber,
+                    &pgd->lower_disp_limit,
+                    &pgd->upper_disp_limit);
+            } else
+                recGblGetGraphicDouble(paddr,pgd);
     }
-
-    if (paddr->pfield >= (void *)&prec->a &&
-	paddr->pfield <= (void *)&prec->l) {
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return 0;
-    }
-    if (paddr->pfield >= (void *)&prec->la &&
-	paddr->pfield <= (void *)&prec->ll) {
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return 0;
-    }
-    recGblGetGraphicDouble(paddr, pgd);
     return 0;
 }
 
-static long get_ctrl_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
+static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     calcRecord *prec = (calcRecord *)paddr->precord;
-
-    if (paddr->pfield == (void *)&prec->val ||
-	paddr->pfield == (void *)&prec->hihi ||
-	paddr->pfield == (void *)&prec->high ||
-	paddr->pfield == (void *)&prec->low ||
-	paddr->pfield == (void *)&prec->lolo) {
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return 0;
+    
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pcd->lower_ctrl_limit = prec->lopr;
+            pcd->upper_ctrl_limit = prec->hopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
     }
-
-    if (paddr->pfield >= (void *)&prec->a &&
-	paddr->pfield <= (void *)&prec->l) {
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return 0;
-    }
-    if (paddr->pfield >= (void *)&prec->la &&
-	paddr->pfield <= (void *)&prec->ll) {
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return 0;
-    }
-    recGblGetControlDouble(paddr, pcd);
     return 0;
 }
 
 static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
 {
     calcRecord *prec = (calcRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
-    if (paddr->pfield == (void *)&prec->val) {
-        pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
-        pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
-        pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
+    if (fieldIndex == indexof(VAL)) {
         pad->lower_alarm_limit = prec->llsv ? prec->lolo : epicsNAN;
+        pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
+        pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
+        pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
     } else {
-	recGblGetAlarmDouble(paddr, pad);
+        linkNumber = get_linkNumber(fieldIndex);
+        if (linkNumber >= 0) {
+            dbGetAlarmLimits(&prec->inpa + linkNumber,
+                &pad->lower_alarm_limit,
+                &pad->lower_warning_limit,
+                &pad->upper_warning_limit,
+                &pad->upper_alarm_limit);
+        } else
+            recGblGetAlarmDouble(paddr, pad);
     }
     return 0;
 }
@@ -311,34 +340,34 @@ static void monitor(calcRecord *prec)
     delta = prec->mlst - prec->val;
     if (delta < 0.0) delta = -delta;
     if (delta > prec->mdel) {
-	/* post events for value change */
-	monitor_mask |= DBE_VALUE;
-	/* update last value monitored */
-	prec->mlst = prec->val;
+        /* post events for value change */
+        monitor_mask |= DBE_VALUE;
+        /* update last value monitored */
+        prec->mlst = prec->val;
     }
     /* check for archive change */
     delta = prec->alst - prec->val;
     if (delta < 0.0) delta = -delta;
     if (delta > prec->adel) {
-	/* post events on value field for archive change */
-	monitor_mask |= DBE_LOG;
-	/* update last archive value monitored */
-	prec->alst = prec->val;
+        /* post events on value field for archive change */
+        monitor_mask |= DBE_LOG;
+        /* update last archive value monitored */
+        prec->alst = prec->val;
     }
 
     /* send out monitors connected to the value field */
     if (monitor_mask){
-	db_post_events(prec, &prec->val, monitor_mask);
+        db_post_events(prec, &prec->val, monitor_mask);
     }
     /* check all input fields for changes*/
     pnew = &prec->a;
     pprev = &prec->la;
     for (i = 0; i < CALCPERFORM_NARGS; i++, pnew++, pprev++) {
-	if (*pnew != *pprev ||
-	    monitor_mask & DBE_ALARM) {
-	    db_post_events(prec, pnew, monitor_mask | DBE_VALUE | DBE_LOG);
-	    *pprev = *pnew;
-	}
+        if (*pnew != *pprev ||
+            monitor_mask & DBE_ALARM) {
+            db_post_events(prec, pnew, monitor_mask | DBE_VALUE | DBE_LOG);
+            *pprev = *pnew;
+        }
     }
     return;
 }
@@ -353,10 +382,10 @@ static int fetch_values(calcRecord *prec)
     plink = &prec->inpa;
     pvalue = &prec->a;
     for(i = 0; i < CALCPERFORM_NARGS; i++, plink++, pvalue++) {
-	int newStatus;
+        int newStatus;
 
-	newStatus = dbGetLink(plink, DBR_DOUBLE, pvalue, 0, 0);
-	if (status == 0) status = newStatus;
+        newStatus = dbGetLink(plink, DBR_DOUBLE, pvalue, 0, 0);
+        if (status == 0) status = newStatus;
     }
     return status;
 }
diff --git a/src/std/rec/calcoutRecord.c b/src/std/rec/calcoutRecord.c
index 062580c76..1e7432465 100644
--- a/src/std/rec/calcoutRecord.c
+++ b/src/std/rec/calcoutRecord.c
@@ -59,7 +59,7 @@ static long get_precision(DBADDR *, long *);
 #define get_enum_strs NULL
 #define put_enum_str NULL
 static long get_graphic_double(DBADDR *, struct dbr_grDouble *);
-static long get_ctrl_double(DBADDR *, struct dbr_ctrlDouble *);
+static long get_control_double(DBADDR *, struct dbr_ctrlDouble *);
 static long get_alarm_double(DBADDR *, struct dbr_alDouble *);
 
 rset calcoutRSET = {
@@ -79,7 +79,7 @@ rset calcoutRSET = {
     get_enum_strs,
     put_enum_str,
     get_graphic_double,
-    get_ctrl_double,
+    get_control_double,
     get_alarm_double
 };
 epicsExportAddress(rset, calcoutRSET);
@@ -363,11 +363,34 @@ static long special(DBADDR *paddr, int after)
     }
 }
 
+#define indexof(field) calcoutRecord##field
+
+static long get_linkNumber(int fieldIndex) {
+    if (fieldIndex >= indexof(A) && fieldIndex <= indexof(L))
+        return fieldIndex - indexof(A);
+    if (fieldIndex >= indexof(LA) && fieldIndex <= indexof(LL))
+        return fieldIndex - indexof(LA);
+    return -1;
+}
+
 static long get_units(DBADDR *paddr, char *units)
 {
     calcoutRecord *prec = (calcoutRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
+    if(fieldIndex == indexof(ODLY)) {
+        strcpy(units, "s");
+        return 0;
+    }
+
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        linkNumber = get_linkNumber(dbGetFieldIndex(paddr));
+        if (linkNumber >= 0)
+            dbGetUnits(&prec->inpa + linkNumber, units, DB_UNITS_SIZE);
+        else
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
@@ -375,86 +398,109 @@ static long get_precision(DBADDR *paddr, long *pprecision)
 {
     calcoutRecord *prec = (calcoutRecord *)paddr->precord;
     int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
+    if(fieldIndex == indexof(ODLY)) {
+        *pprecision = 2;
+        return 0;
+    }
     *pprecision = prec->prec;
-
-    if (fieldIndex != calcoutRecordVAL)
+    if (fieldIndex == indexof(VAL)) {
+        return 0;
+    }
+    linkNumber = get_linkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        short precision;
+        if (dbGetPrecision(&prec->inpa + linkNumber, &precision) == 0)
+            *pprecision = precision;
+        else
+            *pprecision = 15;
+    } else
         recGblGetPrec(paddr, pprecision);
- 
     return 0;
 }
 
 static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     calcoutRecord *prec = (calcoutRecord *)paddr->precord;
-
-    if (paddr->pfield == (void *)&prec->val ||
-        paddr->pfield == (void *)&prec->hihi ||
-        paddr->pfield == (void *)&prec->high ||
-        paddr->pfield == (void *)&prec->low ||
-        paddr->pfield == (void *)&prec->lolo) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-        return 0;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
+    
+    switch (fieldIndex) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pgd->lower_disp_limit = prec->lopr;
+            pgd->upper_disp_limit = prec->hopr;
+            break;
+        case indexof(ODLY):
+            recGblGetGraphicDouble(paddr,pgd);
+            pgd->lower_disp_limit = 0.0;
+            break;       
+        default:
+            linkNumber = get_linkNumber(fieldIndex);
+            if (linkNumber >= 0) {
+                dbGetGraphicLimits(&prec->inpa + linkNumber,
+                    &pgd->lower_disp_limit,
+                    &pgd->upper_disp_limit);
+            } else
+                recGblGetGraphicDouble(paddr,pgd);
     }
-
-    if (paddr->pfield >= (void *)&prec->a &&
-        paddr->pfield <= (void *)&prec->l) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-        return 0;
-    }
-    if (paddr->pfield >= (void *)&prec->la &&
-        paddr->pfield <= (void *)&prec->ll) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-        return 0;
-    }
-    recGblGetGraphicDouble(paddr, pgd);
     return 0;
 }
 
-static long get_ctrl_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
+static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     calcoutRecord *prec = (calcoutRecord *)paddr->precord;
-
-    if (paddr->pfield == (void *)&prec->val ||
-        paddr->pfield == (void *)&prec->hihi ||
-        paddr->pfield == (void *)&prec->high ||
-        paddr->pfield == (void *)&prec->low ||
-        paddr->pfield == (void *)&prec->lolo) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-        return 0;
+    
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pcd->lower_ctrl_limit = prec->lopr;
+            pcd->upper_ctrl_limit = prec->hopr;
+            break;
+        case indexof(ODLY):
+            pcd->lower_ctrl_limit = 0.0;
+            pcd->upper_ctrl_limit = 10.0;
+            break;       
+        default:
+            recGblGetControlDouble(paddr,pcd);
     }
-
-    if (paddr->pfield >= (void *)&prec->a &&
-        paddr->pfield <= (void *)&prec->l) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-        return 0;
-    }
-    if (paddr->pfield >= (void *)&prec->la &&
-        paddr->pfield <= (void *)&prec->ll) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-        return 0;
-    }
-    recGblGetControlDouble(paddr, pcd);
     return 0;
 }
 
 static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
 {
     calcoutRecord *prec = (calcoutRecord *)paddr->precord;
+    int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
-    if (paddr->pfield == (void *)&prec->val) {
+    if (fieldIndex == indexof(VAL)) {
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
         pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
         pad->lower_alarm_limit = prec->llsv ? prec->lolo : epicsNAN;
     } else {
-        recGblGetAlarmDouble(paddr, pad);
+        linkNumber = get_linkNumber(fieldIndex);
+        if (linkNumber >= 0) {
+            dbGetAlarmLimits(&prec->inpa + linkNumber,
+                &pad->lower_alarm_limit,
+                &pad->lower_warning_limit,
+                &pad->upper_warning_limit,
+                &pad->upper_alarm_limit);
+        } else
+            recGblGetAlarmDouble(paddr, pad);
     }
     return 0;
 }
diff --git a/src/std/rec/compressRecord.c b/src/std/rec/compressRecord.c
index 2879852d8..46966dba4 100644
--- a/src/std/rec/compressRecord.c
+++ b/src/std/rec/compressRecord.c
@@ -400,11 +400,16 @@ static long put_array_info(DBADDR *paddr, long nNew)
     return(0);
 }
 
+#define indexof(field) compressRecord##field
+
 static long get_units(DBADDR *paddr,char *units)
 {
     compressRecord *prec=(compressRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE
+    || dbGetFieldIndex(paddr) == indexof(VAL)) {
+        strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return(0);
 }
 
@@ -413,7 +418,7 @@ static long get_precision(DBADDR *paddr, long *precision)
     compressRecord	*prec=(compressRecord *)paddr->precord;
 
     *precision = prec->prec;
-    if(paddr->pfield == (void *)prec->bptr) return(0);
+    if(dbGetFieldIndex(paddr) == indexof(BPTR)) return(0);
     recGblGetPrec(paddr,precision);
     return(0);
 }
@@ -422,12 +427,16 @@ static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     compressRecord *prec=(compressRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)prec->bptr
-    || paddr->pfield==(void *)&prec->ihil
-    || paddr->pfield==(void *)&prec->ilil){
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(BPTR):
+        case indexof(IHIL):
+        case indexof(ILIL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
@@ -435,11 +444,15 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     compressRecord *prec=(compressRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)prec->bptr
-    || paddr->pfield==(void *)&prec->ihil
-    || paddr->pfield==(void *)&prec->ilil){
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(BPTR):
+        case indexof(IHIL):
+        case indexof(ILIL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
diff --git a/src/std/rec/dfanoutRecord.c b/src/std/rec/dfanoutRecord.c
index 672c1cccd..4628ab7a6 100644
--- a/src/std/rec/dfanoutRecord.c
+++ b/src/std/rec/dfanoutRecord.c
@@ -126,73 +126,72 @@ static long process(dfanoutRecord *prec)
     return(status);
 }
 
+#define indexof(field) dfanoutRecord##field
+
 static long get_units(DBADDR *paddr,char *units)
 {
     dfanoutRecord *prec=(dfanoutRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return(0);
 }
 
 static long get_precision(DBADDR *paddr,long *precision)
 {
     dfanoutRecord *prec=(dfanoutRecord *)paddr->precord;
-    int   fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == dfanoutRecordVAL
-    || fieldIndex == dfanoutRecordHIHI
-    || fieldIndex == dfanoutRecordHIGH
-    || fieldIndex == dfanoutRecordLOW
-    || fieldIndex == dfanoutRecordLOLO
-    || fieldIndex == dfanoutRecordHOPR
-    || fieldIndex == dfanoutRecordLOPR) {
-        *precision = prec->prec;
-    } else {
-        recGblGetPrec(paddr,precision);
-    }
+    *precision = prec->prec;
+    if (dbGetFieldIndex(paddr) == indexof(VAL)) return(0);
+    recGblGetPrec(paddr,precision);
     return(0);
 }
 
-static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble	*pgd)
+static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     dfanoutRecord *prec=(dfanoutRecord *)paddr->precord;
-    int   fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == dfanoutRecordVAL
-    || fieldIndex == dfanoutRecordHIHI
-    || fieldIndex == dfanoutRecordHIGH
-    || fieldIndex == dfanoutRecordLOW
-    || fieldIndex == dfanoutRecordLOLO
-    || fieldIndex == dfanoutRecordHOPR
-    || fieldIndex == dfanoutRecordLOPR) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
 static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
 {
     dfanoutRecord *prec=(dfanoutRecord *)paddr->precord;
-    int   fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == dfanoutRecordVAL
-    || fieldIndex == dfanoutRecordHIHI
-    || fieldIndex == dfanoutRecordHIGH
-    || fieldIndex == dfanoutRecordLOW
-    || fieldIndex == dfanoutRecordLOLO) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+	    pcd->upper_ctrl_limit = prec->hopr;
+	    pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
 static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad)
 {
     dfanoutRecord *prec=(dfanoutRecord *)paddr->precord;
-    int   fieldIndex = dbGetFieldIndex(paddr);
-
     
-    if(fieldIndex == dfanoutRecordVAL) {
+    if(dbGetFieldIndex(paddr) == indexof(VAL)) {
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
         pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
diff --git a/src/std/rec/histogramRecord.c b/src/std/rec/histogramRecord.c
index e78be26c5..a01dfb2ab 100644
--- a/src/std/rec/histogramRecord.c
+++ b/src/std/rec/histogramRecord.c
@@ -52,7 +52,7 @@ static long special(DBADDR *, int);
 static long cvt_dbaddr(DBADDR *);
 static long get_array_info(DBADDR *, long *, long *);
 #define  put_array_info NULL
-#define get_units NULL
+static long get_units(DBADDR *, char *);
 static long get_precision(DBADDR *paddr,long *precision);
 #define get_enum_str NULL
 #define get_enum_strs NULL
@@ -386,42 +386,71 @@ static long readValue(histogramRecord *prec)
         return(status);
 }
 
+#define indexof(field) histogramRecord##field
+
+static long get_units(DBADDR *paddr, char *units)
+{
+    if (dbGetFieldIndex(paddr) == indexof(SDEL)) {
+        strcpy(units,"s");
+    }
+    /* We should have EGU for other DOUBLE values or probably get it from input link SVL */
+    return(0);
+}
+
 static long get_precision(DBADDR *paddr,long *precision)
 {
     histogramRecord *prec=(histogramRecord *)paddr->precord;
-    int     fieldIndex = dbGetFieldIndex(paddr);
 
-    *precision = prec->prec;
-    if(fieldIndex == histogramRecordULIM
-    || fieldIndex == histogramRecordLLIM
-    || fieldIndex == histogramRecordSDEL
-    || fieldIndex == histogramRecordSGNL
-    || fieldIndex == histogramRecordSVAL
-    || fieldIndex == histogramRecordWDTH) {
-       *precision = prec->prec;
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(ULIM):
+        case indexof(LLIM):
+        case indexof(SGNL):
+        case indexof(SVAL):
+        case indexof(WDTH):
+            *precision = prec->prec;
+            break;
+        case indexof(SDEL):
+            *precision = 2;
+            break;
+        default:
+            recGblGetPrec(paddr,precision);
     }
-    recGblGetPrec(paddr,precision);
     return(0);
 }
+
 static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     histogramRecord *prec=(histogramRecord *)paddr->precord;
-    int     fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == histogramRecordBPTR){
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(BPTR):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        case indexof(WDTH):
+            pgd->upper_disp_limit = prec->ulim-prec->llim;
+            pgd->lower_disp_limit = 0.0;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
 {
     histogramRecord *prec=(histogramRecord *)paddr->precord;
-    int     fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == histogramRecordBPTR){
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(BPTR):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        case indexof(WDTH):
+            pcd->upper_ctrl_limit = prec->ulim-prec->llim;
+            pcd->lower_ctrl_limit = 0.0;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
diff --git a/src/std/rec/longinRecord.c b/src/std/rec/longinRecord.c
index 011b6c882..b41bbe506 100644
--- a/src/std/rec/longinRecord.c
+++ b/src/std/rec/longinRecord.c
@@ -158,11 +158,15 @@ static long process(longinRecord *prec)
 	return(status);
 }
 
+#define indexof(field) longinRecord##field
+
 static long get_units(DBADDR *paddr,char *units)
 {
     longinRecord *prec=(longinRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_LONG) {
+        strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return(0);
 }
 
@@ -171,14 +175,22 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     longinRecord *prec=(longinRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo){
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+        case indexof(SVAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
@@ -186,14 +198,22 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     longinRecord *prec=(longinRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo){
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+        case indexof(SVAL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
 
@@ -201,7 +221,7 @@ static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble	*pad)
 {
     longinRecord *prec=(longinRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val){
+    if(dbGetFieldIndex(paddr) == indexof(VAL)){
          pad->upper_alarm_limit = prec->hihi;
          pad->upper_warning_limit = prec->high;
          pad->lower_warning_limit = prec->low;
diff --git a/src/std/rec/longoutRecord.c b/src/std/rec/longoutRecord.c
index d7d53d44f..ba1fa34b9 100644
--- a/src/std/rec/longoutRecord.c
+++ b/src/std/rec/longoutRecord.c
@@ -190,58 +190,73 @@ static long process(longoutRecord *prec)
 	return(status);
 }
 
+#define indexof(field) longoutRecord##field
+
 static long get_units(DBADDR *paddr,char *units)
 {
     longoutRecord *prec=(longoutRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_LONG) {
+        strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return(0);
 }
 
 static long get_graphic_double(DBADDR *paddr,struct dbr_grDouble *pgd)
 {
     longoutRecord *prec=(longoutRecord *)paddr->precord;
-    int fieldIndex = dbGetFieldIndex(paddr);
-
-    if(fieldIndex == longoutRecordVAL
-    || fieldIndex == longoutRecordHIHI
-    || fieldIndex == longoutRecordHIGH
-    || fieldIndex == longoutRecordLOW
-    || fieldIndex == longoutRecordLOLO) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else recGblGetGraphicDouble(paddr,pgd);
+    
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr,pgd);
+    }
     return(0);
 }
 
-
 static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
 {
     longoutRecord *prec=(longoutRecord *)paddr->precord;
-    int fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == longoutRecordVAL
-    || fieldIndex == longoutRecordHIHI
-    || fieldIndex == longoutRecordHIGH
-    || fieldIndex == longoutRecordLOW
-    || fieldIndex == longoutRecordLOLO) {
-        /* do not change pre drvh/drvl behavior */
-        if(prec->drvh > prec->drvl) {
-            pcd->upper_ctrl_limit = prec->drvh;
-            pcd->lower_ctrl_limit = prec->drvl;
-        } else {
-            pcd->upper_ctrl_limit = prec->hopr;
-            pcd->lower_ctrl_limit = prec->lopr;
-        }
-    } else recGblGetControlDouble(paddr,pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            /* do not change pre drvh/drvl behavior */
+            if(prec->drvh > prec->drvl) {
+                pcd->upper_ctrl_limit = prec->drvh;
+                pcd->lower_ctrl_limit = prec->drvl;
+            } else {
+                pcd->upper_ctrl_limit = prec->hopr;
+                pcd->lower_ctrl_limit = prec->lopr;
+            }
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
+    }
     return(0);
 }
+
 static long get_alarm_double(DBADDR *paddr,struct dbr_alDouble *pad)
 {
     longoutRecord    *prec=(longoutRecord *)paddr->precord;
-    int     fieldIndex = dbGetFieldIndex(paddr);
 
-    if(fieldIndex == longoutRecordVAL) {
+    if(dbGetFieldIndex(paddr) == indexof(VAL)) {
          pad->upper_alarm_limit = prec->hihi;
          pad->upper_warning_limit = prec->high;
          pad->lower_warning_limit = prec->low;
diff --git a/src/std/rec/selRecord.c b/src/std/rec/selRecord.c
index 6bc43c227..514b42d82 100644
--- a/src/std/rec/selRecord.c
+++ b/src/std/rec/selRecord.c
@@ -132,11 +132,15 @@ static long process(selRecord *prec)
 }
 
 
+#define indexof(field) selRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     selRecord	*prec=(selRecord *)paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return(0);
 }
 
@@ -166,56 +170,68 @@ static long get_precision(DBADDR *paddr, long *precision)
 static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     selRecord	*prec=(selRecord *)paddr->precord;
-
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo){
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return(0);
+    int index = dbGetFieldIndex(paddr);
+    
+    switch (index) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+#ifdef __GNUC__
+        case indexof(A) ... indexof(L):
+        case indexof(LA) ... indexof(LL):
+            break;
+        default:
+#else
+            break;
+        default:
+            if((index >= indexof(A) && index <= indexof(L))
+            || (index >= indexof(LA) && index <= indexof(LL)))
+                break;
+#endif
+            recGblGetGraphicDouble(paddr,pgd);
+            return(0);
     }
-
-    if(paddr->pfield>=(void *)&prec->a && paddr->pfield<=(void *)&prec->l){
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return(0);
-    }
-    if(paddr->pfield>=(void *)&prec->la && paddr->pfield<=(void *)&prec->ll){
-	pgd->upper_disp_limit = prec->hopr;
-	pgd->lower_disp_limit = prec->lopr;
-	return(0);
-    }
-    recGblGetGraphicDouble(paddr,pgd);
+    pgd->upper_disp_limit = prec->hopr;
+    pgd->lower_disp_limit = prec->lopr;
     return(0);
 }
 
 static long get_control_double(struct dbAddr *paddr, struct dbr_ctrlDouble *pcd)
 {
     selRecord	*prec=(selRecord *)paddr->precord;
-
-    if(paddr->pfield==(void *)&prec->val
-    || paddr->pfield==(void *)&prec->hihi
-    || paddr->pfield==(void *)&prec->high
-    || paddr->pfield==(void *)&prec->low
-    || paddr->pfield==(void *)&prec->lolo){
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return(0);
+    int index = dbGetFieldIndex(paddr);
+    
+    switch (index) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+#ifdef __GNUC__
+        case indexof(A) ... indexof(L):
+        case indexof(LA) ... indexof(LL):
+            break;
+        default:
+#else
+            break;
+        default:
+            if((index >= indexof(A) && index <= indexof(L))
+            || (index >= indexof(LA) && index <= indexof(LL)))
+                break;
+#endif
+            recGblGetControlDouble(paddr,pcd);
+            return(0);
     }
-
-    if(paddr->pfield>=(void *)&prec->a && paddr->pfield<=(void *)&prec->l){
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return(0);
-    }
-    if(paddr->pfield>=(void *)&prec->la && paddr->pfield<=(void *)&prec->ll){
-	pcd->upper_ctrl_limit = prec->hopr;
-	pcd->lower_ctrl_limit = prec->lopr;
-	return(0);
-    }
-    recGblGetControlDouble(paddr,pcd);
+    pcd->upper_ctrl_limit = prec->hopr;
+    pcd->lower_ctrl_limit = prec->lopr;
     return(0);
 }
 
@@ -223,7 +239,7 @@ static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
 {
     selRecord	*prec=(selRecord *)paddr->precord;
 
-    if(paddr->pfield==(void *)&prec->val ){
+    if(dbGetFieldIndex(paddr) == indexof(VAL)) {
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
         pad->upper_warning_limit = prec->hsv ? prec->high : epicsNAN;
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
diff --git a/src/std/rec/seqRecord.c b/src/std/rec/seqRecord.c
index 67e2518d8..0394497f7 100644
--- a/src/std/rec/seqRecord.c
+++ b/src/std/rec/seqRecord.c
@@ -6,7 +6,7 @@
 * EPICS BASE is distributed subject to a Software License Agreement found
 * in file LICENSE that is included with this distribution. 
 \*************************************************************************/
-
+ 
 /*
  * $Revision-Id$
  *
@@ -39,34 +39,48 @@
 
 int	seqRecDebug = 0;
 
-/* Create RSET - Record Support Entry Table*/
-static long init_record(seqRecord *prec, int pass);
-static long process(seqRecord *prec);
 static int processNextLink(seqRecord *prec);
 static long asyncFinish(seqRecord *prec);
 static void processCallback(CALLBACK *arg);
-static long get_precision(dbAddr *paddr, long *pprecision);
+
+/* Create RSET - Record Support Entry Table*/
+#define report NULL
+#define initialize NULL
+static long init_record(seqRecord *prec, int pass);
+static long process(seqRecord *prec);
+#define special NULL
+#define get_value NULL
+#define cvt_dbaddr NULL
+#define get_array_info NULL
+#define put_array_info NULL
+static long get_units(DBADDR *, char *);
+static long get_precision(dbAddr *paddr, long *);
+#define get_enum_str NULL
+#define get_enum_strs NULL
+#define put_enum_str NULL
+static long get_graphic_double(DBADDR *, struct dbr_grDouble *);
+static long get_control_double(DBADDR *, struct dbr_ctrlDouble *);
+static long get_alarm_double(DBADDR *, struct dbr_alDouble *);
 
 rset seqRSET={
 	RSETNUMBER,
-	NULL,			/* report */
-	NULL,			/* initialize */
+	report,			/* report */
+	initialize,		/* initialize */
 	init_record,		/* init_record */
 	process,		/* process */
-	NULL,			/* special */
-	NULL,			/* get_value */
-	NULL,			/* cvt_dbaddr */
-	NULL,			/* get_array_info */
-	NULL,			/* put_array_info */
-	NULL,			/* get_units */
+	special,		/* special */
+	get_value,		/* get_value */
+	cvt_dbaddr,		/* cvt_dbaddr */
+	get_array_info,		/* get_array_info */
+	put_array_info,		/* put_array_info */
+	get_units,		/* get_units */
 	get_precision,		/* get_precision */
-	NULL,			/* get_enum_str */
-	NULL,			/* get_enum_strs */
-	NULL,			/* put_enum_str */
-	NULL,			/* get_graphic_double */
-	NULL,			/* get_control_double */
-	NULL 			/* get_alarm_double */
-
+	get_enum_str,		/* get_enum_str */
+	get_enum_strs,		/* get_enum_strs */
+	put_enum_str,		/* put_enum_str */
+	get_graphic_double,	/* get_graphic_double */
+	get_control_double,	/* get_control_double */
+	get_alarm_double 	/* get_alarm_double */
 };
 epicsExportAddress(rset,seqRSET);
 
@@ -406,15 +420,91 @@ static void processCallback(CALLBACK *arg)
  * Return the precision value from PREC
  *
  *****************************************************************************/
+#define indexof(field) seqRecord##field
+#define get_dol(prec, fieldOffset) \
+    &((linkDesc*)&prec->dly1)[fieldOffset>>2].dol
+
+static long get_units(DBADDR *paddr, char *units)
+{
+    seqRecord	*prec = (seqRecord *) paddr->precord;
+    int fieldOffset = dbGetFieldIndex(paddr) - indexof(DLY1);
+
+    if (fieldOffset >= 0) switch (fieldOffset & 2) {
+        case 0: /* DLYn */
+            strcpy(units, "s");
+            break;
+        case 2: /* DOn */
+            dbGetUnits(get_dol(prec, fieldOffset),
+                units, DB_UNITS_SIZE);
+    }
+    return(0);
+}
+
 static long get_precision(dbAddr *paddr, long *pprecision)
 {
     seqRecord	*prec = (seqRecord *) paddr->precord;
+    int fieldOffset = dbGetFieldIndex(paddr) - indexof(DLY1);
+    short precision;
 
+    if (fieldOffset >= 0) switch (fieldOffset & 2) {
+        case 0: /* DLYn */
+            *pprecision = 2;
+            return 0;
+        case 2: /* DOn */
+            if (dbGetPrecision(get_dol(prec, fieldOffset),
+                &precision) == 0) {
+                *pprecision = precision;
+                return 0;
+            }
+    }
     *pprecision = prec->prec;
-
-    if(paddr->pfield < (void *)&prec->val)
-	return 0;			/* Field is NOT in dbCommon */
-
-    recGblGetPrec(paddr, pprecision);	/* Field is in dbCommon */
+    recGblGetPrec(paddr, pprecision);
     return 0;
 }
+
+static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
+{
+    seqRecord	*prec = (seqRecord *) paddr->precord;
+    int fieldOffset = dbGetFieldIndex(paddr) - indexof(DLY1);
+    
+    if (fieldOffset >= 0) switch (fieldOffset & 2) {
+        case 0: /* DLYn */
+            pgd->lower_disp_limit = 0.0;
+            pgd->lower_disp_limit = 10.0;
+            return 0;
+        case 2: /* DOn */
+            dbGetGraphicLimits(get_dol(prec, fieldOffset),
+                &pgd->lower_disp_limit,
+                &pgd->upper_disp_limit);
+            return 0;
+    }
+    recGblGetGraphicDouble(paddr,pgd);
+    return 0;
+}    
+    
+static long get_control_double(DBADDR *paddr,struct dbr_ctrlDouble *pcd)
+{
+    int fieldOffset = dbGetFieldIndex(paddr) - indexof(DLY1);
+
+    recGblGetControlDouble(paddr,pcd);
+    if (fieldOffset >= 0 && (fieldOffset & 2) == 0) /* DLYn */
+        pcd->lower_ctrl_limit = 0.0;
+    return(0);
+}
+
+static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
+{
+    seqRecord	*prec = (seqRecord *) paddr->precord;
+    int fieldOffset = dbGetFieldIndex(paddr) - indexof(DLY1);
+
+    if (fieldOffset >= 0 && (fieldOffset & 2) == 2)  /* DOn */
+        dbGetAlarmLimits(get_dol(prec, fieldOffset),
+            &pad->lower_alarm_limit,
+            &pad->lower_warning_limit,
+            &pad->upper_warning_limit,
+            &pad->upper_alarm_limit);
+    else
+        recGblGetAlarmDouble(paddr, pad);
+    return 0;
+}
+
diff --git a/src/std/rec/subArrayRecord.c b/src/std/rec/subArrayRecord.c
index dc18a6ad3..f40f5ac0c 100644
--- a/src/std/rec/subArrayRecord.c
+++ b/src/std/rec/subArrayRecord.c
@@ -200,25 +200,30 @@ static long put_array_info(DBADDR *paddr, long nNew)
     return 0;
 }
 
+#define indexof(field) subArrayRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     subArrayRecord *prec = (subArrayRecord *) paddr->precord;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
-
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            if (prec->ftvl == DBF_STRING || prec->ftvl == DBF_ENUM)
+                break; 
+        case indexof(HOPR):
+        case indexof(LOPR):
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
 static long get_precision(DBADDR *paddr, long *precision)
 {
     subArrayRecord *prec = (subArrayRecord *) paddr->precord;
-    int fieldIndex = dbGetFieldIndex(paddr);
 
     *precision = prec->prec;
-
-    if (fieldIndex != subArrayRecordVAL)
+    if (dbGetFieldIndex(paddr) != indexof(VAL))
         recGblGetPrec(paddr, precision);
-
     return 0;
 }
 
@@ -227,25 +232,29 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
     subArrayRecord *prec = (subArrayRecord *) paddr->precord;
 
     switch (dbGetFieldIndex(paddr)) {
-    case subArrayRecordVAL:
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-        break;
-
-    case subArrayRecordINDX:
-        pgd->upper_disp_limit = prec->malm - 1;
-        pgd->lower_disp_limit = 0;
-        break;
-
-    case subArrayRecordNELM:
-        pgd->upper_disp_limit = prec->malm;
-        pgd->lower_disp_limit = 1;
-        break;
-
-    default:
-        recGblGetGraphicDouble(paddr, pgd);
+        case indexof(VAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        case indexof(INDX):
+            pgd->upper_disp_limit = prec->malm - 1;
+            pgd->lower_disp_limit = 0;
+            break;
+        case indexof(NELM):
+            pgd->upper_disp_limit = prec->malm;
+            pgd->lower_disp_limit = 0;
+            break;
+        case indexof(NORD):
+            pgd->upper_disp_limit = prec->malm;
+            pgd->lower_disp_limit = 0;
+            break;
+         case indexof(BUSY):
+            pgd->upper_disp_limit = 1;
+            pgd->lower_disp_limit = 0;
+            break;
+       default:
+            recGblGetGraphicDouble(paddr, pgd);
     }
-
     return 0;
 }
 
@@ -254,25 +263,29 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
     subArrayRecord *prec = (subArrayRecord *) paddr->precord;
 
     switch (dbGetFieldIndex(paddr)) {
-    case subArrayRecordVAL:
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-        break;
-
-    case subArrayRecordINDX:
-        pcd->upper_ctrl_limit = prec->malm - 1;
-        pcd->lower_ctrl_limit = 0;
-        break;
-
-    case subArrayRecordNELM:
-        pcd->upper_ctrl_limit = prec->malm;
-        pcd->lower_ctrl_limit = 1;
-        break;
-
-    default:
-        recGblGetControlDouble(paddr, pcd);
+        case indexof(VAL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        case indexof(INDX):
+            pcd->upper_ctrl_limit = prec->malm - 1;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        case indexof(NELM):
+            pcd->upper_ctrl_limit = prec->malm;
+            pcd->lower_ctrl_limit = 1;
+            break;
+        case indexof(NORD):
+            pcd->upper_ctrl_limit = prec->malm;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        case indexof(BUSY):
+            pcd->upper_ctrl_limit = 1;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        default:
+            recGblGetControlDouble(paddr, pcd);
     }
-
     return 0;
 }
 
diff --git a/src/std/rec/subRecord.c b/src/std/rec/subRecord.c
index c07de5692..3b7632ecc 100644
--- a/src/std/rec/subRecord.c
+++ b/src/std/rec/subRecord.c
@@ -191,54 +191,79 @@ static long special(DBADDR *paddr, int after)
     return S_db_BadSub;
 }
 
+#define indexof(field) subRecord##field
+
+static long get_linkNumber(int fieldIndex) {
+    if (fieldIndex >= indexof(A) && fieldIndex <= indexof(L))
+        return fieldIndex - indexof(A);
+    if (fieldIndex >= indexof(LA) && fieldIndex <= indexof(LL))
+        return fieldIndex - indexof(LA);
+    return -1;
+}
+
 static long get_units(DBADDR *paddr, char *units)
 {
     subRecord *prec = (subRecord *)paddr->precord;
+    int linkNumber;
 
-    strncpy(units, prec->egu, DB_UNITS_SIZE);
+    if(paddr->pfldDes->field_type == DBF_DOUBLE) {
+        linkNumber = get_linkNumber(dbGetFieldIndex(paddr));
+        if (linkNumber >= 0)
+            dbGetUnits(&prec->inpa + linkNumber, units, DB_UNITS_SIZE);
+        else
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
-static long get_precision(DBADDR *paddr, long *precision)
+static long get_precision(DBADDR *paddr, long *pprecision)
 {
     subRecord *prec = (subRecord *)paddr->precord;
     int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
-    *precision = prec->prec;
-    if (fieldIndex != subRecordVAL)
-        recGblGetPrec(paddr, precision);
-
+    *pprecision = prec->prec;
+    if (fieldIndex == indexof(VAL)) {
+	return 0;
+    }
+    linkNumber = get_linkNumber(fieldIndex);
+    if (linkNumber >= 0) {
+        short precision;
+        if (dbGetPrecision(&prec->inpa + linkNumber, &precision) == 0)
+            *pprecision = precision;
+        else
+            *pprecision = 15;
+    } else
+        recGblGetPrec(paddr, pprecision);
     return 0;
 }
 
-
 static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     subRecord *prec = (subRecord *)paddr->precord;
     int fieldIndex = dbGetFieldIndex(paddr);
-
+    int linkNumber;
+    
     switch (fieldIndex) {
-    case subRecordVAL:
-    case subRecordHIHI:     case subRecordHIGH:
-    case subRecordLOW:      case subRecordLOLO:
-    case subRecordA:        case subRecordB:
-    case subRecordC:        case subRecordD:
-    case subRecordE:        case subRecordF:
-    case subRecordG:        case subRecordH:
-    case subRecordI:        case subRecordJ:
-    case subRecordK:        case subRecordL:
-    case subRecordLA:       case subRecordLB:
-    case subRecordLC:       case subRecordLD:
-    case subRecordLE:       case subRecordLF:
-    case subRecordLG:       case subRecordLH:
-    case subRecordLI:       case subRecordLJ:
-    case subRecordLK:       case subRecordLL:
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-        break;
-
-    default:
-        recGblGetGraphicDouble(paddr, pgd);
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pgd->lower_disp_limit = prec->lopr;
+            pgd->upper_disp_limit = prec->hopr;
+            break;
+        default:
+            linkNumber = get_linkNumber(fieldIndex);
+            if (linkNumber >= 0) {
+                dbGetGraphicLimits(&prec->inpa + linkNumber,
+                    &pgd->lower_disp_limit,
+                    &pgd->upper_disp_limit);
+            } else
+                recGblGetGraphicDouble(paddr,pgd);
     }
     return 0;
 }
@@ -246,24 +271,21 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     subRecord *prec = (subRecord *)paddr->precord;
-    int fieldIndex = dbGetFieldIndex(paddr);
-
-    switch (fieldIndex) {
-    case subRecordVAL:
-    case subRecordHIHI:     case subRecordHIGH:
-    case subRecordLOW:      case subRecordLOLO:
-    case subRecordA:        case subRecordB:
-    case subRecordC:        case subRecordD:
-    case subRecordE:        case subRecordF:
-    case subRecordG:        case subRecordH:
-    case subRecordI:        case subRecordJ:
-    case subRecordK:        case subRecordL:
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-        break;
-
-    default:
-        recGblGetControlDouble(paddr, pcd);
+    
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+        case indexof(HIHI):
+        case indexof(HIGH):
+        case indexof(LOW):
+        case indexof(LOLO):
+        case indexof(LALM):
+        case indexof(ALST):
+        case indexof(MLST):
+            pcd->lower_ctrl_limit = prec->lopr;
+            pcd->upper_ctrl_limit = prec->hopr;
+            break;
+        default:
+            recGblGetControlDouble(paddr,pcd);
     }
     return 0;
 }
@@ -272,6 +294,7 @@ static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
 {
     subRecord *prec = (subRecord *)paddr->precord;
     int fieldIndex = dbGetFieldIndex(paddr);
+    int linkNumber;
 
     if (fieldIndex == subRecordVAL) {
         pad->upper_alarm_limit = prec->hhsv ? prec->hihi : epicsNAN;
@@ -279,7 +302,15 @@ static long get_alarm_double(DBADDR *paddr, struct dbr_alDouble *pad)
         pad->lower_warning_limit = prec->lsv ? prec->low : epicsNAN;
         pad->lower_alarm_limit = prec->llsv ? prec->lolo : epicsNAN;
     } else {
-        recGblGetAlarmDouble(paddr, pad);
+        linkNumber = get_linkNumber(fieldIndex);
+        if (linkNumber >= 0) {
+            dbGetAlarmLimits(&prec->inpa + linkNumber,
+                &pad->lower_alarm_limit,
+                &pad->lower_warning_limit,
+                &pad->upper_warning_limit,
+                &pad->upper_alarm_limit);
+        } else
+	    recGblGetAlarmDouble(paddr, pad);
     }
     return 0;
 }
diff --git a/src/std/rec/waveformRecord.c b/src/std/rec/waveformRecord.c
index 6cd7a05b4..95219a70a 100644
--- a/src/std/rec/waveformRecord.c
+++ b/src/std/rec/waveformRecord.c
@@ -194,25 +194,30 @@ static long put_array_info(DBADDR *paddr, long nNew)
     return 0;
 }
 
+#define indexof(field) waveformRecord##field
+
 static long get_units(DBADDR *paddr, char *units)
 {
     waveformRecord *prec = (waveformRecord *) paddr->precord;
 
-    strncpy(units,prec->egu,DB_UNITS_SIZE);
-
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            if (prec->ftvl == DBF_STRING || prec->ftvl == DBF_ENUM)
+                break; 
+        case indexof(HOPR):
+        case indexof(LOPR):
+            strncpy(units,prec->egu,DB_UNITS_SIZE);
+    }
     return 0;
 }
 
 static long get_precision(DBADDR *paddr, long *precision)
 {
     waveformRecord *prec = (waveformRecord *) paddr->precord;
-    int fieldIndex = dbGetFieldIndex(paddr);
 
     *precision = prec->prec;
-
-    if (fieldIndex != waveformRecordVAL)
+    if (dbGetFieldIndex(paddr) != indexof(VAL))
         recGblGetPrec(paddr, precision);
-
     return 0;
 }
 
@@ -220,11 +225,22 @@ static long get_graphic_double(DBADDR *paddr, struct dbr_grDouble *pgd)
 {
     waveformRecord *prec = (waveformRecord *) paddr->precord;
 
-    if (dbGetFieldIndex(paddr) == waveformRecordVAL) {
-        pgd->upper_disp_limit = prec->hopr;
-        pgd->lower_disp_limit = prec->lopr;
-    } else
-        recGblGetGraphicDouble(paddr, pgd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pgd->upper_disp_limit = prec->hopr;
+            pgd->lower_disp_limit = prec->lopr;
+            break;
+        case indexof(BUSY):
+            pgd->upper_disp_limit = 1;
+            pgd->lower_disp_limit = 0;
+            break;
+        case indexof(NORD):
+            pgd->upper_disp_limit = prec->nelm;
+            pgd->lower_disp_limit = 0;
+            break;
+        default:
+            recGblGetGraphicDouble(paddr, pgd);
+    }
     return 0;
 }
 
@@ -232,11 +248,22 @@ static long get_control_double(DBADDR *paddr, struct dbr_ctrlDouble *pcd)
 {
     waveformRecord *prec = (waveformRecord *) paddr->precord;
 
-    if (dbGetFieldIndex(paddr) == waveformRecordVAL) {
-        pcd->upper_ctrl_limit = prec->hopr;
-        pcd->lower_ctrl_limit = prec->lopr;
-    } else
-        recGblGetControlDouble(paddr, pcd);
+    switch (dbGetFieldIndex(paddr)) {
+        case indexof(VAL):
+            pcd->upper_ctrl_limit = prec->hopr;
+            pcd->lower_ctrl_limit = prec->lopr;
+            break;
+        case indexof(BUSY):
+            pcd->upper_ctrl_limit = 1;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        case indexof(NORD):
+            pcd->upper_ctrl_limit = prec->nelm;
+            pcd->lower_ctrl_limit = 0;
+            break;
+        default:
+            recGblGetControlDouble(paddr, pcd);
+    }
     return 0;
 }