Merge ~dirk.zimoch/epics-base:CleanupWhitespace into ~epics-core/epics-base/+git/epics-base:7.0

[Dirk Zimoch]

Cleanup whitespace

This is purely cosmetic:
1. There was a mess with tab character usage. Indention with spaces and tabs was mixed inconsistently sometimes with obviously different assumptions on tab width, even in the same file. This results in irregular, hard to read indents. Please stop using tabs in source code.
2. Clean up of space at end of line.

Can we please have a coding style guide?

[Andrew Johnson (anj)]

I am concerned that merging this as is will make it difficult to merge commits made on the 3.15 branch up into the 7.0 branch. I just spent quite a few hours doing just that, without having to contend with a large number of lines that had white-space changes as well as code a documentation changes. Git's recursive merge strategy supports the flag -Xignore-space-change which ought to help, but for several of the conflicts I just had to fix git didn't make any attempt to do a 3-way merge at all, because there were file renames involved as well as large content changes, and it didn't recognize these as such.

If you don't think this will be a problem, please try checking out this branch and doing a git merge of the 3.15 branch into it. I got 63 lines of output with 31 CONFLICT lines when I did that last night to the 7.0 branch.

Don't get me wrong I would like us to have a unified source format and coding style (which of course would follow *my* code-formatting preferences, n'est-pas?), but since we have 2 branches to support I don't think this is the best way to achieve that (nor would doing this in the 3.15 branch and merging up be much better). This approach is fine for the PVA submodules because they don't have any older branches to support though.

We might be able to minimize the churn if we add a .indent.pro file and reformat both branches identically, then merge up with no code changes, but I'd want to try that out before committing to the approach. Are GNU indent and BSD indent (as provided on MacOS) fully compatible? I would also only do this once we have minimized the number of outstanding merge & pull requests.

[Andrew Johnson (anj)]

Sorry, I withdraw my concerns about this particular merge request. I had only looked at your commit messages and not at the actual diff when I wrote the previous commit – my bad. I see now that you are only proposing changes here to the modules/ca tree, which is unlikely to suffer from the problems I was concerned about. The libcom and database modules would be a different matter though.

review: Approve

[Dirk Zimoch (dirk.zimoch)]

Hi Andrew,
I had already started on an .indent.pro file, but so far found no setting that matches the majority of EPICS base coding styles (or let's better say: habits). But I am still trying...
I can also do the same for the 3.15 branch, so that the two look the same. I hope git is ok with two changes that do the same thing and then merging them?

And I was hoping not to limit the fixes on the modules/ca tree only. Let me check if I forgot something... But I have to admid, the ca tree was the worst.

[Dirk Zimoch (dirk.zimoch)]

Ok, it seems I have missed files, headers actually. I forgot to seach for them everywhere. Had happen in the PV modules as well, but I had updated those yesterday already.
Tabs are in database/src/ioc/dbStatic/dbBase.h only but spaces on line end are in 225 more header files and multiple empty lines at file end in 51 headers.

[Dirk Zimoch (dirk.zimoch)]

In the list of changed files above, I see many changes in modules/database and modules/libcom as well. But in the diff below I only find modules/ca. How that? When downloading the diff, the changes are there. Is there something wrong with the diff view of launchpad?

[Dirk Zimoch (dirk.zimoch)]

What is your favorite coding style, mine looks like this:

int function(int a, int b)
{
    int i;

    for (i=a; i<b; i++)
    {
        if (i<10)
            doThis(i);
        else
        {
            switch (i)
            {
                case 42:
                    doSomethingSpecial();
                    break;
                default:
                {
                    doTheNormalThing(i, a, b);
                    break;
                }
            }
        }
    }
    return 0;
}

[Ralph Lange (ralph-lange)]

I don't think it's a good idea to change practically all lines in base to achieve a common coding style. It pretty much renders SCM's blame functionality useless, and is a matter of personal preference anyway.

Here's a nice list of the most common styles for braces and indentation:
http://astyle.sourceforge.net/astyle.html#_Brace_Style_Options

I don't think agreement will be easy.

[Ralph Lange (ralph-lange)]

To answer your question:
I prefer K&R style (attached braces), and would usually have spaces around binary operators like = and < in your example.

[Dirk Zimoch (dirk.zimoch)]

'git blame -w' to ignore whitespace change?

[Dirk Zimoch (dirk.zimoch)]

I just found that I used 'find' the wrong way and there are many more files. I will try again ...

[Ben Franksen (bfrk)]

I propose to shortcut discussion about coding style by agreeing on the status quo. A long time ago I figured out the indent options needed to reproduce the style preferred in EPICS base over the last decade or so:

indent -bap -bl -bli0 -br -brs -c41 -ce -cd41 -ci0 -cli0 -di1 -i4 -ip4 -nbc -ncdb -ncs -nfc1 -nfca -nlp -npcs -npsl -npro -nv -sob -ss -st -ts0

[mdavidsaver (mdavidsaver)]

> 'git blame -w' to ignore whitespace change?

To my mind this is the important point. I'm fairly open about accepting the occasional reformatting which 'git diff --ignore-all-space' renders as empty. And I would be fairly closed to reformatting which doesn't. So eg. no moving brackets between lines. Also, this isn't something to be done frequently. (once per decade is ok)

This change is almost empty. 'git diff --ignore-all-space' still shows the removal of blank lines at the end of files. I'm not so bother this time, although I don't see much point to doing this in future.

As far as style rules. I'm not so strict on aspects other than indentation. There my first rule is to be consistent. With indentation of 4 spaces being a very strong preference (where allowed).

Beyond that, I'm not so concerned beyond a small bias towards schemes which qtcreator can apply automatically. In short, this is not an area where I want to spend much time.

So this change is acceptable to me, provided it doesn't complicate upmerge by whatever version of Git Andrew has these days.

I'm marking this "Needs Fixing" since Dirk has indicated he has more work to do.

review: Needs Fixing

[Dirk Zimoch (dirk.zimoch)]

I will push a new version which produces empty 'git diff --ignore-all-space' output and which is re-based to the laterst 7.0. I can continue resasing it until Andrew is done with the pending merges. I am also willing to do the same for the 3.15 branch, so that future merges can go smoothly.
My most important issue is with the indention mixing tabs and spaces. Clearing out space at the end of lines is secondary. Least important are empty lines at eof (even though they should not lead to git blame confusion).

I will leave .dbd and .dbd.pod untouched for the moment, even though they have the same indention issue. But here I would probably aim for a consistent use of tab.

2b1ce8c... by Dirk Zimoch on 2020-04-17

removed spaces at end of line

Conflicts:
 modules/libcom/test/epicsCalcTest.cpp

[Dirk Zimoch (dirk.zimoch)]

I took out the deletion of empty lines at eof and rebased the remaining changes onto the current 7.0 commit 85d198. I did not clean up the files in boost as they are an external, unlikely to ever change package.

'git diff --ignore-all-space 7.0' gives no output.

[mdavidsaver (mdavidsaver)]

Ok by me.

review: Approve

[mdavidsaver (mdavidsaver)]

Applied as 36a8b51d8e743c487cc5f4c079746b234b2afca1

diff --git a/modules/ca/src/client/CASG.cpp b/modules/ca/src/client/CASG.cpp
index 4ffb414..9eb44e6 100644
--- a/modules/ca/src/client/CASG.cpp
+++ b/modules/ca/src/client/CASG.cpp
@@ -209,23 +209,23 @@ bool CASG::ioComplete (
     return this->ioPendingList.count () == 0u;
 }
 
-void CASG::put ( epicsGuard < epicsMutex > & guard, chid pChan, 
+void CASG::put ( epicsGuard < epicsMutex > & guard, chid pChan,
     unsigned type, arrayElementCount count, const void * pValue )
 {
     guard.assertIdenticalMutex ( this->client.mutexRef() );
     sgAutoPtr < syncGroupWriteNotify > pNotify ( guard, *this );
-    pNotify = syncGroupWriteNotify::factory ( 
+    pNotify = syncGroupWriteNotify::factory (
         this->freeListWriteOP, *this, & CASG :: recycleWriteNotifyIO, pChan );
     pNotify->begin ( guard, type, count, pValue );
     pNotify.release ();
 }
 
-void CASG::get ( epicsGuard < epicsMutex > & guard, chid pChan, 
+void CASG::get ( epicsGuard < epicsMutex > & guard, chid pChan,
                 unsigned type, arrayElementCount count, void *pValue )
 {
     guard.assertIdenticalMutex ( this->client.mutexRef() );
     sgAutoPtr < syncGroupReadNotify > pNotify ( guard, *this );
-    pNotify = syncGroupReadNotify::factory ( 
+    pNotify = syncGroupReadNotify::factory (
         this->freeListReadOP, *this, & CASG :: recycleReadNotifyIO, pChan, pValue );
     pNotify->begin ( guard, type, count );
     pNotify.release ();
@@ -242,14 +242,14 @@ void CASG::completionNotify (
     }
 }
 
-void CASG :: recycleReadNotifyIO ( epicsGuard < epicsMutex > & guard, 
+void CASG :: recycleReadNotifyIO ( epicsGuard < epicsMutex > & guard,
                             syncGroupReadNotify & io )
 {
     guard.assertIdenticalMutex ( this->client.mutexRef() );
     this->freeListReadOP.release ( & io );
 }
 
-void CASG :: recycleWriteNotifyIO ( epicsGuard < epicsMutex > & guard, 
+void CASG :: recycleWriteNotifyIO ( epicsGuard < epicsMutex > & guard,
                             syncGroupWriteNotify & io )
 {
     guard.assertIdenticalMutex ( this->client.mutexRef() );
diff --git a/modules/ca/src/client/SearchDest.h b/modules/ca/src/client/SearchDest.h
index c22be7c..c31f688 100644
--- a/modules/ca/src/client/SearchDest.h
+++ b/modules/ca/src/client/SearchDest.h
@@ -5,7 +5,7 @@
  *     Operator of Los Alamos National Laboratory.
  * EPICS BASE Versions 3.13.7
  * and higher are distributed subject to a Software License Agreement found
- * in file LICENSE that is included with this distribution. 
+ * in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #ifndef SearchDest_h
@@ -28,7 +28,7 @@ struct SearchDest :
         virtual void notify (
             const caHdr & msg, const void * pPayload,
             const osiSockAddr & addr, const epicsTime & ) = 0;
-        virtual void show ( 
+        virtual void show (
             epicsGuard < epicsMutex > &, unsigned level ) const = 0;
     };
     virtual void searchRequest ( epicsGuard < epicsMutex > &,
diff --git a/modules/ca/src/client/access.cpp b/modules/ca/src/client/access.cpp
index a36899c..528cd6c 100644
--- a/modules/ca/src/client/access.cpp
+++ b/modules/ca/src/client/access.cpp
@@ -183,19 +183,19 @@ int epicsShareAPI ca_context_create (
         }
 
         pcac = ( ca_client_context * ) epicsThreadPrivateGet ( caClientContextId );
-	    if ( pcac ) {
+        if ( pcac ) {
             if ( premptiveCallbackSelect == ca_enable_preemptive_callback &&
                 ! pcac->preemptiveCallbakIsEnabled() ) {
                 return ECA_NOTTHREADED;
             }
-		    return ECA_NORMAL;
-	    }
+            return ECA_NORMAL;
+        }
 
         pcac = new ca_client_context (
             premptiveCallbackSelect == ca_enable_preemptive_callback );
-	    if ( ! pcac ) {
-		    return ECA_ALLOCMEM;
-	    }
+        if ( ! pcac ) {
+            return ECA_ALLOCMEM;
+        }
 
         epicsThreadPrivateSet ( caClientContextId, (void *) pcac );
     }
@@ -467,7 +467,7 @@ int epicsShareAPI ca_pend_event ( ca_real timeout )
     try {
         // preserve past odd ball behavior of waiting forever when
         // the delay is zero
-    	if ( timeout == 0.0 ) {
+        if ( timeout == 0.0 ) {
             while ( true ) {
                 pcac->pendEvent ( 60.0 );
             }
@@ -696,7 +696,7 @@ int epicsShareAPI ca_channel_status ( epicsThreadId /* tid */ )
 {
     ::printf ("The R3.14 EPICS OS abstraction API does not allow peeking at thread private storage of another thread.\n");
     ::printf ("Please call \"ca_client_status ( unsigned level )\" from the subsystem specific diagnostic code.\n");
-	return ECA_ANACHRONISM;
+    return ECA_ANACHRONISM;
 }
 
 // extern "C"
@@ -802,253 +802,253 @@ epicsShareDef const int epicsTypeToDBR_XXXX [lastEpicsType+1] = {
 
 // extern "C"
 epicsShareDef const epicsType DBR_XXXXToEpicsType [LAST_BUFFER_TYPE+1] = {
-	epicsOldStringT,
-	epicsInt16T,
-	epicsFloat32T,
-	epicsEnum16T,
-	epicsUInt8T,
-	epicsInt32T,
-	epicsFloat64T,
-
-	epicsOldStringT,
-	epicsInt16T,
-	epicsFloat32T,
-	epicsEnum16T,
-	epicsUInt8T,
-	epicsInt32T,
-	epicsFloat64T,
-
-	epicsOldStringT,
-	epicsInt16T,
-	epicsFloat32T,
-	epicsEnum16T,
-	epicsUInt8T,
-	epicsInt32T,
-	epicsFloat64T,
-
-	epicsOldStringT,
-	epicsInt16T,
-	epicsFloat32T,
-	epicsEnum16T,
-	epicsUInt8T,
-	epicsInt32T,
-	epicsFloat64T,
-
-	epicsOldStringT,
-	epicsInt16T,
-	epicsFloat32T,
-	epicsEnum16T,
-	epicsUInt8T,
-	epicsInt32T,
-	epicsFloat64T,
-
-	epicsUInt16T,
-	epicsUInt16T,
-	epicsOldStringT,
-	epicsOldStringT
+    epicsOldStringT,
+    epicsInt16T,
+    epicsFloat32T,
+    epicsEnum16T,
+    epicsUInt8T,
+    epicsInt32T,
+    epicsFloat64T,
+
+    epicsOldStringT,
+    epicsInt16T,
+    epicsFloat32T,
+    epicsEnum16T,
+    epicsUInt8T,
+    epicsInt32T,
+    epicsFloat64T,
+
+    epicsOldStringT,
+    epicsInt16T,
+    epicsFloat32T,
+    epicsEnum16T,
+    epicsUInt8T,
+    epicsInt32T,
+    epicsFloat64T,
+
+    epicsOldStringT,
+    epicsInt16T,
+    epicsFloat32T,
+    epicsEnum16T,
+    epicsUInt8T,
+    epicsInt32T,
+    epicsFloat64T,
+
+    epicsOldStringT,
+    epicsInt16T,
+    epicsFloat32T,
+    epicsEnum16T,
+    epicsUInt8T,
+    epicsInt32T,
+    epicsFloat64T,
+
+    epicsUInt16T,
+    epicsUInt16T,
+    epicsOldStringT,
+    epicsOldStringT
 };
 
 // extern "C"
 epicsShareDef const unsigned short dbr_size[LAST_BUFFER_TYPE+1] = {
-	sizeof(dbr_string_t),		/* string max size		*/
-	sizeof(dbr_short_t),		/* short			*/
-	sizeof(dbr_float_t),		/* IEEE Float			*/
-	sizeof(dbr_enum_t),		/* item number			*/
-	sizeof(dbr_char_t),		/* character			*/
-
-	sizeof(dbr_long_t),		/* long				*/
-	sizeof(dbr_double_t),		/* double			*/
-	sizeof(struct dbr_sts_string),	/* string field	with status	*/
-	sizeof(struct dbr_sts_short),	/* short field with status	*/
-	sizeof(struct dbr_sts_float),	/* float field with status	*/
-
-	sizeof(struct dbr_sts_enum),	/* item number with status	*/
-	sizeof(struct dbr_sts_char),	/* char field with status	*/
-	sizeof(struct dbr_sts_long),	/* long field with status	*/
-	sizeof(struct dbr_sts_double),	/* double field with time	*/
-	sizeof(struct dbr_time_string),	/* string field	with time	*/
-
-	sizeof(struct dbr_time_short),	/* short field with time	*/
-	sizeof(struct dbr_time_float),	/* float field with time	*/
-	sizeof(struct dbr_time_enum),	/* item number with time	*/
-	sizeof(struct dbr_time_char),	/* char field with time		*/
-	sizeof(struct dbr_time_long),	/* long field with time		*/
-
-	sizeof(struct dbr_time_double),	/* double field with time	*/
-	sizeof(struct dbr_sts_string),	/* graphic string info		*/
-	sizeof(struct dbr_gr_short),	/* graphic short info		*/
-	sizeof(struct dbr_gr_float),	/* graphic float info		*/
-	sizeof(struct dbr_gr_enum),	/* graphic item info		*/
-
-	sizeof(struct dbr_gr_char),	/* graphic char info		*/
-	sizeof(struct dbr_gr_long),	/* graphic long info		*/
-	sizeof(struct dbr_gr_double),	/* graphic double info		*/
-	sizeof(struct dbr_sts_string),	/* control string info		*/
-	sizeof(struct dbr_ctrl_short),	/* control short info		*/
-
-	sizeof(struct dbr_ctrl_float),	/* control float info		*/
-	sizeof(struct dbr_ctrl_enum),	/* control item info		*/
-	sizeof(struct dbr_ctrl_char),	/* control char info		*/
-	sizeof(struct dbr_ctrl_long),	/* control long info		*/
-	sizeof(struct dbr_ctrl_double),	/* control double info		*/
-
-	sizeof(dbr_put_ackt_t),		/* put ackt			*/
-	sizeof(dbr_put_acks_t),		/* put acks			*/
-	sizeof(struct dbr_stsack_string),/* string field with status/ack*/
-	sizeof(dbr_string_t),		/* string max size		*/
+    sizeof(dbr_string_t),           /* string max size              */
+    sizeof(dbr_short_t),            /* short                        */
+    sizeof(dbr_float_t),            /* IEEE Float                   */
+    sizeof(dbr_enum_t),             /* item number                  */
+    sizeof(dbr_char_t),             /* character                    */
+
+    sizeof(dbr_long_t),             /* long                         */
+    sizeof(dbr_double_t),           /* double                       */
+    sizeof(struct dbr_sts_string),  /* string field with status     */
+    sizeof(struct dbr_sts_short),   /* short field with status      */
+    sizeof(struct dbr_sts_float),   /* float field with status      */
+
+    sizeof(struct dbr_sts_enum),    /* item number with status      */
+    sizeof(struct dbr_sts_char),    /* char field with status       */
+    sizeof(struct dbr_sts_long),    /* long field with status       */
+    sizeof(struct dbr_sts_double),  /* double field with time       */
+    sizeof(struct dbr_time_string), /* string field with time       */
+
+    sizeof(struct dbr_time_short),  /* short field with time        */
+    sizeof(struct dbr_time_float),  /* float field with time        */
+    sizeof(struct dbr_time_enum),   /* item number with time        */
+    sizeof(struct dbr_time_char),   /* char field with time         */
+    sizeof(struct dbr_time_long),   /* long field with time         */
+
+    sizeof(struct dbr_time_double), /* double field with time       */
+    sizeof(struct dbr_sts_string),  /* graphic string info          */
+    sizeof(struct dbr_gr_short),    /* graphic short info           */
+    sizeof(struct dbr_gr_float),    /* graphic float info           */
+    sizeof(struct dbr_gr_enum),     /* graphic item info            */
+
+    sizeof(struct dbr_gr_char),     /* graphic char info            */
+    sizeof(struct dbr_gr_long),     /* graphic long info            */
+    sizeof(struct dbr_gr_double),   /* graphic double info          */
+    sizeof(struct dbr_sts_string),  /* control string info          */
+    sizeof(struct dbr_ctrl_short),  /* control short info           */
+
+    sizeof(struct dbr_ctrl_float),  /* control float info           */
+    sizeof(struct dbr_ctrl_enum),   /* control item info            */
+    sizeof(struct dbr_ctrl_char),   /* control char info            */
+    sizeof(struct dbr_ctrl_long),   /* control long info            */
+    sizeof(struct dbr_ctrl_double), /* control double info          */
+
+    sizeof(dbr_put_ackt_t),         /* put ackt                     */
+    sizeof(dbr_put_acks_t),         /* put acks                     */
+    sizeof(struct dbr_stsack_string),/* string field with status/ack*/
+    sizeof(dbr_string_t),           /* string max size              */
 };
 
 // extern "C"
 epicsShareDef const unsigned short dbr_value_size[LAST_BUFFER_TYPE+1] = {
-	sizeof(dbr_string_t),	/* string max size		*/
-	sizeof(dbr_short_t),	/* short			*/
-	sizeof(dbr_float_t),	/* IEEE Float			*/
-	sizeof(dbr_enum_t),	/* item number			*/
-	sizeof(dbr_char_t),	/* character			*/
-
-	sizeof(dbr_long_t),	/* long				*/
-	sizeof(dbr_double_t),	/* double			*/
-	sizeof(dbr_string_t),	/* string max size		*/
-	sizeof(dbr_short_t),	/* short			*/
-	sizeof(dbr_float_t),	/* IEEE Float			*/
-
-	sizeof(dbr_enum_t),	/* item number			*/
-	sizeof(dbr_char_t),	/* character			*/
-	sizeof(dbr_long_t),	/* long				*/
-	sizeof(dbr_double_t),	/* double			*/
-	sizeof(dbr_string_t),	/* string max size		*/
-
-	sizeof(dbr_short_t),	/* short			*/
-	sizeof(dbr_float_t),	/* IEEE Float			*/
-	sizeof(dbr_enum_t),	/* item number			*/
-	sizeof(dbr_char_t),	/* character			*/
-	sizeof(dbr_long_t),	/* long				*/
-
-	sizeof(dbr_double_t),	/* double			*/
-	sizeof(dbr_string_t),	/* string max size		*/
-	sizeof(dbr_short_t),	/* short			*/
-	sizeof(dbr_float_t),	/* IEEE Float			*/
-	sizeof(dbr_enum_t),	/* item number			*/
-
-	sizeof(dbr_char_t),	/* character			*/
-	sizeof(dbr_long_t),	/* long				*/
-	sizeof(dbr_double_t),	/* double			*/
-	sizeof(dbr_string_t),	/* string max size		*/
-	sizeof(dbr_short_t),	/* short			*/
-
-	sizeof(dbr_float_t),	/* IEEE Float			*/
-	sizeof(dbr_enum_t),	/* item number			*/
-	sizeof(dbr_char_t),	/* character			*/
-	sizeof(dbr_long_t),	/* long				*/
-	sizeof(dbr_double_t),	/* double			*/
-
-	sizeof(dbr_ushort_t), 	/* put_ackt			*/
-	sizeof(dbr_ushort_t), 	/* put_acks			*/
-	sizeof(dbr_string_t),	/* string max size		*/
-	sizeof(dbr_string_t),	/* string max size		*/
+    sizeof(dbr_string_t),   /* string max size              */
+    sizeof(dbr_short_t),    /* short                        */
+    sizeof(dbr_float_t),    /* IEEE Float                   */
+    sizeof(dbr_enum_t),     /* item number                  */
+    sizeof(dbr_char_t),     /* character                    */
+
+    sizeof(dbr_long_t),     /* long                         */
+    sizeof(dbr_double_t),   /* double                       */
+    sizeof(dbr_string_t),   /* string max size              */
+    sizeof(dbr_short_t),    /* short                        */
+    sizeof(dbr_float_t),    /* IEEE Float                   */
+
+    sizeof(dbr_enum_t),     /* item number                  */
+    sizeof(dbr_char_t),     /* character                    */
+    sizeof(dbr_long_t),     /* long                         */
+    sizeof(dbr_double_t),   /* double                       */
+    sizeof(dbr_string_t),   /* string max size              */
+
+    sizeof(dbr_short_t),    /* short                        */
+    sizeof(dbr_float_t),    /* IEEE Float                   */
+    sizeof(dbr_enum_t),     /* item number                  */
+    sizeof(dbr_char_t),     /* character                    */
+    sizeof(dbr_long_t),     /* long                         */
+
+    sizeof(dbr_double_t),   /* double                       */
+    sizeof(dbr_string_t),   /* string max size              */
+    sizeof(dbr_short_t),    /* short                        */
+    sizeof(dbr_float_t),    /* IEEE Float                   */
+    sizeof(dbr_enum_t),     /* item number                  */
+
+    sizeof(dbr_char_t),     /* character                    */
+    sizeof(dbr_long_t),     /* long                         */
+    sizeof(dbr_double_t),   /* double                       */
+    sizeof(dbr_string_t),   /* string max size              */
+    sizeof(dbr_short_t),    /* short                        */
+
+    sizeof(dbr_float_t),    /* IEEE Float                   */
+    sizeof(dbr_enum_t),     /* item number                  */
+    sizeof(dbr_char_t),     /* character                    */
+    sizeof(dbr_long_t),     /* long                         */
+    sizeof(dbr_double_t),   /* double                       */
+
+    sizeof(dbr_ushort_t),   /* put_ackt                     */
+    sizeof(dbr_ushort_t),   /* put_acks                     */
+    sizeof(dbr_string_t),   /* string max size              */
+    sizeof(dbr_string_t),   /* string max size              */
 };
 
 //extern "C"
 epicsShareDef const enum dbr_value_class dbr_value_class[LAST_BUFFER_TYPE+1] = {
-	dbr_class_string,	/* string max size		*/
-	dbr_class_int,		/* short			*/
-	dbr_class_float,	/* IEEE Float			*/
-	dbr_class_int,		/* item number			*/
-	dbr_class_int,		/* character			*/
-	dbr_class_int,		/* long				*/
-	dbr_class_float,	/* double			*/
-
-	dbr_class_string,	/* string max size		*/
-	dbr_class_int,		/* short			*/
-	dbr_class_float,	/* IEEE Float			*/
-	dbr_class_int,		/* item number			*/
-	dbr_class_int,		/* character			*/
-	dbr_class_int,		/* long				*/
-	dbr_class_float,	/* double			*/
-
-	dbr_class_string,	/* string max size		*/
-	dbr_class_int,		/* short			*/
-	dbr_class_float,	/* IEEE Float			*/
-	dbr_class_int,		/* item number			*/
-	dbr_class_int,		/* character			*/
-	dbr_class_int,		/* long				*/
-	dbr_class_float,	/* double			*/
-
-	dbr_class_string,	/* string max size		*/
-	dbr_class_int,		/* short			*/
-	dbr_class_float,	/* IEEE Float			*/
-	dbr_class_int,		/* item number			*/
-	dbr_class_int,		/* character			*/
-	dbr_class_int,		/* long				*/
-	dbr_class_float,	/* double			*/
-
-	dbr_class_string,	/* string max size		*/
-	dbr_class_int,		/* short			*/
-	dbr_class_float,	/* IEEE Float			*/
-	dbr_class_int,		/* item number			*/
-	dbr_class_int,		/* character			*/
-	dbr_class_int,		/* long				*/
-	dbr_class_float,	/* double			*/
-	dbr_class_int,
-	dbr_class_int,
-	dbr_class_string,
-	dbr_class_string,	/* string max size		*/
+    dbr_class_string,       /* string max size              */
+    dbr_class_int,          /* short                        */
+    dbr_class_float,        /* IEEE Float                   */
+    dbr_class_int,          /* item number                  */
+    dbr_class_int,          /* character                    */
+    dbr_class_int,          /* long                         */
+    dbr_class_float,        /* double                       */
+
+    dbr_class_string,       /* string max size              */
+    dbr_class_int,          /* short                        */
+    dbr_class_float,        /* IEEE Float                   */
+    dbr_class_int,          /* item number                  */
+    dbr_class_int,          /* character                    */
+    dbr_class_int,          /* long                         */
+    dbr_class_float,        /* double                       */
+
+    dbr_class_string,       /* string max size              */
+    dbr_class_int,          /* short                        */
+    dbr_class_float,        /* IEEE Float                   */
+    dbr_class_int,          /* item number                  */
+    dbr_class_int,          /* character                    */
+    dbr_class_int,          /* long                         */
+    dbr_class_float,        /* double                       */
+
+    dbr_class_string,       /* string max size              */
+    dbr_class_int,          /* short                        */
+    dbr_class_float,        /* IEEE Float                   */
+    dbr_class_int,          /* item number                  */
+    dbr_class_int,          /* character                    */
+    dbr_class_int,          /* long                         */
+    dbr_class_float,        /* double                       */
+
+    dbr_class_string,       /* string max size              */
+    dbr_class_int,          /* short                        */
+    dbr_class_float,        /* IEEE Float                   */
+    dbr_class_int,          /* item number                  */
+    dbr_class_int,          /* character                    */
+    dbr_class_int,          /* long                         */
+    dbr_class_float,        /* double                       */
+    dbr_class_int,
+    dbr_class_int,
+    dbr_class_string,
+    dbr_class_string,       /* string max size              */
 };
 
 // extern "C"
 epicsShareDef const unsigned short dbr_value_offset[LAST_BUFFER_TYPE+1] = {
-	0,					/* string			*/
-	0,					/* short			*/
-	0,					/* IEEE Float			*/
-	0,					/* item number			*/
-	0,					/* character			*/
-	0,					/* long				*/
-	0,					/* IEEE double			*/
-	(unsigned short) offsetof(dbr_sts_string,value[0]),/* string field	with status	*/
-	(unsigned short) offsetof(dbr_sts_short,value),	/* short field with status	*/
-	(unsigned short) offsetof(dbr_sts_float,value),	/* float field with status	*/
-	(unsigned short) offsetof(dbr_sts_enum,value),	/* item number with status	*/
-	(unsigned short) offsetof(dbr_sts_char,value),	/* char field with status	*/
-	(unsigned short) offsetof(dbr_sts_long,value),	/* long field with status	*/
-	(unsigned short) offsetof(dbr_sts_double,value),	/* double field with time	*/
-	(unsigned short) offsetof(dbr_time_string,value[0] ),/* string field with time	*/
-	(unsigned short) offsetof(dbr_time_short,value),	/* short field with time	*/
-	(unsigned short) offsetof(dbr_time_float,value),	/* float field with time	*/
-	(unsigned short) offsetof(dbr_time_enum,value),	/* item number with time	*/
-	(unsigned short) offsetof(dbr_time_char,value),	/* char field with time		*/
-	(unsigned short) offsetof(dbr_time_long,value),	/* long field with time		*/
-	(unsigned short) offsetof(dbr_time_double,value),	/* double field with time	*/
-	(unsigned short) offsetof(dbr_sts_string,value[0]),/* graphic string info		*/
-	(unsigned short) offsetof(dbr_gr_short,value),	/* graphic short info		*/
-	(unsigned short) offsetof(dbr_gr_float,value),	/* graphic float info		*/
-	(unsigned short) offsetof(dbr_gr_enum,value),	/* graphic item info		*/
-	(unsigned short) offsetof(dbr_gr_char,value),	/* graphic char info		*/
-	(unsigned short) offsetof(dbr_gr_long,value),	/* graphic long info		*/
-	(unsigned short) offsetof(dbr_gr_double,value),	/* graphic double info		*/
-	(unsigned short) offsetof(dbr_sts_string,value[0]),/* control string info		*/
-	(unsigned short) offsetof(dbr_ctrl_short,value),	/* control short info		*/
-	(unsigned short) offsetof(dbr_ctrl_float,value),	/* control float info		*/
-	(unsigned short) offsetof(dbr_ctrl_enum,value),	/* control item info		*/
-	(unsigned short) offsetof(dbr_ctrl_char,value),	/* control char info		*/
-	(unsigned short) offsetof(dbr_ctrl_long,value),	/* control long info		*/
-	(unsigned short) offsetof(dbr_ctrl_double,value),	/* control double info		*/
-	0,					/* put ackt			*/
-	0,					/* put acks			*/
-	(unsigned short) offsetof(dbr_stsack_string,value[0]),/* string field	with status	*/
-	0,					/* string			*/
+    0,                                                      /* string                   */
+    0,                                                      /* short                    */
+    0,                                                      /* IEEE Float               */
+    0,                                                      /* item number              */
+    0,                                                      /* character                */
+    0,                                                      /* long                     */
+    0,                                                      /* IEEE double              */
+    (unsigned short) offsetof(dbr_sts_string,value[0]),     /* string field with status */
+    (unsigned short) offsetof(dbr_sts_short,value),         /* short field with status  */
+    (unsigned short) offsetof(dbr_sts_float,value),         /* float field with status  */
+    (unsigned short) offsetof(dbr_sts_enum,value),          /* item number with status  */
+    (unsigned short) offsetof(dbr_sts_char,value),          /* char field with status   */
+    (unsigned short) offsetof(dbr_sts_long,value),          /* long field with status   */
+    (unsigned short) offsetof(dbr_sts_double,value),        /* double field with time   */
+    (unsigned short) offsetof(dbr_time_string,value[0] ),   /* string field with time   */
+    (unsigned short) offsetof(dbr_time_short,value),        /* short field with time    */
+    (unsigned short) offsetof(dbr_time_float,value),        /* float field with time    */
+    (unsigned short) offsetof(dbr_time_enum,value),         /* item number with time    */
+    (unsigned short) offsetof(dbr_time_char,value),         /* char field with time     */
+    (unsigned short) offsetof(dbr_time_long,value),         /* long field with time     */
+    (unsigned short) offsetof(dbr_time_double,value),       /* double field with time   */
+    (unsigned short) offsetof(dbr_sts_string,value[0]),     /* graphic string info      */
+    (unsigned short) offsetof(dbr_gr_short,value),          /* graphic short info       */
+    (unsigned short) offsetof(dbr_gr_float,value),          /* graphic float info       */
+    (unsigned short) offsetof(dbr_gr_enum,value),           /* graphic item info        */
+    (unsigned short) offsetof(dbr_gr_char,value),           /* graphic char info        */
+    (unsigned short) offsetof(dbr_gr_long,value),           /* graphic long info        */
+    (unsigned short) offsetof(dbr_gr_double,value),         /* graphic double info      */
+    (unsigned short) offsetof(dbr_sts_string,value[0]),     /* control string info      */
+    (unsigned short) offsetof(dbr_ctrl_short,value),        /* control short info       */
+    (unsigned short) offsetof(dbr_ctrl_float,value),        /* control float info       */
+    (unsigned short) offsetof(dbr_ctrl_enum,value),         /* control item info        */
+    (unsigned short) offsetof(dbr_ctrl_char,value),         /* control char info        */
+    (unsigned short) offsetof(dbr_ctrl_long,value),         /* control long info        */
+    (unsigned short) offsetof(dbr_ctrl_double,value),       /* control double info      */
+    0,                                                      /* put ackt                 */
+    0,                                                      /* put acks                 */
+    (unsigned short) offsetof(dbr_stsack_string,value[0]),  /* string field with status */
+    0,                                                      /* string                   */
 };
 
 // extern "C"
 epicsShareDef const char *dbf_text[LAST_TYPE+3] = {
-	"TYPENOTCONN",
-	"DBF_STRING",
-	"DBF_SHORT",
-	"DBF_FLOAT",
-	"DBF_ENUM",
-	"DBF_CHAR",
-	"DBF_LONG",
-	"DBF_DOUBLE",
-	"DBF_NO_ACCESS"
+    "TYPENOTCONN",
+    "DBF_STRING",
+    "DBF_SHORT",
+    "DBF_FLOAT",
+    "DBF_ENUM",
+    "DBF_CHAR",
+    "DBF_LONG",
+    "DBF_DOUBLE",
+    "DBF_NO_ACCESS"
 };
 
 // extern "C"
diff --git a/modules/ca/src/client/acctst.c b/modules/ca/src/client/acctst.c
index fd18ae4..9f3e907 100644
--- a/modules/ca/src/client/acctst.c
+++ b/modules/ca/src/client/acctst.c
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 /*
@@ -14,7 +14,7 @@
  * Jeff Hill
  * Murali Shankar - initial versions of verifyMultithreadSubscr
  * Michael Abbott - initial versions of multiSubscrDestroyNoLateCallbackTest
- * 
+ *
  */
 
 /*
@@ -110,7 +110,7 @@ void nUpdatesTester ( struct event_handler_args args )
         ( *pCtr ) ++;
     }
     else {
-        printf ( "subscription update failed for \"%s\" because \"%s\"", 
+        printf ( "subscription update failed for \"%s\" because \"%s\"",
             ca_name ( args.chid ), ca_message ( args.status ) );
     }
 }
@@ -131,7 +131,7 @@ void monitorSubscriptionFirstUpdateTest ( const char *pName, chid chan, unsigned
      * verify that the first event arrives (with evid)
      * and channel connected
      */
-    status = ca_add_event ( DBR_FLOAT, 
+    status = ca_add_event ( DBR_FLOAT,
                 chan, nUpdatesTester, &eventCount, &id );
     SEVCHK ( status, 0 );
     ca_flush_io ();
@@ -190,7 +190,7 @@ void monitorSubscriptionFirstUpdateTest ( const char *pName, chid chan, unsigned
     waitCount = 0u;
     status = ca_search ( pName, &chan2 );
     SEVCHK ( status, 0 );
-    status = ca_add_event ( DBR_FLOAT, chan2, 
+    status = ca_add_event ( DBR_FLOAT, chan2,
                 nUpdatesTester, &eventCount, 0 );
     SEVCHK ( status, 0 );
     status = ca_pend_io ( timeoutToPendIO );
@@ -250,7 +250,7 @@ void ioTesterGet ( struct event_handler_args args )
         ( *pCtr ) ++;
     }
     else {
-        printf("get call back failed for \"%s\" because \"%s\"", 
+        printf("get call back failed for \"%s\" because \"%s\"",
             ca_name ( args.chid ), ca_message ( args.status ) );
     }
 }
@@ -263,7 +263,7 @@ void ioTesterEvent ( struct event_handler_args args )
         SEVCHK ( status, 0 );
     }
     else {
-        printf ( "subscription update failed for \"%s\" because \"%s\"", 
+        printf ( "subscription update failed for \"%s\" because \"%s\"",
             ca_name ( args.chid ), ca_message ( args.status ) );
     }
 }
@@ -280,7 +280,7 @@ void verifyMonitorSubscriptionFlushIO ( chid chan, unsigned interestLevel  )
     /*
      * verify that the first event arrives
      */
-    status = ca_add_event ( DBR_FLOAT, 
+    status = ca_add_event ( DBR_FLOAT,
                 chan, nUpdatesTester, &eventCount, &id );
     SEVCHK (status, 0);
     ca_flush_io ();
@@ -317,8 +317,8 @@ void getCallbackStateChange ( struct event_handler_args args )
     verify ( pChan->channel == args.chid );
     verify ( pChan->connected );
     if ( args.status != ECA_NORMAL ) {
-        printf ( "getCallbackStateChange abnormal status was \"%s\"\n", 
-            ca_message ( args.status ) ); 
+        printf ( "getCallbackStateChange abnormal status was \"%s\"\n",
+            ca_message ( args.status ) );
         verify ( args.status == ECA_NORMAL );
     }
 
@@ -373,7 +373,7 @@ void subscriptionStateChange ( struct event_handler_args args )
 void noopSubscriptionStateChange ( struct event_handler_args args )
 {
     if ( args.status != ECA_NORMAL ) {
-        printf ( "noopSubscriptionStateChange: subscription update failed for \"%s\" because \"%s\"", 
+        printf ( "noopSubscriptionStateChange: subscription update failed for \"%s\" because \"%s\"",
             ca_name ( args.chid ), ca_message ( args.status ) );
     }
 }
@@ -396,7 +396,7 @@ void noopSubscriptionStateChange ( struct event_handler_args args )
  *
  * 7) verify that a nill access rights handler can be installed
  */
-void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount, 
+void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
                         unsigned repetitionCount, unsigned interestLevel )
 {
     int status;
@@ -439,7 +439,7 @@ void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
 
         showProgress ( interestLevel );
 
-        while ( connectionUpdateCount < chanCount || 
+        while ( connectionUpdateCount < chanCount ||
             getCallbackCount < chanCount ) {
             epicsThreadSleep ( 0.1 );
             ca_poll (); /* emulate typical GUI */
@@ -471,7 +471,7 @@ void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
         ca_self_test ();
 
         showProgress ( interestLevel );
-        
+
         for ( j = 0u; j < chanCount; j++ ) {
             status = ca_replace_access_rights_event (
                     pChans[j].channel, 0 );
@@ -494,7 +494,7 @@ void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
 /*
  * verifyBlockingConnect ()
  *
- * 1) verify that we dont print a disconnect message when 
+ * 1) verify that we dont print a disconnect message when
  * we delete the last channel
  *
  * 2) verify that we delete the connection to the IOC
@@ -502,7 +502,7 @@ void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
  *
  * 3) verify channel connection state variables
  *
- * 4) verify ca_test_io () and ca_pend_io () work with 
+ * 4) verify ca_test_io () and ca_pend_io () work with
  * channels w/o connection handlers
  *
  * 5) verify that the pending IO count is properly
@@ -512,7 +512,7 @@ void verifyConnectionHandlerConnect ( appChan *pChans, unsigned chanCount,
  * 6) verify that the pending IO count goes to zero
  * if the channel is deleted before it connects.
  */
-void verifyBlockingConnect ( appChan *pChans, unsigned chanCount, 
+void verifyBlockingConnect ( appChan *pChans, unsigned chanCount,
                             unsigned repetitionCount, unsigned interestLevel )
 {
     int status;
@@ -551,7 +551,7 @@ void verifyBlockingConnect ( appChan *pChans, unsigned chanCount,
                 verify ( INVALID_DB_REQ ( ca_field_type ( pChans[j].channel ) ) );
                 verify ( ca_test_io () == ECA_IOINPROGRESS );
             }
-            
+
             status = ca_replace_access_rights_event (
                     pChans[j].channel, accessRightsStateChange );
             SEVCHK ( status, NULL );
@@ -605,7 +605,7 @@ void verifyBlockingConnect ( appChan *pChans, unsigned chanCount,
         showProgress ( interestLevel );
 
         /*
-         * verify that connections to IOC's that are 
+         * verify that connections to IOC's that are
          * not in use are dropped
          */
         if ( ca_get_ioc_connection_count () != backgroundConnCount ) {
@@ -698,13 +698,13 @@ void verifyClear ( appChan *pChans, unsigned interestLevel )
 
     /*
      * verify subscription clear before connect
-     * and verify that NULL evid does not cause failure 
+     * and verify that NULL evid does not cause failure
      */
     status = ca_search ( pChans[0].name, &pChans[0].channel );
     SEVCHK ( status, NULL );
 
     SEVCHK ( status, NULL );
-    status = ca_add_event ( DBR_GR_DOUBLE, 
+    status = ca_add_event ( DBR_GR_DOUBLE,
             pChans[0].channel, noopSubscriptionStateChange, NULL, NULL );
     SEVCHK ( status, NULL );
 
@@ -791,7 +791,7 @@ void ctrlDoubleTest ( chid chan, unsigned interestLevel )
     SEVCHK (status, "ctrlDoubleTest, ca_array_put");
 
     size = dbr_size_n(DBR_CTRL_DOUBLE, ca_element_count(chan));
-    pCtrlDbl = (struct dbr_ctrl_double *) malloc (size); 
+    pCtrlDbl = (struct dbr_ctrl_double *) malloc (size);
     verify (pCtrlDbl!=NULL);
 
     /*
@@ -846,7 +846,7 @@ void verifyBlockInPendIO ( chid chan, unsigned interestLevel  )
         else if ( resp != -100 ) {
             printf ( "CA didnt block for get to return?\n" );
         }
-            
+
         req = 1;
         resp = -100;
         SEVCHK ( ca_put (DBR_LONG, chan, &req), NULL );
@@ -898,7 +898,7 @@ void floatTest ( chid chan, dbr_float_t beginValue, dbr_float_t increment,
 /*
  * doubleTest ()
  */
-void doubleTest ( chid chan, dbr_double_t beginValue, 
+void doubleTest ( chid chan, dbr_double_t beginValue,
     dbr_double_t  increment, dbr_double_t epsilon,
     unsigned iterations)
 {
@@ -929,7 +929,7 @@ void doubleTest ( chid chan, dbr_double_t beginValue,
  * Verify that we can write and then read back
  * the same analog value
  */
-void verifyAnalogIO ( chid chan, int dataType, double min, double max, 
+void verifyAnalogIO ( chid chan, int dataType, double min, double max,
                int minExp, int maxExp, double epsilon, unsigned interestLevel )
 {
     int i;
@@ -962,11 +962,11 @@ void verifyAnalogIO ( chid chan, int dataType, double min, double max,
             iter = 10u;
         }
         if ( dataType == DBR_FLOAT ) {
-            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr, 
+            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr,
                 (dbr_float_t) epsil, iter );
         }
         else if (dataType == DBR_DOUBLE ) {
-            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr, 
+            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr,
                 (dbr_double_t) epsil, iter );
         }
         else {
@@ -983,11 +983,11 @@ void verifyAnalogIO ( chid chan, int dataType, double min, double max,
             iter = 10u;
         }
         if ( dataType == DBR_FLOAT ) {
-            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr, 
+            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr,
                 (dbr_float_t) epsil, iter );
         }
         else if (dataType == DBR_DOUBLE ) {
-            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr, 
+            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr,
                 (dbr_double_t) epsil, iter );
          }
         else {
@@ -1004,11 +1004,11 @@ void verifyAnalogIO ( chid chan, int dataType, double min, double max,
             iter = 10l;
         }
         if ( dataType == DBR_FLOAT ) {
-            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr, 
+            floatTest ( chan, (dbr_float_t) base, (dbr_float_t) incr,
                 (dbr_float_t) epsil, iter );
         }
         else if (dataType == DBR_DOUBLE ) {
-            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr, 
+            doubleTest ( chan, (dbr_double_t) base, (dbr_double_t) incr,
                 (dbr_double_t) epsil, iter );
          }
         else {
@@ -1045,7 +1045,7 @@ void verifyLongIO ( chid chan, unsigned interestLevel  )
         if ( incr == 0 ) {
             incr = 1;
         }
-        for ( iter = cl.lower_ctrl_limit; 
+        for ( iter = cl.lower_ctrl_limit;
             iter <= cl.upper_ctrl_limit; iter+=incr ) {
 
             ca_put ( DBR_LONG, chan, &iter );
@@ -1089,8 +1089,8 @@ void verifyShortIO ( chid chan, unsigned interestLevel  )
         if ( incr == 0 ) {
             incr = 1;
         }
-        for ( iter = (dbr_short_t) cl.lower_ctrl_limit; 
-            iter <= (dbr_short_t) cl.upper_ctrl_limit; 
+        for ( iter = (dbr_short_t) cl.lower_ctrl_limit;
+            iter <= (dbr_short_t) cl.upper_ctrl_limit;
             iter = (dbr_short_t) (iter + incr) ) {
 
             ca_put ( DBR_SHORT, chan, &iter );
@@ -1131,7 +1131,7 @@ void verifyHighThroughputRead ( chid chan, unsigned interestLevel )
     }
 }
 
-void verifyHighThroughputWrite ( chid chan, unsigned interestLevel  ) 
+void verifyHighThroughputWrite ( chid chan, unsigned interestLevel  )
 {
     int status;
     unsigned i;
@@ -1155,12 +1155,12 @@ void verifyHighThroughputWrite ( chid chan, unsigned interestLevel  )
  * verify we dont jam up on many uninterrupted
  * get callback requests
  */
-void verifyHighThroughputReadCallback ( chid chan, unsigned interestLevel ) 
+void verifyHighThroughputReadCallback ( chid chan, unsigned interestLevel )
 {
     unsigned i;
     int status;
 
-    if ( ca_read_access ( chan ) ) { 
+    if ( ca_read_access ( chan ) ) {
         unsigned count = 0u;
         showProgressBegin ( "verifyHighThroughputReadCallback", interestLevel );
         for ( i=0; i<10000; i++ ) {
@@ -1203,10 +1203,10 @@ void verifyHighThroughputWriteCallback ( chid chan, unsigned interestLevel )
         SEVCHK ( ca_flush_io (), NULL );
         dval = 0.0;
         status = ca_get ( DBR_DOUBLE, chan, &dval );
-        SEVCHK ( status, 
+        SEVCHK ( status,
             "verifyHighThroughputWriteCallback, verification get" );
         status = ca_pend_io ( timeoutToPendIO );
-        SEVCHK ( status, 
+        SEVCHK ( status,
             "verifyHighThroughputWriteCallback, verification get pend" );
         verify ( dval == i );
         showProgressEnd ( interestLevel );
@@ -1360,9 +1360,9 @@ static void noLateCallbackDetect ( struct event_handler_args args )
     verify ( callbackIsOk );
 }
 
-static void multiSubscrDestroyNoLateCallbackThread ( void * pParm ) 
+static void multiSubscrDestroyNoLateCallbackThread ( void * pParm )
 {
-    struct MultiSubscrDestroyNoLateCallbackTestData * const pTestData = 
+    struct MultiSubscrDestroyNoLateCallbackTestData * const pTestData =
               ( struct MultiSubscrDestroyNoLateCallbackTestData * ) pParm;
     unsigned i, j;
     int status;
@@ -1391,10 +1391,10 @@ static void multiSubscrDestroyNoLateCallbackThread ( void * pParm )
             SEVCHK ( ca_add_event ( DBR_GR_FLOAT, pTestData->m_chan, noLateCallbackDetect,
                         &pTestData->m_eventData[j], &pTestData->m_eventData[j].m_id ) , NULL );
         }
-        SEVCHK ( ca_flush_io(), NULL ); 
+        SEVCHK ( ca_flush_io(), NULL );
 
         /*
-         * raise the priority of the current thread hoping to improve our 
+         * raise the priority of the current thread hoping to improve our
          * likelyhood of detecting a bug
          */
         priorityOfTestThread = epicsThreadGetPrioritySelf ();
@@ -1445,7 +1445,7 @@ static void multiSubscrDestroyNoLateCallbackThread ( void * pParm )
 }
 
 /*
- * verify that, in a preemtive callback mode client, a subscription callback never 
+ * verify that, in a preemtive callback mode client, a subscription callback never
  * comes after the subscription is destroyed
  */
 static void multiSubscrDestroyNoLateCallbackTest ( const char *pName, unsigned interestLevel )
@@ -1456,13 +1456,13 @@ static void multiSubscrDestroyNoLateCallbackTest ( const char *pName, unsigned i
 
     pTestData = calloc ( 1u, sizeof ( struct MultiSubscrDestroyNoLateCallbackTestData ) );
     verify ( pTestData );
-    pTestData->m_mutex = epicsMutexMustCreate (); 
+    pTestData->m_mutex = epicsMutexMustCreate ();
     pTestData->m_testDoneEvent = epicsEventMustCreate ( epicsEventEmpty );
     pTestData->m_pChanName = pName;
     pTestData->m_interestLevel = interestLevel;
     epicsThreadMustCreate (
                       "multiSubscrDestroyNoLateCallbackTest",
-                      epicsThreadPriorityLow, 
+                      epicsThreadPriorityLow,
                       epicsThreadGetStackSize ( epicsThreadStackMedium ),
                       multiSubscrDestroyNoLateCallbackThread,
                       pTestData );
@@ -1488,7 +1488,7 @@ static void multiSubscrDestroyNoLateCallbackTest ( const char *pName, unsigned i
  * 1) verify we can add many monitors at once
  * 2) verify that under heavy load the last monitor
  *      returned is the last modification sent
- * 3) attempt to delete monitors while many monitors 
+ * 3) attempt to delete monitors while many monitors
  *      are running
  */
 void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
@@ -1497,7 +1497,7 @@ void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     evid mid[1000];
     dbr_float_t temp, getResp;
     unsigned i;
-    
+
     showProgressBegin ( "multiSubscriptionDeleteTest", interestLevel );
 
     for ( i=0; i < NELEMENTS (mid); i++ ) {
@@ -1510,7 +1510,7 @@ void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
      * complete
      *
      * NOTE: this hopefully demonstrates that when the
-     * server is very busy with monitors the client 
+     * server is very busy with monitors the client
      * is still able to punch through with a request.
      */
     SEVCHK ( ca_get ( DBR_FLOAT,chan,&getResp ), NULL );
@@ -1521,7 +1521,7 @@ void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     /*
      * attempt to generate heavy event traffic before initiating
      * the monitor delete
-     */  
+     */
     if ( ca_write_access (chan) ) {
         for ( i=0; i < NELEMENTS (mid); i++ ) {
             temp = (float) i;
@@ -1532,12 +1532,12 @@ void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     showProgress ( interestLevel );
 
     /*
-     * without pausing begin deleting the event subscriptions 
+     * without pausing begin deleting the event subscriptions
      * while the queue is full
      *
-     * continue attempting to generate heavy event traffic 
-     * while deleting subscriptions with the hope that we will 
-     * deleting an event at the instant that its callback is 
+     * continue attempting to generate heavy event traffic
+     * while deleting subscriptions with the hope that we will
+     * deleting an event at the instant that its callback is
      * occurring
      */
     for ( i=0; i < NELEMENTS (mid); i++ ) {
@@ -1557,14 +1557,14 @@ void multiSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     SEVCHK ( ca_pend_io (timeoutToPendIO), NULL );
 
     showProgressEnd ( interestLevel );
-} 
+}
 
 
 /*
  * singleSubscriptionDeleteTest
  *
- * verify that we dont fail when we repeatedly create 
- * and delete only one subscription with a high level of 
+ * verify that we dont fail when we repeatedly create
+ * and delete only one subscription with a high level of
  * traffic on it
  */
 void singleSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
@@ -1573,7 +1573,7 @@ void singleSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     evid sid;
     dbr_float_t temp, getResp;
     unsigned i;
-    
+
     showProgressBegin ( "singleSubscriptionDeleteTest", interestLevel );
 
     for ( i=0; i < 1000; i++ ){
@@ -1595,14 +1595,14 @@ void singleSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
          * attempt to generate heavy event traffic before initiating
          * the monitor delete
          *
-         * try to interrupt the recv thread while it is processing 
+         * try to interrupt the recv thread while it is processing
          * incoming subscription updates
-         */  
+         */
         if ( ca_write_access (chan) ) {
             unsigned j = 0;
             while ( j < i ) {
                 temp = (float) j++;
-                SEVCHK ( ca_put (DBR_FLOAT, chan, &temp), 
+                SEVCHK ( ca_put (DBR_FLOAT, chan, &temp),
                     "singleSubscriptionDeleteTest - one of multiple puts" );
             }
             ca_flush_io ();
@@ -1612,7 +1612,7 @@ void singleSubscriptionDeleteTest ( chid chan, unsigned interestLevel  )
     }
 
     showProgressEnd ( interestLevel );
-} 
+}
 
 /*
  * channelClearWithEventTrafficTest
@@ -1626,13 +1626,13 @@ void channelClearWithEventTrafficTest ( const char *pName, unsigned interestLeve
     evid sid;
     dbr_float_t temp, getResp;
     unsigned i;
-    
+
     showProgressBegin ( "channelClearWithEventTrafficTest", interestLevel );
 
     for ( i=0; i < 1000; i++ ) {
         chid chan;
 
-        int status = ca_create_channel ( pName, 0, 0, 
+        int status = ca_create_channel ( pName, 0, 0,
             CA_PRIORITY_DEFAULT, &chan );
         status = ca_pend_io ( timeoutToPendIO );
         SEVCHK ( status, "channelClearWithEventTrafficTest: channel connect failed" );
@@ -1652,9 +1652,9 @@ void channelClearWithEventTrafficTest ( const char *pName, unsigned interestLeve
          * attempt to generate heavy event traffic before initiating
          * the channel delete
          *
-         * try to interrupt the recv thread while it is processing 
+         * try to interrupt the recv thread while it is processing
          * incoming subscription updates
-         */  
+         */
         if ( ca_write_access (chan) ) {
             unsigned j = 0;
             while ( j < i ) {
@@ -1669,7 +1669,7 @@ void channelClearWithEventTrafficTest ( const char *pName, unsigned interestLeve
     }
 
     showProgressEnd ( interestLevel );
-} 
+}
 
 
 
@@ -1679,7 +1679,7 @@ void selfDeleteEvent ( struct event_handler_args args )
 {
     int status;
     status = ca_clear_event ( globalEventID );
-    verify ( status == ECA_NORMAL ); 
+    verify ( status == ECA_NORMAL );
 }
 
 void eventClearTest ( chid chan )
@@ -1687,29 +1687,29 @@ void eventClearTest ( chid chan )
     int status;
     evid monix1, monix2, monix3;
 
-    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange, 
+    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange,
                 NULL, &monix1 );
     SEVCHK ( status, NULL );
 
     status = ca_clear_event ( monix1 );
     SEVCHK ( status, NULL );
 
-    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange, 
+    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange,
                 NULL, &monix1 );
     SEVCHK ( status, NULL );
 
-    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange, 
+    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange,
                 NULL, &monix2);
     SEVCHK (status, NULL);
 
     status = ca_clear_event ( monix2 );
     SEVCHK ( status, NULL);
 
-    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange, 
+    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange,
                 NULL, &monix2);
     SEVCHK ( status, NULL );
 
-    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange, 
+    status = ca_add_event ( DBR_FLOAT, chan, noopSubscriptionStateChange,
                 NULL, &monix3);
     SEVCHK ( status, NULL );
 
@@ -1722,7 +1722,7 @@ void eventClearTest ( chid chan )
     status = ca_clear_event ( monix3 );
     SEVCHK ( status, NULL);
 
-    status = ca_add_event ( DBR_FLOAT, chan, selfDeleteEvent, 
+    status = ca_add_event ( DBR_FLOAT, chan, selfDeleteEvent,
                 0, &globalEventID );
     SEVCHK ( status, NULL );
 }
@@ -1739,7 +1739,7 @@ void arrayEventExceptionNotify ( struct event_handler_args args )
     if ( args.status == ECA_NORMAL ) {
         printf (
             "arrayEventExceptionNotify: expected "
-            "exception but didnt receive one against \"%s\" \n", 
+            "exception but didnt receive one against \"%s\" \n",
             ca_name ( args.chid ) );
     }
     else {
@@ -1765,8 +1765,8 @@ void exceptionTest ( chid chan, unsigned interestLevel )
 
         pRS = malloc ( ca_element_count (chan) * sizeof (*pRS) );
         verify ( pRS );
-        status = ca_array_get ( DBR_PUT_ACKT, 
-            ca_element_count (chan), chan, pRS ); 
+        status = ca_array_get ( DBR_PUT_ACKT,
+            ca_element_count (chan), chan, pRS );
         SEVCHK  ( status, "array read request failed" );
         ca_pend_io ( 1e-5 );
         epicsThreadSleep ( 0.1 );
@@ -1787,8 +1787,8 @@ void exceptionTest ( chid chan, unsigned interestLevel )
      */
     {
         arrayEventExceptionNotifyComplete = 0u;
-        status = ca_array_get_callback ( DBR_PUT_ACKT, 
-            ca_element_count (chan), chan, arrayEventExceptionNotify, 0 ); 
+        status = ca_array_get_callback ( DBR_PUT_ACKT,
+            ca_element_count (chan), chan, arrayEventExceptionNotify, 0 );
         if ( status != ECA_NORMAL ) {
             verify ( status == ECA_BADTYPE || status == ECA_GETFAIL );
             arrayEventExceptionNotifyComplete = 1;
@@ -1811,8 +1811,8 @@ void exceptionTest ( chid chan, unsigned interestLevel )
         evid id;
 
         arrayEventExceptionNotifyComplete = 0u;
-        status = ca_add_array_event ( DBR_PUT_ACKT, ca_element_count ( chan ), 
-                        chan, arrayEventExceptionNotify, 0, 0.0, 0.0, 0.0, &id ); 
+        status = ca_add_array_event ( DBR_PUT_ACKT, ca_element_count ( chan ),
+                        chan, arrayEventExceptionNotify, 0, 0.0, 0.0, 0.0, &id );
         if ( status != ECA_NORMAL ) {
             verify ( status == ECA_BADTYPE || status == ECA_GETFAIL );
             arrayEventExceptionNotifyComplete = 1;
@@ -1846,8 +1846,8 @@ void exceptionTest ( chid chan, unsigned interestLevel )
         for ( i = 0; i < ca_element_count (chan); i++ ) {
             strcpy ( pWS[i], "@#$%" );
         }
-        status = ca_array_put ( DBR_STRING, 
-            ca_element_count (chan), chan, pWS ); 
+        status = ca_array_put ( DBR_STRING,
+            ca_element_count (chan), chan, pWS );
         if ( status != ECA_NORMAL ) {
             verify ( status == ECA_BADTYPE || status == ECA_PUTFAIL );
             acctstExceptionCount++; /* local PV case */
@@ -1879,9 +1879,9 @@ void exceptionTest ( chid chan, unsigned interestLevel )
             strcpy ( pWS[i], "@#$%" );
         }
         arrayEventExceptionNotifyComplete = 0u;
-        status = ca_array_put_callback ( DBR_STRING, 
+        status = ca_array_put_callback ( DBR_STRING,
             ca_element_count (chan), chan, pWS,
-            arrayEventExceptionNotify, 0); 
+            arrayEventExceptionNotify, 0);
         if ( status != ECA_NORMAL ) {
             arrayEventExceptionNotifyComplete = 1;
         }
@@ -1924,7 +1924,7 @@ void arrayWriteNotify ( struct event_handler_args args )
         arrayWriteNotifyComplete = 1;
     }
     else {
-       printf ( "arrayWriteNotify: update failed for \"%s\" because \"%s\"", 
+       printf ( "arrayWriteNotify: update failed for \"%s\" because \"%s\"",
             ca_name ( args.chid ), ca_message ( args.status ) );
     }
 }
@@ -1956,15 +1956,15 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
         pWF[i] =  rand ();
         pRF[i] = - pWF[i];
     }
-    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( chan ), 
-                    chan, pWF ); 
+    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( chan ),
+                    chan, pWF );
     SEVCHK ( status, "array write request failed" );
 
     /*
      * read back the array
      */
-    status = ca_array_get ( DBR_DOUBLE,  ca_element_count (chan), 
-                    chan, pRF ); 
+    status = ca_array_get ( DBR_DOUBLE,  ca_element_count (chan),
+                    chan, pRF );
     SEVCHK ( status, "array read request failed" );
     status = ca_pend_io ( timeoutToPendIO );
     SEVCHK ( status, "array read failed" );
@@ -1991,8 +1991,8 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
 
             pRS = malloc ( ca_element_count (chan) * MAX_STRING_SIZE );
             verify ( pRS );
-            status = ca_array_get ( DBR_STRING, 
-                ca_element_count (chan), chan, pRS ); 
+            status = ca_array_get ( DBR_STRING,
+                ca_element_count (chan), chan, pRS );
             SEVCHK  ( status, "array read request failed" );
             status = ca_pend_io ( timeoutToPendIO );
             SEVCHK ( status, "array read failed" );
@@ -2010,11 +2010,11 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
         pWF[i] =  rand ();
         pRF[i] = - pWF[i];
     }
-    status = ca_array_put_callback ( DBR_DOUBLE, ca_element_count (chan), 
-                    chan, pWF, arrayWriteNotify, 0 ); 
+    status = ca_array_put_callback ( DBR_DOUBLE, ca_element_count (chan),
+                    chan, pWF, arrayWriteNotify, 0 );
     SEVCHK ( status, "array write notify request failed" );
-    status = ca_array_get_callback ( DBR_DOUBLE, ca_element_count (chan), 
-                    chan, arrayReadNotify, pWF ); 
+    status = ca_array_get_callback ( DBR_DOUBLE, ca_element_count (chan),
+                    chan, arrayReadNotify, pWF );
     SEVCHK  ( status, "array read notify request failed" );
     ca_flush_io ();
     while ( ! arrayWriteNotifyComplete || ! arrayReadNotifyComplete ) {
@@ -2030,11 +2030,11 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
         pRF[i] = - pWF[i];
     }
     arrayReadNotifyComplete = 0;
-    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( chan ), 
-                    chan, pWF ); 
+    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( chan ),
+                    chan, pWF );
     SEVCHK ( status, "array write notify request failed" );
-    status = ca_add_array_event ( DBR_DOUBLE, ca_element_count ( chan ), 
-                    chan, arrayReadNotify, pWF, 0.0, 0.0, 0.0, &id ); 
+    status = ca_add_array_event ( DBR_DOUBLE, ca_element_count ( chan ),
+                    chan, arrayReadNotify, pWF, 0.0, 0.0, 0.0, &id );
     SEVCHK ( status, "array subscription request failed" );
     ca_flush_io ();
     while ( ! arrayReadNotifyComplete ) {
@@ -2052,8 +2052,8 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
         acctstExceptionCount = 0u;
         status = ca_add_exception_event ( acctstExceptionNotify, 0 );
         SEVCHK ( status, "exception notify install failed" );
-        status = ca_array_get ( DBR_DOUBLE, 
-            ca_element_count (chan)+1, chan, pRF ); 
+        status = ca_array_get ( DBR_DOUBLE,
+            ca_element_count (chan)+1, chan, pRF );
         if ( status == ECA_NORMAL ) {
             ca_poll ();
             while ( acctstExceptionCount < 1u ) {
@@ -2076,7 +2076,7 @@ void arrayTest ( chid chan, unsigned maxArrayBytes, unsigned interestLevel )
     showProgressEnd ( interestLevel );
 }
 
-/* 
+/*
  * verify that unequal send/recv buffer sizes work
  * (a bug related to this test was detected in early R3.14)
  *
@@ -2115,8 +2115,8 @@ void unequalServerBufferSizeTest ( const char * pName, unsigned interestLevel )
     pWF = (dbr_double_t *) calloc ( ca_element_count (newChan), sizeof (*pWF) );
     verify ( pWF != NULL );
 
-    status = ca_array_get ( DBR_DOUBLE, ca_element_count ( newChan ), 
-                newChan, pRF ); 
+    status = ca_array_get ( DBR_DOUBLE, ca_element_count ( newChan ),
+                newChan, pRF );
     status = ca_pend_io ( timeoutToPendIO );
     verify ( status == ECA_NORMAL );
     status = ca_clear_channel ( newChan );
@@ -2131,11 +2131,11 @@ void unequalServerBufferSizeTest ( const char * pName, unsigned interestLevel )
 
     showProgress ( interestLevel );
 
-    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( newChan ), 
-                newChan, pWF ); 
+    status = ca_array_put ( DBR_DOUBLE, ca_element_count ( newChan ),
+                newChan, pWF );
     verify ( status == ECA_NORMAL );
-    status = ca_array_get ( DBR_DOUBLE, 1, 
-                newChan, pRF ); 
+    status = ca_array_get ( DBR_DOUBLE, 1,
+                newChan, pRF );
     verify ( status == ECA_NORMAL );
     status = ca_pend_io ( timeoutToPendIO );
     verify ( status == ECA_NORMAL );
@@ -2205,9 +2205,9 @@ void verifyDataTypeMacros (void)
     verify ( dbf_type_is_valid ( DBF_SHORT ) );
     {
         int dataType = -1;
-        dbf_text_to_type ( "DBF_SHORT", dataType ); 
+        dbf_text_to_type ( "DBF_SHORT", dataType );
         verify ( dataType == DBF_SHORT );
-        dbr_text_to_type ( "DBR_CLASS_NAME", dataType ); 
+        dbr_text_to_type ( "DBR_CLASS_NAME", dataType );
         verify ( dataType == DBR_CLASS_NAME );
     }
 }
@@ -2225,7 +2225,7 @@ void updateTestEvent ( struct event_handler_args args )
 {
     eventTest *pET = (eventTest *) args.usr;
     struct dbr_gr_float *pGF = (struct dbr_gr_float *) args.dbr;
-    pET->lastValue = pGF->value; 
+    pET->lastValue = pGF->value;
     pET->count++;
 }
 
@@ -2246,7 +2246,7 @@ void clearChannelInGetCallbackTest ( const char *pName, unsigned level )
     unsigned i;
     chid chan;
     int status;
-    
+
     showProgressBegin ( "clearChannelInGetCallbackTest", level );
 
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
@@ -2259,15 +2259,15 @@ void clearChannelInGetCallbackTest ( const char *pName, unsigned level )
 
     status = ca_pend_io ( timeoutToPendIO );
     SEVCHK ( status, "clearChannelInGetCallbackTest connect channel" );
-    
+
     status = ca_get_callback ( DBR_DOUBLE, chan, callbackClearsChannel, 0 );
     SEVCHK ( status, "clearChannelInGetCallbackTest get callback" );
-    
+
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
         ca_pend_event ( 0.1 );
         verify ( i < 100 );
     }
-    
+
     showProgressEnd ( level );
 }
 
@@ -2277,7 +2277,7 @@ void clearChannelInPutCallbackTest ( const char *pName, unsigned level )
     const dbr_double_t value = 1.1;
     chid chan;
     int status;
-    
+
     showProgressBegin ( "clearChannelInPutCallbackTest", level );
 
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
@@ -2291,15 +2291,15 @@ void clearChannelInPutCallbackTest ( const char *pName, unsigned level )
     status = ca_pend_io ( timeoutToPendIO );
     SEVCHK ( status, "clearChannelInPutCallbackTest connect channel" );
 
-    status = ca_put_callback ( DBR_DOUBLE, chan, & value, 
+    status = ca_put_callback ( DBR_DOUBLE, chan, & value,
                         callbackClearsChannel, 0 );
     SEVCHK ( status, "clearChannelInPutCallbackTest get callback" );
-    
+
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
         ca_pend_event ( 0.1 );
         verify ( i < 100 );
     }
-    
+
     showProgressEnd ( level );
 }
 
@@ -2308,7 +2308,7 @@ void clearChannelInSubscrCallbackTest ( const char *pName, unsigned level )
     unsigned i;
     chid chan;
     int status;
-    
+
     showProgressBegin ( "clearChannelInSubscrCallbackTest", level );
 
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
@@ -2321,8 +2321,8 @@ void clearChannelInSubscrCallbackTest ( const char *pName, unsigned level )
 
     status = ca_pend_io ( timeoutToPendIO );
     SEVCHK ( status, "clearChannelInSubscrCallbackTest connect channel" );
-                        
-    status = ca_create_subscription ( DBR_DOUBLE, 1, chan, 
+
+    status = ca_create_subscription ( DBR_DOUBLE, 1, chan,
         DBE_VALUE, callbackClearsChannel, 0, 0 );
     SEVCHK ( status, "clearChannelInSubscrCallbackTest subscribe" );
 
@@ -2330,18 +2330,18 @@ void clearChannelInSubscrCallbackTest ( const char *pName, unsigned level )
         ca_pend_event ( 0.1 );
         verify ( i < 100 );
     }
-    
+
     showProgressEnd ( level );
 }
 
-void monitorAddConnectionCallback ( struct connection_handler_args args ) 
+void monitorAddConnectionCallback ( struct connection_handler_args args )
 {
     if ( args.op == CA_OP_CONN_UP ) {
         unsigned * pEventCount = ( unsigned * ) ca_puser ( args.chid );
         int status;
         verify ( *pEventCount == 0u );
         (*pEventCount)++;
-        status = ca_create_subscription ( DBR_DOUBLE, 1, 
+        status = ca_create_subscription ( DBR_DOUBLE, 1,
             args.chid, DBE_VALUE, nUpdatesTester, ca_puser ( args.chid ), 0 );
         SEVCHK ( status, "monitorAddConnectionCallback create subscription" );
     }
@@ -2363,7 +2363,7 @@ void monitorAddConnectionCallbackTest ( const char *pName, unsigned interestLeve
     int status;
     unsigned eventCount = 0u;
     unsigned getCallbackCount = 0u;
-    
+
     showProgressBegin ( "monitorAddConnectionCallbackTest", interestLevel );
 
     for ( i = 0; ca_get_ioc_connection_count () > 0 ; i++ ) {
@@ -2371,7 +2371,7 @@ void monitorAddConnectionCallbackTest ( const char *pName, unsigned interestLeve
         verify ( i < 100 );
     }
 
-    status = ca_create_channel ( pName, 
+    status = ca_create_channel ( pName,
         monitorAddConnectionCallback, &eventCount, 0, & chan );
     SEVCHK ( status, "monitorAddConnectionCallbackTest create channel" );
 
@@ -2379,7 +2379,7 @@ void monitorAddConnectionCallbackTest ( const char *pName, unsigned interestLeve
         ca_pend_event ( 0.1 );
     }
     verify ( eventCount >= 2u );
-    
+
     status = ca_get_callback ( DBR_DOUBLE, chan, nUpdatesTester, &getCallbackCount );
     SEVCHK ( status, "monitorAddConnectionCallback get callback" );
     while ( getCallbackCount == 0 ) {
@@ -2390,7 +2390,7 @@ void monitorAddConnectionCallbackTest ( const char *pName, unsigned interestLeve
 
     status = ca_clear_channel ( chan );
     SEVCHK ( status, "monitorAddConnectionCallbackTest clear channel" );
-    
+
     status = ca_flush_io ();
     SEVCHK ( status, "monitorAddConnectionCallbackTest flush" );
 
@@ -2423,7 +2423,7 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
         printf ("skipped monitorUpdateTest test - not an analog type\n");
         return;
     }
-    
+
     showProgressBegin ( "monitorUpdateTest", interestLevel );
 
     /*
@@ -2444,12 +2444,12 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
      * complete
      *
      * NOTE: this hopefully demonstrates that when the
-     * server is very busy with monitors the client 
+     * server is very busy with monitors the client
      * is still able to punch through with a request.
      */
     SEVCHK ( ca_get ( DBR_FLOAT, chan, &getResp) ,NULL );
     SEVCHK ( ca_pend_io ( timeoutToPendIO ) ,NULL );
-            
+
     showProgress ( interestLevel );
 
     /*
@@ -2483,7 +2483,7 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
     /*
      * attempt to uncover problems where the last event isnt sent
      * and hopefully get into a flow control situation
-     */   
+     */
     prevPassCount = 0u;
     for ( i = 0; i < 10; i++ ) {
         for ( j = 0; j < NELEMENTS(test); j++ ) {
@@ -2492,7 +2492,7 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
             test[j].lastValue = -1.0f;
             SEVCHK ( ca_add_event ( DBR_GR_FLOAT, chan, updateTestEvent,
                 &test[j], &test[j].id ) , NULL );
-        } 
+        }
 
         for ( j = 0; j <= i; j++ ) {
             temp = monitorUpdateTestPattern ( j );
@@ -2522,7 +2522,7 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
             ca_poll (); /* emulate typical GUI */
             for ( j = 0; j < NELEMENTS ( test ); j++ ) {
                 /*
-                 * we shouldnt see old monitors because 
+                 * we shouldnt see old monitors because
                  * we resubscribed
                  */
                 verify ( test[j].count <= i + 2 );
@@ -2562,12 +2562,12 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
     showProgress ( interestLevel );
 
     /*
-     * delete the event subscriptions 
+     * delete the event subscriptions
      */
     for ( i = 0; i < NELEMENTS ( test ); i++ ) {
         SEVCHK ( ca_clear_event ( test[i].id ), NULL );
     }
-        
+
     /*
      * force all of the clear event requests to
      * complete
@@ -2578,7 +2578,7 @@ void monitorUpdateTest ( chid chan, unsigned interestLevel )
     /* printf ( "flow control bypassed %u events\n", flowCtrlCount ); */
 
     showProgressEnd ( interestLevel );
-} 
+}
 
 void verifyReasonableBeaconPeriod ( chid chan, unsigned interestLevel )
 {
@@ -2594,7 +2594,7 @@ void verifyReasonableBeaconPeriod ( chid chan, unsigned interestLevel )
             ca_beacon_anomaly_count () );
 
         beaconPeriod = ca_beacon_period ( chan );
-        printf ( "Estimated beacon period for channel %s = %g sec.\n", 
+        printf ( "Estimated beacon period for channel %s = %g sec.\n",
             ca_name ( chan ), beaconPeriod );
 
         watchDogDelay = ca_receive_watchdog_delay ( chan );
@@ -2603,8 +2603,8 @@ void verifyReasonableBeaconPeriod ( chid chan, unsigned interestLevel )
         printf ( "busy: receive watchdog for \"%s\" expires in %g sec.\n",
             ca_name ( chan ), watchDogDelay );
 
-        /* 
-         * let one default connection timeout go by w/o receive activity 
+        /*
+         * let one default connection timeout go by w/o receive activity
          * so we can see if beacons reset the watchdog
          */
         for ( i = 0u; i < 15u; i++ ) {
@@ -2667,18 +2667,18 @@ void verifyTimeStamps ( chid chan, unsigned interestLevel )
     status = ca_pend_io ( timeoutToPendIO );
     verify ( status == ECA_NORMAL );
 
-    length = epicsTimeToStrftime ( buf, sizeof ( buf ), 
+    length = epicsTimeToStrftime ( buf, sizeof ( buf ),
         "%a %b %d %Y %H:%M:%S.%f", & first.stamp );
     verify ( length );
-    printf ("Processing time of channel \"%s\" was \"%s\"\n", 
+    printf ("Processing time of channel \"%s\" was \"%s\"\n",
         ca_name ( chan ), buf );
 
     diff = epicsTimeDiffInSeconds ( & last.stamp, & first.stamp );
-    printf ("Time difference between two successive reads was %g sec\n", 
+    printf ("Time difference between two successive reads was %g sec\n",
         diff );
 
     diff = epicsTimeDiffInSeconds ( & first.stamp, & localTime );
-    printf ("Time difference between client and server %g sec\n", 
+    printf ("Time difference between client and server %g sec\n",
         diff );
 
     showProgressEnd ( interestLevel );
@@ -2700,7 +2700,7 @@ void verifyChannelPriorities ( const char *pName, unsigned interestLevel )
         double value;
         chid chan0, chan1;
         unsigned priority0, priority1;
-        
+
         priority0 = ( i * ( CA_PRIORITY_MAX - CA_PRIORITY_MIN ) ) / nPrio;
         priority0 += CA_PRIORITY_MIN;
         if ( priority0 > CA_PRIORITY_MAX ) {
@@ -2713,11 +2713,11 @@ void verifyChannelPriorities ( const char *pName, unsigned interestLevel )
             priority1 = CA_PRIORITY_MAX;
         }
 
-        status = ca_create_channel ( pName, 0, 0, 
+        status = ca_create_channel ( pName, 0, 0,
             priority0, &chan0 );
         SEVCHK ( status, "prioritized channel create failed" );
 
-        status = ca_create_channel ( pName, 0, 0, 
+        status = ca_create_channel ( pName, 0, 0,
             priority1, &chan1 );
         SEVCHK ( status, "prioritized channel create failed" );
 
@@ -2751,8 +2751,8 @@ void verifyChannelPriorities ( const char *pName, unsigned interestLevel )
     showProgressEnd ( interestLevel );
 }
 
-void verifyTearDownWhenChannelConnected ( const char * pName, 
-        enum ca_preemptive_callback_select select, 
+void verifyTearDownWhenChannelConnected ( const char * pName,
+        enum ca_preemptive_callback_select select,
         unsigned interestLevel )
 {
     static const unsigned chanCount = 20;
@@ -2761,15 +2761,15 @@ void verifyTearDownWhenChannelConnected ( const char * pName,
     chid * const pChans = (chid * const) calloc ( chanCount, sizeof ( *pChans ) );
     double * const pValues = (double * const) calloc ( chanCount, sizeof ( *pValues ) );
     unsigned i, j;
-    
+
     verify ( pChans && pValues );
-    
+
     showProgressBegin ( "verifyTearDownWhenChannelConnected", interestLevel );
 
     for ( i = 0u; i < loopCount; i++ ) {
         int status;
         ca_context_create ( select );
-        
+
         for ( j = 0; j < chanCount; j++ ) {
             status = ca_create_channel ( pName, 0, 0, 0, & pChans[j] );
             SEVCHK ( status, "immediate tear down channel create failed" );
@@ -2782,11 +2782,11 @@ void verifyTearDownWhenChannelConnected ( const char * pName,
             status = ca_get ( DBR_DOUBLE, pChans[j], &pValues[j] );
             SEVCHK ( status, "immediate tear down channel get failed" );
         }
-        
+
         status = ca_pend_io ( timeoutToPendIO );
         SEVCHK ( status, "immediate tear down get pend io failed" );
 
-        ca_context_destroy ();    
+        ca_context_destroy ();
     }
 
     ca_context_create ( select );
@@ -2798,8 +2798,8 @@ void verifyTearDownWhenChannelConnected ( const char * pName,
 }
 
 
-void verifyImmediateTearDown ( const char * pName, 
-        enum ca_preemptive_callback_select select, 
+void verifyImmediateTearDown ( const char * pName,
+        enum ca_preemptive_callback_select select,
         unsigned interestLevel )
 {
     int i;
@@ -2817,8 +2817,8 @@ void verifyImmediateTearDown ( const char * pName,
         status = ca_pend_io ( timeoutToPendIO );
         SEVCHK ( status, "immediate tear down channel connect failed" );
         verify ( status == ECA_NORMAL );
-        /* 
-         * verify that puts pending when we call ca_task_exit() 
+        /*
+         * verify that puts pending when we call ca_task_exit()
          * get flushed out
          */
         if ( i > 0 ) {
@@ -2868,12 +2868,12 @@ void fdRegCB ( void * parg, int fd, int opened )
 
     fdctx * mgrCtx = ( fdctx * ) parg;
     if ( opened ) {
-        status = fdmgr_add_callback ( 
+        status = fdmgr_add_callback (
             mgrCtx, fd, fdi_read, fdcb, 0 );
         verify ( status >= 0 );
     }
     else {
-        status = fdmgr_clear_callback ( 
+        status = fdmgr_clear_callback (
             mgrCtx, fd, fdi_read );
         verify ( status >= 0 );
     }
@@ -2893,21 +2893,21 @@ typedef struct {
     unsigned m_interestLevel;
 } MultiThreadSubscrTest;
 
-static void testMultithreadSubscrSubscrCallback 
+static void testMultithreadSubscrSubscrCallback
                         ( struct event_handler_args eha )
 {
     const epicsEventId firstUpdateEvent = ( epicsEventId ) eha.usr;
     epicsEventSignal ( firstUpdateEvent );
 }
 
-static void testMultithreadSubscrCreateSubscr ( void * pParm ) 
+static void testMultithreadSubscrCreateSubscr ( void * pParm )
 {
     static unsigned nElem = 0;
     int testComplete = FALSE;
     evid id;
     epicsEventId firstUpdateEvent;
-    epicsEventWaitStatus eventWaitStatus;   
-    MultiThreadSubscrTest * const pMultiThreadSubscrTest = 
+    epicsEventWaitStatus eventWaitStatus;
+    MultiThreadSubscrTest * const pMultiThreadSubscrTest =
                                 ( MultiThreadSubscrTest * ) pParm;
 
     /* this is required for the ca_flush below to work correctly */
@@ -2915,19 +2915,19 @@ static void testMultithreadSubscrCreateSubscr ( void * pParm )
     verify ( status == ECA_NORMAL );
     firstUpdateEvent = epicsEventMustCreate ( epicsEventEmpty );
     verify ( firstUpdateEvent );
-    status = ca_create_subscription ( 
-                            DBR_TIME_LONG, 
-                            nElem, 
-                            pMultiThreadSubscrTest->m_chan, 
-                            DBE_VALUE, 
-                            testMultithreadSubscrSubscrCallback, 
-                            firstUpdateEvent, 
+    status = ca_create_subscription (
+                            DBR_TIME_LONG,
+                            nElem,
+                            pMultiThreadSubscrTest->m_chan,
+                            DBE_VALUE,
+                            testMultithreadSubscrSubscrCallback,
+                            firstUpdateEvent,
                             & id );
     verify ( status == ECA_NORMAL );
     status = ca_flush_io ();
     verify ( status == ECA_NORMAL );
     /* wait for first update */
-    eventWaitStatus = epicsEventWaitWithTimeout ( 
+    eventWaitStatus = epicsEventWaitWithTimeout (
                             firstUpdateEvent, 60.0 * 10 );
     verify ( eventWaitStatus ==  epicsEventWaitOK );
     epicsEventDestroy ( firstUpdateEvent );
@@ -2935,7 +2935,7 @@ static void testMultithreadSubscrCreateSubscr ( void * pParm )
     verify ( status == ECA_NORMAL );
     epicsMutexMustLock ( pMultiThreadSubscrTest->m_mutex );
     pMultiThreadSubscrTest->m_nUpdatesReceived++;
-    testComplete = ( pMultiThreadSubscrTest->m_nUpdatesReceived == 
+    testComplete = ( pMultiThreadSubscrTest->m_nUpdatesReceived ==
                     pMultiThreadSubscrTest->m_nUpdatesRequired );
     pMultiThreadSubscrTest->m_testComplete = testComplete;
     epicsMutexUnlock ( pMultiThreadSubscrTest->m_mutex );
@@ -2946,10 +2946,10 @@ static void testMultithreadSubscrCreateSubscr ( void * pParm )
 
 void testMultithreadSubscrConnHandler ( struct connection_handler_args args )
 {
-    MultiThreadSubscrTest * const pMultiThreadSubscrTest = 
+    MultiThreadSubscrTest * const pMultiThreadSubscrTest =
                         ( MultiThreadSubscrTest * ) ca_puser ( args.chid );
     epicsMutexMustLock ( pMultiThreadSubscrTest->m_mutex );
-    if ( !pMultiThreadSubscrTest->m_testInitiated && 
+    if ( !pMultiThreadSubscrTest->m_testInitiated &&
             args.op == CA_OP_CONN_UP ) {
         int i;
         pMultiThreadSubscrTest->m_testInitiated = TRUE;
@@ -2957,10 +2957,10 @@ void testMultithreadSubscrConnHandler ( struct connection_handler_args args )
             char threadname[64];
             epicsThreadId threadId;
             sprintf(threadname, "testSubscr%06u", i);
-            threadId = epicsThreadCreate ( threadname, 
-                        epicsThreadPriorityMedium, 
-                        epicsThreadGetStackSize(epicsThreadStackSmall), 
-                        testMultithreadSubscrCreateSubscr, 
+            threadId = epicsThreadCreate ( threadname,
+                        epicsThreadPriorityMedium,
+                        epicsThreadGetStackSize(epicsThreadStackSmall),
+                        testMultithreadSubscrCreateSubscr,
                         pMultiThreadSubscrTest );
             verify ( threadId );
         }
@@ -2970,7 +2970,7 @@ void testMultithreadSubscrConnHandler ( struct connection_handler_args args )
 
 void testMultithreadSubscr ( void * pParm )
 {
-    MultiThreadSubscrTest * const pMultiThreadSubscrTest = 
+    MultiThreadSubscrTest * const pMultiThreadSubscrTest =
                                 ( MultiThreadSubscrTest * ) pParm;
     int status;
     unsigned i;
@@ -2983,11 +2983,11 @@ void testMultithreadSubscr ( void * pParm )
                 pMultiThreadSubscrTest->m_chanName,
                 testMultithreadSubscrConnHandler,
                 pMultiThreadSubscrTest,
-                CA_PRIORITY_MIN, 
+                CA_PRIORITY_MIN,
                 & pMultiThreadSubscrTest->m_chan );
     verify ( status == ECA_NORMAL );
 
-    showProgressBegin ( "verifyMultithreadSubscr", 
+    showProgressBegin ( "verifyMultithreadSubscr",
             pMultiThreadSubscrTest->m_interestLevel );
     i = 0;
     while ( TRUE ) {
@@ -2999,11 +2999,11 @@ void testMultithreadSubscr ( void * pParm )
         if ( success ) {
             break;
         }
-        eventWaitStatus = epicsEventWaitWithTimeout ( 
+        eventWaitStatus = epicsEventWaitWithTimeout (
                             pMultiThreadSubscrTest->m_testCompleteEvent, 0.1 );
-        verify ( eventWaitStatus ==  epicsEventWaitOK || 
+        verify ( eventWaitStatus ==  epicsEventWaitOK ||
                 eventWaitStatus ==  epicsEventWaitTimeout );
-        if ( i++ % 100 == 0u ) 
+        if ( i++ % 100 == 0u )
             showProgress ( pMultiThreadSubscrTest->m_interestLevel );
         verify ( i < 1000 );
     }
@@ -3023,33 +3023,33 @@ void verifyMultithreadSubscr ( const char * pName, unsigned interestLevel )
 {
     static unsigned nSubscr = 3000;
     epicsThreadId threadId;
-    MultiThreadSubscrTest * const pMultiThreadSubscrTest = 
-                                (MultiThreadSubscrTest*) calloc ( 1, 
+    MultiThreadSubscrTest * const pMultiThreadSubscrTest =
+                                (MultiThreadSubscrTest*) calloc ( 1,
                                     sizeof ( MultiThreadSubscrTest ) );
     verify ( pMultiThreadSubscrTest);
     pMultiThreadSubscrTest->m_mutex = epicsMutexMustCreate ();
     verify ( pMultiThreadSubscrTest->m_mutex );
-    pMultiThreadSubscrTest->m_testCompleteEvent = 
+    pMultiThreadSubscrTest->m_testCompleteEvent =
                 epicsEventMustCreate ( epicsEventEmpty );
     verify ( pMultiThreadSubscrTest->m_testCompleteEvent );
-    pMultiThreadSubscrTest->m_threadExitEvent = 
+    pMultiThreadSubscrTest->m_threadExitEvent =
                 epicsEventMustCreate ( epicsEventEmpty );
     verify ( pMultiThreadSubscrTest->m_threadExitEvent );
-    strncpy ( pMultiThreadSubscrTest->m_chanName, pName, 
+    strncpy ( pMultiThreadSubscrTest->m_chanName, pName,
             sizeof ( pMultiThreadSubscrTest->m_chanName ) );
     pMultiThreadSubscrTest->m_chanName
         [ sizeof ( pMultiThreadSubscrTest->m_chanName ) - 1u ] = '\0';
     pMultiThreadSubscrTest->m_nUpdatesRequired = nSubscr;
     pMultiThreadSubscrTest->m_interestLevel = interestLevel;
-    threadId = epicsThreadCreate ( 
-                "testMultithreadSubscr", 
-                epicsThreadPriorityMedium, 
-                epicsThreadGetStackSize(epicsThreadStackSmall), 
+    threadId = epicsThreadCreate (
+                "testMultithreadSubscr",
+                epicsThreadPriorityMedium,
+                epicsThreadGetStackSize(epicsThreadStackSmall),
                 testMultithreadSubscr, pMultiThreadSubscrTest );
     verify ( threadId );
     {
         epicsEventWaitStatus eventWaitStatus;
-        eventWaitStatus = epicsEventWaitWithTimeout ( 
+        eventWaitStatus = epicsEventWaitWithTimeout (
                 pMultiThreadSubscrTest->m_threadExitEvent, 1000.0 );
         verify  ( eventWaitStatus == epicsEventWaitOK );
     }
@@ -3068,7 +3068,7 @@ void fdManagerVerify ( const char * pName, unsigned interestLevel )
     evid subscription;
     unsigned eventCount = 0u;
     epicsTimeStamp begin, end;
-    
+
     mgrCtx = fdmgr_init ();
     verify ( mgrCtx );
 
@@ -3089,7 +3089,7 @@ void fdManagerVerify ( const char * pName, unsigned interestLevel )
 
     showProgress ( interestLevel );
 
-    status = ca_add_event ( DBR_FLOAT, newChan, 
+    status = ca_add_event ( DBR_FLOAT, newChan,
         nUpdatesTester, & eventCount,  & subscription );
     verify ( status == ECA_NORMAL );
 
@@ -3142,7 +3142,7 @@ void fdManagerVerify ( const char * pName, unsigned interestLevel )
     showProgressEnd ( interestLevel );
 }
 
-void verifyConnectWithDisconnectedChannels ( 
+void verifyConnectWithDisconnectedChannels (
     const char *pName, unsigned interestLevel )
 {
     int status;
@@ -3171,11 +3171,11 @@ void verifyConnectWithDisconnectedChannels (
     status = ca_create_channel ( pName, 0, 0, 0, & validChan );
     verify ( status == ECA_NORMAL );
 
-    /* 
-     * we should be able to connect to a valid 
+    /*
+     * we should be able to connect to a valid
      * channel within a reasonable delay even
-     * though there is one permanently 
-     * diasconnected channel 
+     * though there is one permanently
+     * diasconnected channel
      */
     status = ca_pend_io ( timeoutToPendIO );
     verify ( status == ECA_NORMAL );
@@ -3205,7 +3205,7 @@ void noopExceptionCallback ( struct exception_handler_args args )
 {
 }
 
-void verifyDisconnect ( 
+void verifyDisconnect (
     const char * pName, unsigned interestLevel )
 {
     int disconnectFlag = 0;
@@ -3214,8 +3214,8 @@ void verifyDisconnect (
     chid chan1;
     int status;
 
-    status = ca_create_channel  ( 
-        pName, verifyClearChannelOnDisconnectCallback, 
+    status = ca_create_channel  (
+        pName, verifyClearChannelOnDisconnectCallback,
         & disconnectFlag, 0, & chan0 );
     SEVCHK ( status, NULL );
 
@@ -3256,7 +3256,7 @@ void verifyDisconnect (
     fprintf ( stdout, "confirmed.\n" );
     /* channel cleared by disconnect handler */
 
-    status = ca_create_channel  ( 
+    status = ca_create_channel  (
         pName, 0, 0, 0, & chan1 );
     SEVCHK ( status, NULL );
 
@@ -3275,11 +3275,11 @@ void verifyDisconnect (
     SEVCHK ( status, NULL );
 }
 
-void verifyName ( 
+void verifyName (
     const char * pName, unsigned interestLevel )
 {
     chid chan;
-    int status = ca_create_channel  ( 
+    int status = ca_create_channel  (
                     pName, 0, 0, 0, & chan );
     SEVCHK ( status, NULL );
     if ( strcmp ( pName, ca_name ( chan ) ) != 0 ) {
@@ -3297,13 +3297,13 @@ void verifyContextRundownFlush ( const char * pName, unsigned interestLevel )
 
     for ( i=0u; i < 1000; i++ ) {
         const dbr_double_t stim = i;
-        
-        {  
+
+        {
             chid chan;
             int status;
             status = ca_context_create ( ca_disable_preemptive_callback );
             SEVCHK ( status, "context create failed" );
-            
+
             status = ca_create_channel  ( pName, 0, 0, 0, & chan );
             /*
              * currently in-memory channels cant be used with this test
@@ -3311,26 +3311,26 @@ void verifyContextRundownFlush ( const char * pName, unsigned interestLevel )
              */
             if ( status != ECA_UNAVAILINSERV ) {
                 SEVCHK ( status, NULL );
-                
+
                 status = ca_pend_io( timeoutToPendIO );
                 SEVCHK ( status, "channel connect failed" );
-                
+
                 status = ca_put ( DBR_DOUBLE, chan, & stim );
                 SEVCHK ( status, "channel put failed" );
-        
+
                 status = ca_clear_channel ( chan );
                 SEVCHK ( status, NULL );
             }
             ca_context_destroy ();
         }
-        
+
         {
             chid chan;
             int status;
             dbr_double_t resp;
             status = ca_context_create ( ca_disable_preemptive_callback );
             SEVCHK ( status, "context create failed" );
-           
+
             status = ca_create_channel  ( pName, 0, 0, 0, & chan );
             SEVCHK ( status, NULL );
             /*
@@ -3340,15 +3340,15 @@ void verifyContextRundownFlush ( const char * pName, unsigned interestLevel )
             if ( status != ECA_UNAVAILINSERV ) {
                 status = ca_pend_io( timeoutToPendIO );
                 SEVCHK ( status, "channel connect failed" );
-        
+
                 status = ca_get ( DBR_DOUBLE, chan, & resp );
                 SEVCHK ( status, "channel get failed" );
-        
+
                 status = ca_pend_io ( timeoutToPendIO );
                 SEVCHK ( status, "get, pend io failed" );
-                
+
                 verify ( stim == resp );
-        
+
                 status = ca_clear_channel ( chan );
                 SEVCHK ( status, NULL );
             }
@@ -3359,11 +3359,11 @@ void verifyContextRundownFlush ( const char * pName, unsigned interestLevel )
             showProgress ( interestLevel );
         }
     }
-    
+
     showProgressEnd ( interestLevel );
 }
 
-void verifyContextRundownChanStillExist ( 
+void verifyContextRundownChanStillExist (
     const char * pName, unsigned interestLevel )
 {
     chid chan[10000];
@@ -3374,7 +3374,7 @@ void verifyContextRundownChanStillExist (
 
     status = ca_context_create ( ca_disable_preemptive_callback );
     SEVCHK ( status, "context create failed" );
-    
+
     for ( i = 0; i < NELEMENTS ( chan ); i++ ) {
         status = ca_create_channel  ( pName, 0, 0, 0, & chan[i] );
         /*
@@ -3386,17 +3386,17 @@ void verifyContextRundownChanStillExist (
         }
         SEVCHK ( status, NULL );
     }
-    
+
     status = ca_pend_io( timeoutToPendIO );
     SEVCHK ( status, "channel connect failed" );
 
     ca_context_destroy ();
-    
+
     showProgressEnd ( interestLevel );
 }
 
-int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount, 
-			unsigned repetitionCount, enum ca_preemptive_callback_select select )
+int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
+            unsigned repetitionCount, enum ca_preemptive_callback_select select )
 {
     chid chan;
     int status;
@@ -3405,7 +3405,7 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     unsigned connections;
     unsigned maxArrayBytes = 10000000;
 
-    printf ( "CA Client V%s, channel name \"%s\", timeout %g\n", 
+    printf ( "CA Client V%s, channel name \"%s\", timeout %g\n",
         ca_version (), pName, timeoutToPendIO );
     if ( select == ca_enable_preemptive_callback ) {
         printf ( "Preemptive call back is enabled.\n" );
@@ -3414,7 +3414,7 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     {
         char tmpString[32];
         sprintf ( tmpString, "%u", maxArrayBytes );
-        epicsEnvSet ( "EPICS_CA_MAX_ARRAY_BYTES", tmpString ); 
+        epicsEnvSet ( "EPICS_CA_MAX_ARRAY_BYTES", tmpString );
     }
 
     /*
@@ -3447,7 +3447,7 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     showProgressEnd ( interestLevel );
 
     printf ( "native type was %s, native count was %lu\n",
-        dbf_type_to_text ( ca_field_type ( chan ) ), 
+        dbf_type_to_text ( ca_field_type ( chan ) ),
         ca_element_count ( chan ) );
 
     connections = ca_get_ioc_connection_count ();
@@ -3464,14 +3464,14 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     verifyTimeStamps ( chan, interestLevel );
     verifyOldPend ( interestLevel );
     exceptionTest ( chan, interestLevel );
-    arrayTest ( chan, maxArrayBytes, interestLevel ); 
+    arrayTest ( chan, maxArrayBytes, interestLevel );
     verifyMonitorSubscriptionFlushIO ( chan, interestLevel );
     monitorSubscriptionFirstUpdateTest ( pName, chan, interestLevel );
     ctrlDoubleTest ( chan, interestLevel );
     verifyBlockInPendIO ( chan, interestLevel );
-    verifyAnalogIO ( chan, DBR_FLOAT, FLT_MIN, FLT_MAX, 
+    verifyAnalogIO ( chan, DBR_FLOAT, FLT_MIN, FLT_MAX,
                FLT_MIN_EXP, FLT_MAX_EXP, FLT_EPSILON, interestLevel );
-    verifyAnalogIO ( chan, DBR_DOUBLE, DBL_MIN, DBL_MAX, 
+    verifyAnalogIO ( chan, DBR_DOUBLE, DBL_MIN, DBL_MAX,
                DBL_MIN_EXP, DBL_MAX_EXP, DBL_EPSILON, interestLevel );
     verifyLongIO ( chan, interestLevel );
     verifyShortIO ( chan, interestLevel );
@@ -3486,7 +3486,7 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     verifyBadString ( chan, interestLevel );
     verifyMultithreadSubscr ( pName, interestLevel );
     if ( select != ca_enable_preemptive_callback ) {
-        fdManagerVerify ( pName, interestLevel ); 
+        fdManagerVerify ( pName, interestLevel );
     }
 
     /*
@@ -3497,7 +3497,7 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     printf ( "\n" );
     pend_event_delay_test ( 1.0 );
     pend_event_delay_test ( 0.1 );
-    pend_event_delay_test ( 0.25 ); 
+    pend_event_delay_test ( 0.25 );
 
     /* ca_channel_status ( 0 ); */
     ca_client_status ( 0 );
@@ -3539,10 +3539,10 @@ int acctst ( const char * pName, unsigned interestLevel, unsigned channelCount,
     /* SEVCHK ( status, NULL ); */
 
     caTaskExitTest ( interestLevel );
-    
+
     verifyContextRundownFlush ( pName, interestLevel );
     verifyContextRundownChanStillExist ( pName, interestLevel );
-    
+
     free ( pChans );
 
     printf ( "\nTest Complete\n" );
diff --git a/modules/ca/src/client/acctstMain.c b/modules/ca/src/client/acctstMain.c
index 4c700a3..5386019 100644
--- a/modules/ca/src/client/acctstMain.c
+++ b/modules/ca/src/client/acctstMain.c
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
@@ -19,15 +19,15 @@ int main ( int argc, char **argv )
     unsigned progressLoggingLevel;
     unsigned channelCount;
     unsigned repetitionCount;
-	enum ca_preemptive_callback_select preempt;
-	int aBoolean;
+    enum ca_preemptive_callback_select preempt;
+    int aBoolean;
 
 
     if ( argc < 2 || argc > 6 ) {
         printf ("usage: %s <PV name> [progress logging level] [channel count] "
-                "[repetition count] [enable preemptive callback]\n", 
+                "[repetition count] [enable preemptive callback]\n",
                 argv[0] );
-        return 1;        
+        return 1;
     }
 
     if ( argc >= 3 ) {
@@ -57,12 +57,12 @@ int main ( int argc, char **argv )
     else {
         aBoolean = 0;
     }
-	if ( aBoolean ) {
-		preempt = ca_enable_preemptive_callback;
-	}
-	else {
-		preempt = ca_disable_preemptive_callback;
-	}
+    if ( aBoolean ) {
+        preempt = ca_enable_preemptive_callback;
+    }
+    else {
+        preempt = ca_disable_preemptive_callback;
+    }
 
     acctst ( argv[1], progressLoggingLevel, channelCount, repetitionCount, preempt );
 
diff --git a/modules/ca/src/client/acctstRegister.cpp b/modules/ca/src/client/acctstRegister.cpp
index e75ed7f..5ddc5af 100644
--- a/modules/ca/src/client/acctstRegister.cpp
+++ b/modules/ca/src/client/acctstRegister.cpp
@@ -60,7 +60,7 @@ struct AutoInit {
     AutoInit ();
 };
 
-AutoInit :: AutoInit () 
+AutoInit :: AutoInit ()
 {
     iocshRegister ( &acctstFuncDef, acctstCallFunc );
 }
diff --git a/modules/ca/src/client/addrList.h b/modules/ca/src/client/addrList.h
index c06c8b2..9d51e0c 100644
--- a/modules/ca/src/client/addrList.h
+++ b/modules/ca/src/client/addrList.h
@@ -5,28 +5,28 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #ifndef addrListh
 #define addrListh
 
 #include "shareLib.h"
-#include "envDefs.h" 
+#include "envDefs.h"
 #include "osiSock.h"
 
 #ifdef __cplusplus
 extern "C" {
 #endif
 
-epicsShareFunc void epicsShareAPI configureChannelAccessAddressList 
+epicsShareFunc void epicsShareAPI configureChannelAccessAddressList
     ( struct ELLLIST *pList, SOCKET sock, unsigned short port );
 
 epicsShareFunc int epicsShareAPI addAddrToChannelAccessAddressList
-    ( struct ELLLIST *pList, const ENV_PARAM *pEnv, 
+    ( struct ELLLIST *pList, const ENV_PARAM *pEnv,
     unsigned short port, int ignoreNonDefaultPort );
 
-epicsShareFunc void epicsShareAPI printChannelAccessAddressList 
+epicsShareFunc void epicsShareAPI printChannelAccessAddressList
     ( const struct ELLLIST *pList );
 
 epicsShareFunc void epicsShareAPI removeDuplicateAddresses
diff --git a/modules/ca/src/client/autoPtrFreeList.h b/modules/ca/src/client/autoPtrFreeList.h
index 7dc7360..9c1d967 100644
--- a/modules/ca/src/client/autoPtrFreeList.h
+++ b/modules/ca/src/client/autoPtrFreeList.h
@@ -5,22 +5,22 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
 #ifndef autoPtrFreeListh
@@ -56,7 +56,7 @@ private:
 };
 
 template < class T, unsigned N, class MUTEX >
-inline autoPtrFreeList < T, N, MUTEX >::autoPtrFreeList ( 
+inline autoPtrFreeList < T, N, MUTEX >::autoPtrFreeList (
     tsFreeList < T, N, MUTEX > & freeListIn, T * pIn ) :
     p ( pIn ), freeList ( freeListIn ) {}
 
diff --git a/modules/ca/src/client/autoPtrRecycle.h b/modules/ca/src/client/autoPtrRecycle.h
index 173e148..600bb5a 100644
--- a/modules/ca/src/client/autoPtrRecycle.h
+++ b/modules/ca/src/client/autoPtrRecycle.h
@@ -5,22 +5,22 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
 #ifndef autoPtrRecycleh
@@ -29,7 +29,7 @@
 template < class T >
 class autoPtrRecycle {
 public:
-    autoPtrRecycle ( 
+    autoPtrRecycle (
         epicsGuard < epicsMutex > &, chronIntIdResTable < baseNMIU > &,
         cacRecycle &, T * );
     ~autoPtrRecycle ();
@@ -43,12 +43,12 @@ private:
     chronIntIdResTable < baseNMIU > & ioTable;
     epicsGuard < epicsMutex > & guard;
     // not implemented
-	autoPtrRecycle ( const autoPtrRecycle & );
-	autoPtrRecycle & operator = ( const autoPtrRecycle & );
+    autoPtrRecycle ( const autoPtrRecycle & );
+    autoPtrRecycle & operator = ( const autoPtrRecycle & );
 };
 
 template < class T >
-inline autoPtrRecycle<T>::autoPtrRecycle ( 
+inline autoPtrRecycle<T>::autoPtrRecycle (
     epicsGuard < epicsMutex > & guardIn, chronIntIdResTable < baseNMIU > & tbl,
         cacRecycle & rIn, T * pIn ) :
     p ( pIn ), r ( rIn ), ioTable ( tbl ), guard ( guardIn ) {}
diff --git a/modules/ca/src/client/baseNMIU.cpp b/modules/ca/src/client/baseNMIU.cpp
index 20f153b..8d444c1 100644
--- a/modules/ca/src/client/baseNMIU.cpp
+++ b/modules/ca/src/client/baseNMIU.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
diff --git a/modules/ca/src/client/bhe.cpp b/modules/ca/src/client/bhe.cpp
index d6f1796..4fac257 100644
--- a/modules/ca/src/client/bhe.cpp
+++ b/modules/ca/src/client/bhe.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-    
-/*  
+
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -42,12 +42,12 @@
  *  start up
  *
  * if creating this in response to a search reply
- * and not in response to a beacon then 
+ * and not in response to a beacon then
  * we set the beacon time stamp to
  * zero (so we can correctly compute the period
  * between the 1st and 2nd beacons)
  */
-bhe::bhe ( epicsMutex & mutexIn, const epicsTime & initialTimeStamp, 
+bhe::bhe ( epicsMutex & mutexIn, const epicsTime & initialTimeStamp,
           unsigned initialBeaconNumber, const inetAddrID & addr ) :
     inetAddrID ( addr ), timeStamp ( initialTimeStamp ), averagePeriod ( - DBL_MAX ),
     mutex ( mutexIn ), pIIU ( 0 ), lastBeaconNumber ( initialBeaconNumber )
@@ -74,7 +74,7 @@ void bhe::beaconAnomalyNotify ( epicsGuard < epicsMutex > & guard )
 }
 
 #ifdef DEBUG
-void bhe::logBeacon ( const char * pDiagnostic, 
+void bhe::logBeacon ( const char * pDiagnostic,
                      const double & currentPeriod,
                      const epicsTime & currentTime )
 {
@@ -82,10 +82,10 @@ void bhe::logBeacon ( const char * pDiagnostic,
         char name[64];
         this->name ( name, sizeof ( name ) );
         char date[64];
-        currentTime.strftime ( date, sizeof ( date ), 
+        currentTime.strftime ( date, sizeof ( date ),
             "%a %b %d %Y %H:%M:%S.%f");
         ::printf ( "%s cp=%g ap=%g %s %s\n",
-            pDiagnostic, currentPeriod, 
+            pDiagnostic, currentPeriod,
             this->averagePeriod, name, date );
     }
 }
@@ -105,7 +105,7 @@ void bhe::logBeaconDiscard ( unsigned beaconAdvance,
         char name[64];
         this->name ( name, sizeof ( name ) );
         char date[64];
-        currentTime.strftime ( date, sizeof ( date ), 
+        currentTime.strftime ( date, sizeof ( date ),
             "%a %b %d %Y %H:%M:%S.%f");
         ::printf ( "bb %u %s %s\n",
             beaconAdvance, name, date );
@@ -123,16 +123,16 @@ void bhe::logBeaconDiscard ( unsigned /* beaconAdvance */,
  *
  * updates beacon period, and looks for beacon anomalies
  */
-bool bhe::updatePeriod ( 
-    epicsGuard < epicsMutex > & guard, const epicsTime & programBeginTime, 
-    const epicsTime & currentTime, ca_uint32_t beaconNumber, 
+bool bhe::updatePeriod (
+    epicsGuard < epicsMutex > & guard, const epicsTime & programBeginTime,
+    const epicsTime & currentTime, ca_uint32_t beaconNumber,
     unsigned protocolRevision )
 {
     guard.assertIdenticalMutex ( this->mutex );
 
     //
     // this block is enetered if the beacon was created as a side effect of
-    // creating a connection and so we dont yet know the first beacon time 
+    // creating a connection and so we dont yet know the first beacon time
     // and  sequence number
     //
     if ( this->timeStamp == epicsTime () ) {
@@ -142,7 +142,7 @@ bool bhe::updatePeriod (
 
         this->beaconAnomalyNotify ( guard );
 
-        /* 
+        /*
          * this is the 1st beacon seen - the beacon time stamp
          * was not initialized during BHE create because
          * a TCP/IP connection created the beacon.
@@ -167,15 +167,15 @@ bool bhe::updatePeriod (
         }
         this->lastBeaconNumber = beaconNumber;
 
-        // throw out sequence numbers just prior to, or the same as, the last one received 
+        // throw out sequence numbers just prior to, or the same as, the last one received
         // (this situation is probably caused by a temporary duplicate route )
         if ( beaconSeqAdvance == 0 ||  beaconSeqAdvance > ca_uint32_max - 256 ) {
             logBeaconDiscard ( beaconSeqAdvance, currentTime );
             return false;
         }
 
-        // throw out sequence numbers that jump forward by only a few numbers 
-        // (this situation is probably caused by a duplicate route 
+        // throw out sequence numbers that jump forward by only a few numbers
+        // (this situation is probably caused by a duplicate route
         // or a beacon due to input queue overun)
         if ( beaconSeqAdvance > 1 &&  beaconSeqAdvance < 4 ) {
             logBeaconDiscard ( beaconSeqAdvance, currentTime );
@@ -205,7 +205,7 @@ bool bhe::updatePeriod (
         /*
          * ignore beacons seen for the first time shortly after
          * init, but do not ignore beacons arriving with a short
-         * period because the IOC was rebooted soon after the 
+         * period because the IOC was rebooted soon after the
          * client starts up.
          */
         totalRunningTime = this->timeStamp - programBeginTime;
@@ -217,24 +217,24 @@ bool bhe::updatePeriod (
 
         /*
          * Is this an IOC seen because of a restored
-         * network segment? 
+         * network segment?
          *
-         * It may be possible to get false triggers here 
+         * It may be possible to get false triggers here
          * if the client is busy, but this does not cause
-         * problems because the echo response will tell us 
+         * problems because the echo response will tell us
          * that the server is available
          */
         if ( currentPeriod >= this->averagePeriod * 1.25 ) {
 
-            /* 
-             * trigger on any missing beacon 
+            /*
+             * trigger on any missing beacon
              * if connected to this server
-             */    
+             */
             this->beaconAnomalyNotify ( guard );
 
             if ( currentPeriod >= this->averagePeriod * 3.25 ) {
-                /* 
-                 * trigger on any 3 contiguous missing beacons 
+                /*
+                 * trigger on any 3 contiguous missing beacons
                  * if not connected to this server
                  */
                 netChange = true;
@@ -248,9 +248,9 @@ bool bhe::updatePeriod (
          * IOC reboots). Lower tolarance here because we
          * dont have to worry about lost beacons.
          *
-         * It may be possible to get false triggers here 
+         * It may be possible to get false triggers here
          * if the client is busy, but this does not cause
-         * problems because the echo response will tell us 
+         * problems because the echo response will tell us
          * that the server is available
          */
         else if ( currentPeriod <= this->averagePeriod * 0.80 ) {
@@ -259,14 +259,14 @@ bool bhe::updatePeriod (
             logBeacon ( "bal", currentPeriod, currentTime );
         }
         else if ( this->pIIU ) {
-            // update state of health for active virtual circuits 
+            // update state of health for active virtual circuits
             // if the beacon looks ok
             this->pIIU->beaconArrivalNotify ( guard );
             logBeacon ( "vb", currentPeriod, currentTime );
         }
 
         // update a running average period
-        this->averagePeriod = currentPeriod * 0.125 + 
+        this->averagePeriod = currentPeriod * 0.125 +
             this->averagePeriod * 0.875;
     }
 
@@ -286,22 +286,22 @@ void bhe::show ( epicsGuard < epicsMutex > &, unsigned level ) const
     char host [64];
     this->name ( host, sizeof ( host ) );
     if ( this->averagePeriod == -DBL_MAX ) {
-        ::printf ( "CA beacon hash entry for %s <no period estimate>\n", 
+        ::printf ( "CA beacon hash entry for %s <no period estimate>\n",
             host );
     }
     else {
-        ::printf ( "CA beacon hash entry for %s with period estimate %f\n", 
+        ::printf ( "CA beacon hash entry for %s with period estimate %f\n",
             host, this->averagePeriod );
     }
     if ( level > 0u ) {
         char date[64];
         this->timeStamp.strftime ( date, sizeof ( date ), "%a %b %d %Y %H:%M:%S");
-        ::printf ( "\tbeacon number %u, on %s\n", 
+        ::printf ( "\tbeacon number %u, on %s\n",
             this->lastBeaconNumber, date );
     }
 }
 
-double bhe::period ( epicsGuard < epicsMutex > & guard ) const 
+double bhe::period ( epicsGuard < epicsMutex > & guard ) const
 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->averagePeriod;
@@ -313,14 +313,14 @@ epicsTime bhe::updateTime ( epicsGuard < epicsMutex > & guard ) const
     return this->timeStamp;
 }
 
-void bhe::registerIIU ( 
+void bhe::registerIIU (
     epicsGuard < epicsMutex > & guard, tcpiiu & iiu )
 {
     guard.assertIdenticalMutex ( this->mutex );
     this->pIIU = & iiu;
 }
 
-void bhe::unregisterIIU ( 
+void bhe::unregisterIIU (
     epicsGuard < epicsMutex > & guard, tcpiiu & iiu )
 {
     guard.assertIdenticalMutex ( this->mutex );
diff --git a/modules/ca/src/client/bhe.h b/modules/ca/src/client/bhe.h
index 4da9520..b1be35f 100644
--- a/modules/ca/src/client/bhe.h
+++ b/modules/ca/src/client/bhe.h
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -54,14 +54,14 @@ public:
 
 class bhe : public tsSLNode < bhe >, public inetAddrID {
 public:
-    epicsShareFunc bhe ( 
-        epicsMutex &, const epicsTime & initialTimeStamp, 
+    epicsShareFunc bhe (
+        epicsMutex &, const epicsTime & initialTimeStamp,
         unsigned initialBeaconNumber, const inetAddrID & addr );
-    epicsShareFunc ~bhe (); 
-    epicsShareFunc bool updatePeriod ( 
+    epicsShareFunc ~bhe ();
+    epicsShareFunc bool updatePeriod (
         epicsGuard < epicsMutex > &,
-        const epicsTime & programBeginTime, 
-        const epicsTime & currentTime, ca_uint32_t beaconNumber, 
+        const epicsTime & programBeginTime,
+        const epicsTime & currentTime, ca_uint32_t beaconNumber,
         unsigned protocolRevision );
     epicsShareFunc double period ( epicsGuard < epicsMutex > & ) const;
     epicsShareFunc epicsTime updateTime ( epicsGuard < epicsMutex > & ) const;
@@ -80,13 +80,13 @@ private:
     tcpiiu * pIIU;
     ca_uint32_t lastBeaconNumber;
     void beaconAnomalyNotify ( epicsGuard < epicsMutex > & );
-    void logBeacon ( const char * pDiagnostic, 
+    void logBeacon ( const char * pDiagnostic,
                      const double & currentPeriod,
                      const epicsTime & currentTime );
     void logBeaconDiscard ( unsigned beaconAdvance,
                      const epicsTime & currentTime );
-	bhe ( const bhe & );
-	bhe & operator = ( const bhe & );
+    bhe ( const bhe & );
+    bhe & operator = ( const bhe & );
     epicsShareFunc void operator delete ( void * );
 };
 
@@ -99,20 +99,20 @@ public:
     void release ( void * );
 private:
     tsFreeList < bhe, 0x100 > freeList;
-	bheFreeStore ( const bheFreeStore & );
-	bheFreeStore & operator = ( const bheFreeStore & );
+    bheFreeStore ( const bheFreeStore & );
+    bheFreeStore & operator = ( const bheFreeStore & );
 };
 
-inline void * bhe::operator new ( size_t size, 
+inline void * bhe::operator new ( size_t size,
         bheMemoryManager & mgr )
-{ 
+{
     return mgr.allocate ( size );
 }
 
 #ifdef CXX_PLACEMENT_DELETE
-inline void bhe::operator delete ( void * pCadaver, 
+inline void bhe::operator delete ( void * pCadaver,
         bheMemoryManager & mgr )
-{ 
+{
     mgr.release ( pCadaver );
 }
 #endif
diff --git a/modules/ca/src/client/caConnTest.cpp b/modules/ca/src/client/caConnTest.cpp
index 2107739..bd479e6 100644
--- a/modules/ca/src/client/caConnTest.cpp
+++ b/modules/ca/src/client/caConnTest.cpp
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
@@ -60,50 +60,50 @@ void caConnTest ( const char *pNameIn, unsigned channelCountIn, double delayIn )
 {
     unsigned iteration = 0u;
     int status;
-	unsigned i;
-	chid *pChans;
+    unsigned i;
+    chid *pChans;
 
     channelCount = channelCountIn;
 
     pChans = new chid [channelCount];
-	
-	while ( 1 ) {
+
+    while ( 1 ) {
         connCount = 0u;
         subsequentConnect = false;
         begin = epicsTime::getCurrent ();
 
         printf ( "initializing CA client library\n" );
 
-		status = ca_task_initialize();
-		SEVCHK ( status, "CA init failed" );
+        status = ca_task_initialize();
+        SEVCHK ( status, "CA init failed" );
 
         printf ( "creating channels\n" );
 
-		for ( i = 0u; i < channelCount; i++ ) {
-			status = ca_search_and_connect ( pNameIn, 
+        for ( i = 0u; i < channelCount; i++ ) {
+            status = ca_search_and_connect ( pNameIn,
                 &pChans[i], caConnTestConnHandler, 0 );
-			SEVCHK ( status, "CA search problems" );
-		}
+            SEVCHK ( status, "CA search problems" );
+        }
 
         printf ( "all channels were created\n" );
 
-		ca_pend_event ( delayIn );
+        ca_pend_event ( delayIn );
 
         if ( iteration & 1 ) {
-		    for ( i = 0u; i < channelCount; i++ ) {
-			    status = ca_clear_channel ( pChans[i] );
-			    SEVCHK ( status, "ca_clear_channel() problems" );
-		    }
+            for ( i = 0u; i < channelCount; i++ ) {
+                status = ca_clear_channel ( pChans[i] );
+                SEVCHK ( status, "ca_clear_channel() problems" );
+            }
             printf ( "all channels were destroyed\n" );
         }
 
         printf ( "shutting down CA client library\n" );
 
-		status = ca_task_exit ();
-		SEVCHK ( status, "task exit problems" );
+        status = ca_task_exit ();
+        SEVCHK ( status, "task exit problems" );
 
         iteration++;
-	}
+    }
 
     //delete [] pChans;
 }
diff --git a/modules/ca/src/client/caConnTestMain.cpp b/modules/ca/src/client/caConnTestMain.cpp
index f398580..b5e921c 100644
--- a/modules/ca/src/client/caConnTestMain.cpp
+++ b/modules/ca/src/client/caConnTestMain.cpp
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
diff --git a/modules/ca/src/client/caDiagnostics.h b/modules/ca/src/client/caDiagnostics.h
index 90221e1..87029ce 100644
--- a/modules/ca/src/client/caDiagnostics.h
+++ b/modules/ca/src/client/caDiagnostics.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #ifndef caDiagnosticsh
@@ -20,8 +20,8 @@ extern "C" {
 enum appendNumberFlag {appendNumber, dontAppendNumber};
 int catime ( const char *channelName, unsigned channelCount, enum appendNumberFlag appNF );
 
-int acctst ( const char *pname, unsigned logggingInterestLevel, 
-            unsigned channelCount, unsigned repetitionCount, 
+int acctst ( const char *pname, unsigned logggingInterestLevel,
+            unsigned channelCount, unsigned repetitionCount,
             enum ca_preemptive_callback_select select );
 
 #define CATIME_OK 0
diff --git a/modules/ca/src/client/caEventRate.cpp b/modules/ca/src/client/caEventRate.cpp
index 8beb163..efb6dc7 100644
--- a/modules/ca/src/client/caEventRate.cpp
+++ b/modules/ca/src/client/caEventRate.cpp
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
@@ -38,50 +38,50 @@ void caEventRate ( const char *pName, unsigned count )
     chid * pChidTable = new chid [ count ];
 
     {
-        printf ( "Connecting to CA Channel \"%s\" %u times.", 
+        printf ( "Connecting to CA Channel \"%s\" %u times.",
                     pName, count );
         fflush ( stdout );
-    
+
         epicsTime begin = epicsTime::getCurrent ();
         for ( unsigned i = 0u; i < count; i++ ) {
             int status = ca_search ( pName,  & pChidTable[i] );
             SEVCHK ( status, NULL );
         }
-    
+
         int status = ca_pend_io ( 10000.0 );
         if ( status != ECA_NORMAL ) {
             fprintf ( stderr, " not found.\n" );
             return;
         }
         epicsTime end = epicsTime::getCurrent ();
-    
+
         printf ( " done(%f sec).\n", end - begin );
     }
 
     {
         printf ( "Subscribing %u times.", count );
         fflush ( stdout );
-        
+
         epicsTime begin = epicsTime::getCurrent ();
         for ( unsigned i = 0u; i < count; i++ ) {
-            int addEventStatus = ca_add_event ( DBR_FLOAT, 
+            int addEventStatus = ca_add_event ( DBR_FLOAT,
                 pChidTable[i], eventCallBack, &eventCount, NULL);
             SEVCHK ( addEventStatus, __FILE__ );
         }
-    
+
         int status = ca_flush_io ();
         SEVCHK ( status, __FILE__ );
-    
+
         epicsTime end = epicsTime::getCurrent ();
-    
+
         printf ( " done(%f sec).\n", end - begin );
     }
-        
+
     {
         printf ( "Waiting for initial value events." );
         fflush ( stdout );
-    
-        // let the first one go by 
+
+        // let the first one go by
         epicsTime begin = epicsTime::getCurrent ();
         while ( eventCount < count ) {
             int status = ca_pend_event ( 0.01 );
@@ -90,7 +90,7 @@ void caEventRate ( const char *pName, unsigned count )
             }
         }
         epicsTime end = epicsTime::getCurrent ();
-    
+
         printf ( " done(%f sec).\n", end - begin );
     }
 
@@ -128,7 +128,7 @@ void caEventRate ( const char *pName, unsigned count )
         double mean = X / N;
         double stdDev = sqrt ( XX / N - mean * mean );
 
-        printf ( "CA Event Rate (Hz): current %g mean %g std dev %g\n", 
+        printf ( "CA Event Rate (Hz): current %g mean %g std dev %g\n",
             Hz, mean, stdDev );
 
         if ( samplePeriod < maxSamplePeriod ) {
diff --git a/modules/ca/src/client/caEventRateMain.cpp b/modules/ca/src/client/caEventRateMain.cpp
index 725e661..7ace11d 100644
--- a/modules/ca/src/client/caEventRateMain.cpp
+++ b/modules/ca/src/client/caEventRateMain.cpp
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
diff --git a/modules/ca/src/client/caProto.h b/modules/ca/src/client/caProto.h
index 781c89b..dd59fd4 100644
--- a/modules/ca/src/client/caProto.h
+++ b/modules/ca/src/client/caProto.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
@@ -15,14 +15,14 @@
  */
 
 #ifndef __CAPROTO__
-#define __CAPROTO__ 
+#define __CAPROTO__
 
 #define capStrOf(A) #A
 #define capStrOfX(A) capStrOf ( A )
 
-/* 
+/*
  * CA protocol revision
- * TCP/UDP port number (bumped each major protocol change) 
+ * TCP/UDP port number (bumped each major protocol change)
  */
 #define CA_MAJOR_PROTOCOL_REVISION 4
 #define CA_VERSION_STRING( MINOR_REVISION ) \
@@ -30,7 +30,7 @@
 #define CA_UKN_MINOR_VERSION    0u /* unknown minor version */
 #define CA_MINIMUM_SUPPORTED_VERSION 4u
 #   define CA_VSUPPORTED(MINOR) ((MINOR)>=CA_MINIMUM_SUPPORTED_VERSION)
-#   define CA_V41(MINOR) ((MINOR)>=1u) 
+#   define CA_V41(MINOR) ((MINOR)>=1u)
 #   define CA_V42(MINOR) ((MINOR)>=2u)
 #   define CA_V43(MINOR) ((MINOR)>=3u)
 #   define CA_V44(MINOR) ((MINOR)>=4u)
@@ -45,8 +45,8 @@
 #   define CA_V413(MINOR) ((MINOR)>=13u)  /* Allow zero length in requests. */
 
 /*
- * These port numbers are only used if the CA repeater and 
- * CA server port numbers cant be obtained from the EPICS 
+ * These port numbers are only used if the CA repeater and
+ * CA server port numbers cant be obtained from the EPICS
  * environment variables "EPICS_CA_REPEATER_PORT" and
  * "EPICS_CA_SERVER_PORT"
  */
@@ -54,8 +54,8 @@
 #define CA_SERVER_PORT          (CA_PORT_BASE+CA_MAJOR_PROTOCOL_REVISION*2u)
 #define CA_REPEATER_PORT        (CA_PORT_BASE+CA_MAJOR_PROTOCOL_REVISION*2u+1u)
 
-/* 
- * 1500 (max of ethernet and 802.{2,3} MTU) - 20(IP) - 8(UDP) 
+/*
+ * 1500 (max of ethernet and 802.{2,3} MTU) - 20(IP) - 8(UDP)
  * (the MTU of Ethernet is currently independent of its speed varient)
  */
 #define ETHERNET_MAX_UDP        ( 1500u - 20u - 8u )
@@ -89,10 +89,10 @@ typedef ca_uint32_t     caResId;
 #define CA_PROTO_SNAPSHOT       5u  /* snapshot of the system */
 #define CA_PROTO_SEARCH         6u  /* IOC channel search */
 #define CA_PROTO_BUILD          7u  /* build - obsolete */
-#define CA_PROTO_EVENTS_OFF     8u  /* flow control */ 
-#define CA_PROTO_EVENTS_ON      9u  /* flow control */ 
-#define CA_PROTO_READ_SYNC      10u /* purge old reads */ 
-#define CA_PROTO_ERROR          11u /* an operation failed */ 
+#define CA_PROTO_EVENTS_OFF     8u  /* flow control */
+#define CA_PROTO_EVENTS_ON      9u  /* flow control */
+#define CA_PROTO_READ_SYNC      10u /* purge old reads */
+#define CA_PROTO_ERROR          11u /* an operation failed */
 #define CA_PROTO_CLEAR_CHANNEL  12u /* free chan resources */
 #define CA_PROTO_RSRV_IS_UP     13u /* CA server has joined the net */
 #define CA_PROTO_NOT_FOUND      14u /* channel not found */
@@ -172,7 +172,7 @@ typedef struct ca_hdr {
  */
 struct  mon_info {
     ca_float32_t    m_lval;     /* low delta */
-    ca_float32_t    m_hval;     /* high delta */ 
+    ca_float32_t    m_hval;     /* high delta */
     ca_float32_t    m_toval;    /* period btween samples */
     ca_uint16_t     m_mask;     /* event select mask */
     ca_uint16_t     m_pad;      /* extend to 32 bits */
diff --git a/modules/ca/src/client/caRepeater.cpp b/modules/ca/src/client/caRepeater.cpp
index 2561223..634a2bc 100644
--- a/modules/ca/src/client/caRepeater.cpp
+++ b/modules/ca/src/client/caRepeater.cpp
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
diff --git a/modules/ca/src/client/caServerID.h b/modules/ca/src/client/caServerID.h
index 08bfdd5..430f314 100644
--- a/modules/ca/src/client/caServerID.h
+++ b/modules/ca/src/client/caServerID.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
@@ -37,7 +37,7 @@ private:
     ca_uint8_t pri;
 };
 
-inline caServerID::caServerID ( 
+inline caServerID::caServerID (
     const struct sockaddr_in & addrIn, unsigned priorityIn ) :
     addr ( addrIn ), pri ( static_cast <ca_uint8_t> ( priorityIn ) )
 {
@@ -46,7 +46,7 @@ inline caServerID::caServerID (
 
 inline bool caServerID::operator == ( const caServerID & rhs ) const
 {
-    if (    this->addr.sin_addr.s_addr == rhs.addr.sin_addr.s_addr && 
+    if (    this->addr.sin_addr.s_addr == rhs.addr.sin_addr.s_addr &&
             this->addr.sin_port == rhs.addr.sin_port &&
             this->pri == rhs.pri ) {
         return true;
@@ -67,7 +67,7 @@ inline resTableIndex caServerID::hash () const
     index ^= this->addr.sin_port;
     index ^= this->addr.sin_port >> 8u;
     index ^= this->pri;
-    return integerHash ( caServerMinIndexBitWidth, 
+    return integerHash ( caServerMinIndexBitWidth,
         caServerMaxIndexBitWidth, index );
 }
 
diff --git a/modules/ca/src/client/ca_client_context.cpp b/modules/ca/src/client/ca_client_context.cpp
index 3fd0512..44d6427 100644
--- a/modules/ca/src/client/ca_client_context.cpp
+++ b/modules/ca/src/client/ca_client_context.cpp
@@ -17,9 +17,9 @@
  *  Copyright, 1986, The Regents of the University of California.
  *
  *
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
 #ifdef _MSC_VER
diff --git a/modules/ca/src/client/cac.cpp b/modules/ca/src/client/cac.cpp
index 476d1c3..e335e6e 100644
--- a/modules/ca/src/client/cac.cpp
+++ b/modules/ca/src/client/cac.cpp
@@ -155,7 +155,7 @@ cac::cac (
     }
 
     try {
-	    long status;
+        long status;
 
         /*
          * Certain os, such as HPUX, do not unblock a socket system call
diff --git a/modules/ca/src/client/cac.h b/modules/ca/src/client/cac.h
index 7db5c6d..c98f05d 100644
--- a/modules/ca/src/client/cac.h
+++ b/modules/ca/src/client/cac.h
@@ -81,8 +81,8 @@ public:
     void release ( void * );
 private:
     tsFreeList < comBuf, 0x20 > freeList;
-	cacComBufMemoryManager ( const cacComBufMemoryManager & );
-	cacComBufMemoryManager & operator = ( const cacComBufMemoryManager & );
+    cacComBufMemoryManager ( const cacComBufMemoryManager & );
+    cacComBufMemoryManager & operator = ( const cacComBufMemoryManager & );
 };
 
 class notifyGuard {
@@ -348,8 +348,8 @@ private:
                     const char *pCtx, unsigned status );
     static const pExcepProtoStubTCP tcpExcepJumpTableCAC [];
 
-	cac ( const cac & );
-	cac & operator = ( const cac & );
+        cac ( const cac & );
+        cac & operator = ( const cac & );
 
     friend class tcpiiu;
 };
diff --git a/modules/ca/src/client/cacChannel.cpp b/modules/ca/src/client/cacChannel.cpp
index c1a52a0..80f622f 100644
--- a/modules/ca/src/client/cacChannel.cpp
+++ b/modules/ca/src/client/cacChannel.cpp
@@ -5,11 +5,11 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -41,7 +41,7 @@ private:
     epicsSingleton < localHostName > :: reference
         _refLocalHostName;
 };
-    
+
 static epicsThreadOnceId cacChannelIdOnce = EPICS_THREAD_ONCE_INIT;
 
 const cacChannel::priLev cacChannel::priorityMax = 99u;
@@ -55,63 +55,63 @@ cacChannel::~cacChannel ()
 {
 }
 
-caAccessRights cacChannel::accessRights ( 
-    epicsGuard < epicsMutex > & ) const 
+caAccessRights cacChannel::accessRights (
+    epicsGuard < epicsMutex > & ) const
 {
     static caAccessRights ar ( true, true );
     return ar;
 }
 
-unsigned cacChannel::searchAttempts ( 
-    epicsGuard < epicsMutex > & ) const 
+unsigned cacChannel::searchAttempts (
+    epicsGuard < epicsMutex > & ) const
 {
     return 0u;
 }
 
-double cacChannel::beaconPeriod ( 
-    epicsGuard < epicsMutex > & ) const 
+double cacChannel::beaconPeriod (
+    epicsGuard < epicsMutex > & ) const
 {
     return - DBL_MAX;
 }
 
-double cacChannel::receiveWatchdogDelay ( 
+double cacChannel::receiveWatchdogDelay (
     epicsGuard < epicsMutex > & ) const
 {
     return - DBL_MAX;
 }
 
 bool cacChannel::ca_v42_ok (
-    epicsGuard < epicsMutex > & ) const 
+    epicsGuard < epicsMutex > & ) const
 {
     return true;
 }
 
 bool cacChannel::connected (
-    epicsGuard < epicsMutex > & ) const 
+    epicsGuard < epicsMutex > & ) const
 {
     return true;
 }
 
-CACChannelPrivate :: 
+CACChannelPrivate ::
     CACChannelPrivate() :
     _refLocalHostName ( localHostNameCache.getReference () )
 {
 }
 
-inline unsigned CACChannelPrivate :: 
+inline unsigned CACChannelPrivate ::
     getHostName ( char * pBuf, unsigned bufLength )
 {
     return _refLocalHostName->getName ( pBuf, bufLength );
 }
-    
-inline const char * CACChannelPrivate :: 
+
+inline const char * CACChannelPrivate ::
     pHostName ()
 {
     return _refLocalHostName->pointer ();
 }
 
 static CACChannelPrivate * pCACChannelPrivate = 0;
-    
+
 // runs once only for each process
 extern "C" void cacChannelSetup ( void * )
 {
@@ -119,7 +119,7 @@ extern "C" void cacChannelSetup ( void * )
 }
 
 // the default is to assume that it is a locally hosted channel
-unsigned cacChannel::getHostName ( 
+unsigned cacChannel::getHostName (
     epicsGuard < epicsMutex > &,
     char * pBuf, unsigned bufLength ) const throw ()
 {
diff --git a/modules/ca/src/client/cacChannelNotify.cpp b/modules/ca/src/client/cacChannelNotify.cpp
index 08d2cab..5819b6b 100644
--- a/modules/ca/src/client/cacChannelNotify.cpp
+++ b/modules/ca/src/client/cacChannelNotify.cpp
@@ -5,21 +5,21 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
 #include "iocinf.h"
@@ -28,7 +28,7 @@
 #include "cacIO.h"
 #undef epicsExportSharedSymbols
 
-cacChannelNotify::~cacChannelNotify () 
+cacChannelNotify::~cacChannelNotify ()
 {
 }
 
diff --git a/modules/ca/src/client/cacContextNotify.cpp b/modules/ca/src/client/cacContextNotify.cpp
index a4498ac..b7d96ac 100644
--- a/modules/ca/src/client/cacContextNotify.cpp
+++ b/modules/ca/src/client/cacContextNotify.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -31,11 +31,11 @@ cacContextNotify::~cacContextNotify ()
 {
 }
 
-void cacContextNotify::callbackProcessingInitiateNotify () 
+void cacContextNotify::callbackProcessingInitiateNotify ()
 {
 }
 
-void cacContextNotify::callbackProcessingCompleteNotify () 
+void cacContextNotify::callbackProcessingCompleteNotify ()
 {
 }
 
diff --git a/modules/ca/src/client/cacIO.h b/modules/ca/src/client/cacIO.h
index 4e8af4a..426ba02 100644
--- a/modules/ca/src/client/cacIO.h
+++ b/modules/ca/src/client/cacIO.h
@@ -17,9 +17,9 @@
  *  Copyright, 1986, The Regents of the University of California.
  *
  *
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
 #ifndef cacIOh
@@ -273,8 +273,8 @@ protected:
 
 private:
     cacChannelNotify & callback;
-	cacChannel ( const cacChannel & );
-	cacChannel & operator = ( const cacChannel & );
+    cacChannel ( const cacChannel & );
+    cacChannel & operator = ( const cacChannel & );
 };
 
 class epicsShareClass cacContext {
diff --git a/modules/ca/src/client/cacReadNotify.cpp b/modules/ca/src/client/cacReadNotify.cpp
index 23284c8..3d3d5a7 100644
--- a/modules/ca/src/client/cacReadNotify.cpp
+++ b/modules/ca/src/client/cacReadNotify.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
diff --git a/modules/ca/src/client/cacStateNotify.cpp b/modules/ca/src/client/cacStateNotify.cpp
index 0885248..ba5575f 100644
--- a/modules/ca/src/client/cacStateNotify.cpp
+++ b/modules/ca/src/client/cacStateNotify.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
diff --git a/modules/ca/src/client/cacWriteNotify.cpp b/modules/ca/src/client/cacWriteNotify.cpp
index 13d47cd..2bd2221 100644
--- a/modules/ca/src/client/cacWriteNotify.cpp
+++ b/modules/ca/src/client/cacWriteNotify.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
diff --git a/modules/ca/src/client/cadef.h b/modules/ca/src/client/cadef.h
index e62dd72..7e34b38 100644
--- a/modules/ca/src/client/cadef.h
+++ b/modules/ca/src/client/cadef.h
@@ -5,9 +5,9 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/* 
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -83,8 +83,8 @@ typedef void caArh (struct access_rights_handler_args args);
 /*  The conversion routine to call for each type    */
 #define VALID_TYPE(TYPE)  (((unsigned short)TYPE)<=LAST_BUFFER_TYPE)
 
-/* 
- * Arguments passed to event handlers and get/put call back handlers.   
+/*
+ * Arguments passed to event handlers and get/put call back handlers.
  *
  * The status field below is the CA ECA_XXX status of the requested
  * operation which is saved from when the operation was attempted in the
@@ -95,7 +95,7 @@ typedef void caArh (struct access_rights_handler_args args);
 typedef struct event_handler_args {
     void            *usr;   /* user argument supplied with request */
     chanId          chid;   /* channel id */
-    long            type;   /* the type of the item returned */ 
+    long            type;   /* the type of the item returned */
     long            count;  /* the element count of the item returned */
     const void      *dbr;   /* a pointer to the item returned */
     int             status; /* ECA_XXX status of the requested op from the server */
@@ -133,8 +133,8 @@ typedef unsigned CA_SYNC_GID;
 #define CA_OP_CLEAR_EVENT     4
 #define CA_OP_OTHER           5
 
-/* 
- * used with connection_handler_args 
+/*
+ * used with connection_handler_args
  */
 #define CA_OP_CONN_UP       6
 #define CA_OP_CONN_DOWN     7
@@ -167,8 +167,8 @@ epicsShareFunc unsigned epicsShareAPI ca_read_access (chid chan);
 epicsShareFunc unsigned epicsShareAPI ca_write_access (chid chan);
 
 /*
- *  cs_ - `channel state'   
- *  
+ *  cs_ - `channel state'
+ *
  *  cs_never_conn       valid chid, IOC not found
  *  cs_prev_conn        valid chid, IOC was found, but unavailable
  *  cs_conn             valid chid, IOC was found, still available
@@ -183,11 +183,11 @@ epicsShareFunc enum channel_state epicsShareAPI ca_state (chid chan);
 /*  Must be called once before calling any of the other routines        */
 /************************************************************************/
 epicsShareFunc int epicsShareAPI ca_task_initialize (void);
-enum ca_preemptive_callback_select 
+enum ca_preemptive_callback_select
 { ca_disable_preemptive_callback, ca_enable_preemptive_callback };
-epicsShareFunc int epicsShareAPI 
+epicsShareFunc int epicsShareAPI
         ca_context_create (enum ca_preemptive_callback_select select);
-epicsShareFunc void epicsShareAPI ca_detach_context (); 
+epicsShareFunc void epicsShareAPI ca_detach_context ();
 
 /************************************************************************/
 /*  Remove CA facility from your task                                   */
@@ -197,7 +197,7 @@ epicsShareFunc void epicsShareAPI ca_detach_context ();
 epicsShareFunc int epicsShareAPI ca_task_exit (void);
 epicsShareFunc void epicsShareAPI ca_context_destroy (void);
 
-typedef unsigned capri; 
+typedef unsigned capri;
 #define CA_PRIORITY_MAX 99
 #define CA_PRIORITY_MIN 0
 #define CA_PRIORITY_DEFAULT CA_PRIORITY_MIN
@@ -210,7 +210,7 @@ typedef unsigned capri;
  * ca_create_channel ()
  *
  * pChanName            R   channel name string
- * pConnStateCallback   R   address of connection state change 
+ * pConnStateCallback   R   address of connection state change
  *                          callback function
  * pUserPrivate         R   placed in the channel's user private field
  *                          o can be fetched later by ca_puser(CHID)
@@ -220,8 +220,8 @@ typedef unsigned capri;
  */
 epicsShareFunc int epicsShareAPI ca_create_channel
 (
-     const char     *pChanName, 
-     caCh           *pConnStateCallback, 
+     const char     *pChanName,
+     caCh           *pConnStateCallback,
      void           *pUserPrivate,
      capri          priority,
      chid           *pChanID
@@ -230,7 +230,7 @@ epicsShareFunc int epicsShareAPI ca_create_channel
 /*
  * ca_change_connection_event()
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pfunc    R   address of connection call-back function
  */
 epicsShareFunc int epicsShareAPI ca_change_connection_event
@@ -242,7 +242,7 @@ epicsShareFunc int epicsShareAPI ca_change_connection_event
 /*
  * ca_replace_access_rights_event ()
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pfunc    R   address of access rights call-back function
  */
 epicsShareFunc int epicsShareAPI ca_replace_access_rights_event (
@@ -256,7 +256,7 @@ epicsShareFunc int epicsShareAPI ca_replace_access_rights_event (
  * replace the default exception handler
  *
  * pfunc    R   address of exception call-back function
- * pArg     R   copy of this pointer passed to exception 
+ * pArg     R   copy of this pointer passed to exception
  *          call-back function
  */
 typedef void caExceptionHandler (struct exception_handler_args);
@@ -283,10 +283,10 @@ epicsShareFunc int epicsShareAPI ca_clear_channel
 /*
  * ca_bput()
  *
- * WARNING: this copies the new value from a string (dbr_string_t) 
+ * WARNING: this copies the new value from a string (dbr_string_t)
  *      (and not as an integer)
  *
- * chan         R       channel identifier  
+ * chan         R       channel identifier
  * pValue       R       new channel value string copied from this location
  */
 #define ca_bput(chan, pValue) \
@@ -295,9 +295,9 @@ ca_array_put(DBR_STRING, 1u, chan, (const dbr_string_t *) (pValue))
 /*
  * ca_rput()
  *
- * WARNING: this copies the new value from a dbr_float_t 
+ * WARNING: this copies the new value from a dbr_float_t
  *
- * chan         R       channel identifier  
+ * chan         R       channel identifier
  * pValue       R       new channel value copied from this location
  */
 #define ca_rput(chan,pValue) \
@@ -307,7 +307,7 @@ ca_array_put(DBR_FLOAT, 1u, chan, (const dbr_float_t *) pValue)
  * ca_put()
  *
  * type         R   data type from db_access.h
- * chan         R   channel identifier  
+ * chan         R   channel identifier
  * pValue       R   new channel value copied from this location
  */
 #define ca_put(type, chan, pValue) ca_array_put (type, 1u, chan, pValue)
@@ -317,13 +317,13 @@ ca_array_put(DBR_FLOAT, 1u, chan, (const dbr_float_t *) pValue)
  *
  * type         R   data type from db_access.h
  * count        R   array element count
- * chan         R   channel identifier  
+ * chan         R   channel identifier
  * pValue       R       new channel value copied from this location
  */
 epicsShareFunc int epicsShareAPI ca_array_put
 (
-     chtype         type,   
-     unsigned long  count,   
+     chtype         type,
+     unsigned long  count,
      chid           chanId,
      const void *   pValue
 );
@@ -331,8 +331,8 @@ epicsShareFunc int epicsShareAPI ca_array_put
 /*
  * ca_array_put_callback()
  *
- * This routine functions identically to the original ca put request 
- * with the addition of a callback to the user supplied function 
+ * This routine functions identically to the original ca put request
+ * with the addition of a callback to the user supplied function
  * after recod processing completes in the IOC. The arguments
  * to the user supplied callback function are declared in
  * the structure event_handler_args and include the pointer
@@ -340,15 +340,15 @@ epicsShareFunc int epicsShareAPI ca_array_put
  *
  * type         R   data type from db_access.h
  * count        R   array element count
- * chan         R   channel identifier  
+ * chan         R   channel identifier
  * pValue       R       new channel value copied from this location
  * pFunc        R   pointer to call-back function
  * pArg         R   copy of this pointer passed to pFunc
  */
 epicsShareFunc int epicsShareAPI ca_array_put_callback
 (
-     chtype                 type,   
-     unsigned long          count,   
+     chtype                 type,
+     unsigned long          count,
      chid                   chanId,
      const void *           pValue,
      caEventCallBackFunc *  pFunc,
@@ -365,10 +365,10 @@ epicsShareFunc int epicsShareAPI ca_array_put_callback
 /*
  * ca_bget()
  *
- * WARNING: this copies the new value into a string (dbr_string_t) 
+ * WARNING: this copies the new value into a string (dbr_string_t)
  *      (and not into an integer)
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   W   channel value copied to this location
  */
 #define ca_bget(chan, pValue) \
@@ -377,9 +377,9 @@ ca_array_get(DBR_STRING, 1u, chan, (dbr_string_t *)(pValue))
 /*
  * ca_rget()
  *
- * WARNING: this copies the new value into a 32 bit float (dbr_float_t) 
+ * WARNING: this copies the new value into a 32 bit float (dbr_float_t)
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   W   channel value copied to this location
  */
 #define ca_rget(chan, pValue) \
@@ -389,7 +389,7 @@ ca_array_get(DBR_FLOAT, 1u, chan, (dbr_float_t *)(pValue))
  * ca_rget()
  *
  * type     R   data type from db_access.h
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   W   channel value copied to this location
  */
 #define ca_get(type, chan, pValue) ca_array_get(type, 1u, chan, pValue)
@@ -399,13 +399,13 @@ ca_array_get(DBR_FLOAT, 1u, chan, (dbr_float_t *)(pValue))
  *
  * type     R   data type from db_access.h
  * count    R   array element count
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   W   channel value copied to this location
  */
 epicsShareFunc int epicsShareAPI ca_array_get
 (
-     chtype         type,   
-     unsigned long  count,   
+     chtype         type,
+     unsigned long  count,
      chid           chanId,
      void *         pValue
 );
@@ -419,10 +419,10 @@ epicsShareFunc int epicsShareAPI ca_array_get
 /*
  * ca_bget_callback()
  *
- * WARNING: this returns the new value as a string (dbr_string_t) 
+ * WARNING: this returns the new value as a string (dbr_string_t)
  *      (and not as an integer)
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pFunc    R   pointer to call-back function
  * pArg     R   copy of this pointer passed to pFunc
  */
@@ -432,9 +432,9 @@ ca_array_get_callback (DBR_STRING, 1u, chan, pFunc, pArg)
 /*
  * ca_rget_callback()
  *
- * WARNING: this returns the new value as a float (dbr_float_t) 
+ * WARNING: this returns the new value as a float (dbr_float_t)
  *
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pFunc    R   pointer to call-back function
  * pArg     R   copy of this pointer passed to pFunc
  */
@@ -445,7 +445,7 @@ ca_array_get_callback (DBR_FLOAT, 1u, chan, pFunc, pArg)
  * ca_get_callback()
  *
  * type     R   data type from db_access.h
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pFunc    R   pointer to call-back function
  * pArg     R   copy of this pointer passed to pFunc
  */
@@ -457,14 +457,14 @@ ca_array_get_callback (type, 1u, chan, pFunc, pArg)
  *
  * type     R   data type from db_access.h
  * count    R   array element count
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pFunc    R   pointer to call-back function
  * pArg     R   copy of this pointer passed to pFunc
  */
 epicsShareFunc int epicsShareAPI ca_array_get_callback
 (
-     chtype                 type,   
-     unsigned long          count,   
+     chtype                 type,
+     unsigned long          count,
      chid                   chanId,
      caEventCallBackFunc *  pFunc,
      void *                 pArg
@@ -476,7 +476,7 @@ epicsShareFunc int epicsShareAPI ca_array_get_callback
 /*  NOTES:                                                              */
 /*  1)  Evid may be omited by passing a NULL pointer                    */
 /*                                                                      */
-/*  2)  An array count of zero specifies the native db count            */ 
+/*  2)  An array count of zero specifies the native db count            */
 /*                                                                      */
 /************************************************************************/
 
@@ -485,7 +485,7 @@ epicsShareFunc int epicsShareAPI ca_array_get_callback
  *
  * type     R   data type from db_access.h
  * count    R   array element count
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * mask     R   event mask - one of {DBE_VALUE, DBE_ALARM, DBE_LOG}
  * pFunc    R   pointer to call-back function
  * pArg     R   copy of this pointer passed to pFunc
@@ -493,8 +493,8 @@ epicsShareFunc int epicsShareAPI ca_array_get_callback
  */
 epicsShareFunc int epicsShareAPI ca_create_subscription
 (
-     chtype                 type,   
-     unsigned long          count,   
+     chtype                 type,
+     unsigned long          count,
      chid                   chanId,
      long                   mask,
      caEventCallBackFunc *  pFunc,
@@ -535,24 +535,24 @@ epicsShareFunc chid epicsShareAPI ca_evid_to_chid ( evid id );
 /*   FLOW OF TYPICAL APPLICATION                                        */
 /*                                                                      */
 /*   search()       ! Obtain Channel ids                                */
-/*   .              ! "				                                    */
+/*   .              ! "                                                 */
 /*   .              ! "                                                 */
 /*   pend_io        ! wait for channels to connect                      */
 /*                                                                      */
 /*   get()          ! several requests for remote info                  */
-/*   get()          ! "					                                */
-/*   add_event()    ! "					                                */	
-/*   get()          ! "					                                */
+/*   get()          ! "                                                 */
+/*   add_event()    ! "                                                 */
+/*   get()          ! "                                                 */
 /*   .                                                                  */
 /*   .                                                                  */
 /*   .                                                                  */
 /*   flush_io()     ! send get requests                                 */
 /*                  ! optional parallel processing                      */
-/*   .              ! "					                                */
-/*   .              ! "					                                */
+/*   .              ! "                                                 */
+/*   .              ! "                                                 */
 /*   pend_io()      ! wait for replies from get requests                */
 /*   .              ! access to requested data                          */
-/*   .              ! "					                                */
+/*   .              ! "                                                 */
 /*   pend_event()   ! wait for requested events                         */
 /*                                                                      */
 /************************************************************************/
@@ -562,7 +562,7 @@ epicsShareFunc chid epicsShareAPI ca_evid_to_chid ( evid id );
 /*  functions specified with add_event when events occur. If the        */
 /*  timeout is specified as 0 an infinite timeout is assumed.           */
 /*  ca_flush_io() is called by this routine. If ca_pend_io ()           */
-/*  is called when no IO is outstanding then it will return immediately */ 
+/*  is called when no IO is outstanding then it will return immediately */
 /*  without processing.                                                 */
 /************************************************************************/
 
@@ -577,8 +577,8 @@ epicsShareFunc int epicsShareAPI ca_pend_event (ca_real timeOut);
 /*
  * ca_pend_io()
  *
- * timeOut  R   wait for this delay in seconds but return early 
- *              if all get requests (or search requests with null 
+ * timeOut  R   wait for this delay in seconds but return early
+ *              if all get requests (or search requests with null
  *              connection handler pointer have completed)
  */
 epicsShareFunc int epicsShareAPI ca_pend_io (ca_real timeOut);
@@ -589,7 +589,7 @@ epicsShareFunc int epicsShareAPI ca_pend (ca_real timeout, int early);
 /*
  * ca_test_io()
  *
- * returns TRUE when get requests (or search requests with null 
+ * returns TRUE when get requests (or search requests with null
  * connection handler pointer) are outstanding
  */
 epicsShareFunc int epicsShareAPI ca_test_io (void);
@@ -611,8 +611,8 @@ epicsShareFunc int epicsShareAPI ca_flush_io (void);
  */
 epicsShareFunc void epicsShareAPI ca_signal
 (
-     long errorCode,    
-     const char *pCtxStr     
+     long errorCode,
+     const char *pCtxStr
 );
 
 /*
@@ -625,10 +625,10 @@ epicsShareFunc void epicsShareAPI ca_signal
  */
 epicsShareFunc void epicsShareAPI ca_signal_with_file_and_lineno
 (
-     long errorCode,    
-     const char *pCtxStr,    
-     const char *pFileStr,   
-     int lineNo     
+     long errorCode,
+     const char *pCtxStr,
+     const char *pFileStr,
+     int lineNo
 );
 
 /*
@@ -639,7 +639,7 @@ epicsShareFunc void epicsShareAPI ca_signal_with_file_and_lineno
  * pFormat      R   printf dtyle format string (and optional arguments)
  *
  */
-epicsShareFunc void epicsShareAPI ca_signal_formated (long ca_status, const char *pfilenm, 
+epicsShareFunc void epicsShareAPI ca_signal_formated (long ca_status, const char *pfilenm,
                                        int lineno, const char *pFormat, ...);
 
 /*
@@ -651,13 +651,13 @@ epicsShareFunc void epicsShareAPI ca_signal_formated (long ca_status, const char
  */
 epicsShareFunc const char * epicsShareAPI ca_host_name (chid channel);
 /* thread safe version */
-epicsShareFunc unsigned epicsShareAPI ca_get_host_name ( chid pChan, 
+epicsShareFunc unsigned epicsShareAPI ca_get_host_name ( chid pChan,
     char *pBuf, unsigned bufLength );
 
 /*
  *  CA_ADD_FD_REGISTRATION
  *
- *  call their function with their argument whenever 
+ *  call their function with their argument whenever
  *  a new fd is added or removed
  *  (for use with a manager of the select system call under UNIX)
  *
@@ -665,7 +665,7 @@ epicsShareFunc unsigned epicsShareAPI ca_get_host_name ( chid pChan,
  *  if (!opened) then fd was deleted
  *
  */
-typedef void CAFDHANDLER (void *parg, int fd, int opened); 
+typedef void CAFDHANDLER (void *parg, int fd, int opened);
 
 /*
  * ca_add_fd_registration()
@@ -696,7 +696,7 @@ epicsShareFunc int epicsShareAPI ca_add_fd_registration
  *
  * create a sync group
  *
- * pgid     W   pointer to sync group id that will be written   
+ * pgid     W   pointer to sync group id that will be written
  */
 epicsShareFunc int epicsShareAPI ca_sg_create (CA_SYNC_GID *  pgid);
 
@@ -705,16 +705,16 @@ epicsShareFunc int epicsShareAPI ca_sg_create (CA_SYNC_GID *  pgid);
  *
  * delete a sync group
  *
- * gid      R   sync group id 
+ * gid      R   sync group id
  */
 epicsShareFunc int epicsShareAPI ca_sg_delete (const CA_SYNC_GID gid);
 
 /*
  * ca_sg_block()
  *
- * block for IO performed within a sync group to complete 
+ * block for IO performed within a sync group to complete
  *
- * gid      R   sync group id 
+ * gid      R   sync group id
  * timeout  R   wait for this duration prior to timing out
  *          and returning ECA_TIMEOUT
  */
@@ -726,7 +726,7 @@ epicsShareFunc int epicsShareAPI ca_sg_block (const CA_SYNC_GID gid, ca_real tim
  * test for sync group IO operations in progress
  *
  * gid      R   sync group id
- * 
+ *
  * returns one of ECA_BADSYNCGRP, ECA_IOINPROGRESS, ECA_IODONE
  */
 epicsShareFunc int epicsShareAPI ca_sg_test (const CA_SYNC_GID gid);
@@ -747,16 +747,16 @@ epicsShareFunc int epicsShareAPI ca_sg_reset(const CA_SYNC_GID gid);
  * gid      R   sync group id
  * type     R   data type from db_access.h
  * count    R   array element count
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   W   channel value copied to this location
  */
 epicsShareFunc int epicsShareAPI ca_sg_array_get
 (
     const CA_SYNC_GID gid,
-    chtype type, 
+    chtype type,
     unsigned long count,
     chid chan,
-    void *pValue  
+    void *pValue
 );
 
 #define ca_sg_get(gid, type, chan, pValue) \
@@ -771,16 +771,16 @@ ca_sg_array_get (gid, type, 1u, chan, pValue)
  * gid      R   sync group id
  * type     R   data type from db_access.h
  * count    R   array element count
- * chan     R   channel identifier  
+ * chan     R   channel identifier
  * pValue   R   new channel value copied from this location
  */
 epicsShareFunc int epicsShareAPI ca_sg_array_put
 (
     const CA_SYNC_GID gid,
-    chtype type, 
+    chtype type,
     unsigned long count,
     chid chan,
-    const void *pValue  
+    const void *pValue
 );
 
 #define ca_sg_put(gid, type, chan, pValue) \
@@ -801,11 +801,11 @@ epicsShareFunc void epicsShareAPI ca_dump_dbr (chtype type, unsigned count, cons
 /*
  * ca_v42_ok()
  *
- * Put call back is available if the CA server is on version is 4.2 
+ * Put call back is available if the CA server is on version is 4.2
  *  or higher.
  *
  * chan     R   channel identifier
- * 
+ *
  * (returns true or false)
  */
 epicsShareFunc int epicsShareAPI ca_v42_ok (chid chan);
@@ -865,12 +865,12 @@ ca_build_and_connect(NAME, XXXXX, 1, CHIDPTR, YYYYY, 0, 0)
 #define ca_array_build(NAME,XXXXX, ZZZZZZ, CHIDPTR,YYYYY)\
 ca_build_and_connect(NAME, XXXXX, ZZZZZZ, CHIDPTR, YYYYY, 0, 0)
 epicsShareFunc int epicsShareAPI ca_build_and_connect
-    ( const char *pChanName, chtype, unsigned long, 
+    ( const char *pChanName, chtype, unsigned long,
     chid * pChanID, void *, caCh * pFunc, void * pArg );
 #define ca_search(pChanName, pChanID)\
 ca_search_and_connect (pChanName, pChanID, 0, 0)
 epicsShareFunc int epicsShareAPI ca_search_and_connect
-    ( const char * pChanName, chid * pChanID, 
+    ( const char * pChanName, chid * pChanID,
     caCh *pFunc, void * pArg );
 epicsShareFunc int epicsShareAPI ca_channel_status (epicsThreadId tid);
 epicsShareFunc int epicsShareAPI ca_clear_event ( evid eventID );
diff --git a/modules/ca/src/client/caerr.h b/modules/ca/src/client/caerr.h
index 5393096..fd67a5f 100644
--- a/modules/ca/src/client/caerr.h
+++ b/modules/ca/src/client/caerr.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
@@ -17,7 +17,7 @@
  *
  *  Author: Jeffrey O. Hill
  *
- */ 
+ */
 
 
 #ifndef INCLcaerrh
@@ -78,9 +78,9 @@
 (CA_INSERT_MSG_NO(NUMBER) | CA_INSERT_SEVERITY(SEVERITY))
 
 /*
- * In the lines below "defunct" indicates that current release 
+ * In the lines below "defunct" indicates that current release
  * servers and client library will not return this error code, but
- * servers on earlier releases that communicate with current clients 
+ * servers on earlier releases that communicate with current clients
  * might still generate exceptions with these error constants
  */
 #define ECA_NORMAL          DEFMSG(CA_K_SUCCESS,    0) /* success */
@@ -89,10 +89,10 @@
 #define ECA_UKNSERV         DEFMSG(CA_K_ERROR,      3) /* defunct */
 #define ECA_SOCK            DEFMSG(CA_K_ERROR,      4) /* defunct */
 #define ECA_CONN            DEFMSG(CA_K_WARNING,    5) /* defunct */
-#define ECA_ALLOCMEM        DEFMSG(CA_K_WARNING,    6) 
+#define ECA_ALLOCMEM        DEFMSG(CA_K_WARNING,    6)
 #define ECA_UKNCHAN         DEFMSG(CA_K_WARNING,    7) /* defunct */
 #define ECA_UKNFIELD        DEFMSG(CA_K_WARNING,    8) /* defunct */
-#define ECA_TOLARGE         DEFMSG(CA_K_WARNING,    9) 
+#define ECA_TOLARGE         DEFMSG(CA_K_WARNING,    9)
 #define ECA_TIMEOUT         DEFMSG(CA_K_WARNING,   10)
 #define ECA_NOSUPPORT       DEFMSG(CA_K_WARNING,   11) /* defunct */
 #define ECA_STRTOBIG        DEFMSG(CA_K_WARNING,   12) /* defunct */
diff --git a/modules/ca/src/client/caeventmask.h b/modules/ca/src/client/caeventmask.h
index 5f09145..4f0f2ec 100644
--- a/modules/ca/src/client/caeventmask.h
+++ b/modules/ca/src/client/caeventmask.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #ifndef INCLcaeventmaskh
@@ -13,12 +13,12 @@
 
 /*
     event selections
-    (If any more than 8 of these are needed then update the 
-    select field in the event_block struct in db_event.c from 
+    (If any more than 8 of these are needed then update the
+    select field in the event_block struct in db_event.c from
     unsigned char to unsigned short)
 
 
-    DBE_VALUE 
+    DBE_VALUE
     Trigger an event when a significant change in the channel's value
     occurs. Relies on the monitor deadband field under DCT.
 
diff --git a/modules/ca/src/client/casw.cpp b/modules/ca/src/client/casw.cpp
index ed17660..e527a3c 100644
--- a/modules/ca/src/client/casw.cpp
+++ b/modules/ca/src/client/casw.cpp
@@ -5,10 +5,10 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/* 
+/*
  *
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
@@ -23,7 +23,7 @@
 
 #define epicsAssertAuthor "Jeff Hill [e-mail]"
 
-#include "envDefs.h" 
+#include "envDefs.h"
 #include "errlog.h"
 #include "osiWireFormat.h"
 
@@ -40,8 +40,8 @@ public:
     void release ( void * );
 private:
     tsFreeList < class bhe, 0x100 > freeList;
-	bheFreeStoreMgr ( const bheFreeStoreMgr & );
-	bheFreeStoreMgr & operator = ( const bheFreeStoreMgr & );
+    bheFreeStoreMgr ( const bheFreeStoreMgr & );
+    bheFreeStoreMgr & operator = ( const bheFreeStoreMgr & );
 };
 
 void * bheFreeStoreMgr::allocate ( size_t size )
@@ -108,7 +108,7 @@ int main ( int argc, char ** argv )
     sock = epicsSocketCreate ( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
     if ( sock == INVALID_SOCKET ) {
         char sockErrBuf[64];
-        epicsSocketConvertErrnoToString ( 
+        epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         errlogPrintf ("casw: unable to create datagram socket because = \"%s\"\n",
             sockErrBuf );
@@ -122,7 +122,7 @@ int main ( int argc, char ** argv )
     status = bind ( sock, &addr.sa, sizeof (addr) );
     if ( status < 0 ) {
         char sockErrBuf[64];
-        epicsSocketConvertErrnoToString ( 
+        epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         epicsSocketDestroy ( sock );
         errlogPrintf ( "casw: unable to bind to an unconstrained address because = \"%s\"\n",
@@ -134,7 +134,7 @@ int main ( int argc, char ** argv )
     status = socket_ioctl ( sock, FIONBIO, &yes );
     if ( status < 0 ) {
         char sockErrBuf[64];
-        epicsSocketConvertErrnoToString ( 
+        epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         epicsSocketDestroy ( sock );
         errlogPrintf ( "casw: unable to set socket to nonblocking state because \"%s\"\n",
@@ -169,7 +169,7 @@ int main ( int argc, char ** argv )
     status = socket_ioctl ( sock, FIONBIO, &no );
     if ( status < 0 ) {
         char sockErrBuf[64];
-        epicsSocketConvertErrnoToString ( 
+        epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         epicsSocketDestroy ( sock );
         errlogPrintf ( "casw: unable to set socket to blocking state because \"%s\"\n",
@@ -185,7 +185,7 @@ int main ( int argc, char ** argv )
                             &addr.sa, &addrSize );
         if ( status <= 0 ) {
             char sockErrBuf[64];
-            epicsSocketConvertErrnoToString ( 
+            epicsSocketConvertErrnoToString (
                 sockErrBuf, sizeof ( sockErrBuf ) );
             epicsSocketDestroy ( sock );
             errlogPrintf ("casw: error from recv was = \"%s\"\n",
@@ -196,7 +196,7 @@ int main ( int argc, char ** argv )
         if ( addr.sa.sa_family != AF_INET ) {
             continue;
         }
-        
+
         unsigned byteCount = static_cast <unsigned> ( status );
         pCurMsg = reinterpret_cast < const caHdr * > ( ( pCurBuf = buf ) );
         while ( byteCount ) {
@@ -213,9 +213,9 @@ int main ( int argc, char ** argv )
                 epicsTime previousTime;
                 struct sockaddr_in ina;
 
-                /* 
+                /*
                  * this allows a fan-out server to potentially
-                 * insert the true address of the CA server 
+                 * insert the true address of the CA server
                  *
                  * old servers:
                  *   1) set this field to one of the ip addresses of the host _or_
@@ -252,8 +252,8 @@ int main ( int argc, char ** argv )
                 bhe *pBHE = beaconTable.lookup ( ina );
                 if ( pBHE ) {
                     previousTime = pBHE->updateTime ( guard );
-                    anomaly = pBHE->updatePeriod ( 
-                        guard, programBeginTime, 
+                    anomaly = pBHE->updatePeriod (
+                        guard, programBeginTime,
                         currentTime, beaconNumber, protocolRevision );
                 }
                 else {
@@ -264,7 +264,7 @@ int main ( int argc, char ** argv )
                      * time that we have seen a server's beacon
                      * shortly after the program started up)
                      */
-                    pBHE = new ( bheFreeList ) 
+                    pBHE = new ( bheFreeList )
                         bhe ( mutex, currentTime, beaconNumber, ina );
                     if ( pBHE ) {
                         if ( beaconTable.add ( *pBHE ) < 0 ) {
@@ -275,7 +275,7 @@ int main ( int argc, char ** argv )
                 }
                 if ( anomaly || interest > 1 ) {
                     char date[64];
-                    currentTime.strftime ( date, sizeof ( date ), 
+                    currentTime.strftime ( date, sizeof ( date ),
                         "%Y-%m-%d %H:%M:%S.%09f");
                     char host[64];
                     ipAddrToA ( &ina, host, sizeof ( host ) );
@@ -288,11 +288,11 @@ int main ( int argc, char ** argv )
                             pPrefix = "  ";
                         }
                     }
-                    printf ( "%s%-40s %s\n", 
+                    printf ( "%s%-40s %s\n",
                         pPrefix, host, date );
                     if ( anomaly && interest > 0 ) {
-                        printf ( "\testimate=%f current=%f\n", 
-                            pBHE->period ( guard ), 
+                        printf ( "\testimate=%f current=%f\n",
+                            pBHE->period ( guard ),
                             currentTime - previousTime );
                     }
                     fflush(stdout);
diff --git a/modules/ca/src/client/catime.c b/modules/ca/src/client/catime.c
index cccd940..ab758d3 100644
--- a/modules/ca/src/client/catime.c
+++ b/modules/ca/src/client/catime.c
@@ -5,17 +5,17 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
- *  CA performance test 
+ *  CA performance test
  *
- *  History 
+ *  History
  *  joh 09-12-89 Initial release
  *  joh 12-20-94 portability
  *
- * 
+ *
  */
 
 #include <stdio.h>
@@ -45,7 +45,7 @@ typedef struct testItem {
     char                name[128];
     int                 type;
     int                 count;
-    void *              pValue;	
+    void *              pValue;
 } ti;
 
 typedef void tf ( ti *pItems, unsigned iterations, unsigned *pInlineIter );
@@ -144,7 +144,7 @@ unsigned    *pInlineIter
 {
     int status;
     unsigned i;
-        
+
     for (i=0u; i<iterations; i++) {
         status = ca_clear_channel (pItems[i].chix);
         SEVCHK (status, NULL);
@@ -166,7 +166,7 @@ unsigned    *pInlineIter
     ti      *pi;
     int     status;
     dbr_int_t   val;
-  
+
     for (pi=pItems; pi < &pItems[iterations]; pi++) {
         status = ca_array_put(
                 pi->type,
@@ -257,7 +257,7 @@ unsigned    *pInlineIter
 {
     ti  *pi;
     int status;
-  
+
     for (pi=pItems; pi<&pItems[iterations]; pi++) {
         status = ca_array_get(
                 pi->type,
@@ -337,7 +337,7 @@ unsigned    *pInlineIter
 {
     ti  *pi;
     int status;
-  
+
     for (pi=pItems; pi<&pItems[iterations]; pi++) {
         status = ca_array_get(
                 pi->type,
@@ -361,9 +361,9 @@ static void measure_get_latency (ti *pItems, unsigned iterations)
     epicsTimeStamp start_time;
     double delay;
     double X = 0u;
-    double XX = 0u; 
-    double max = DBL_MIN; 
-    double min = DBL_MAX; 
+    double XX = 0u;
+    double max = DBL_MIN;
+    double min = DBL_MAX;
     double mean;
     double stdDev;
     ti *pi;
@@ -371,7 +371,7 @@ static void measure_get_latency (ti *pItems, unsigned iterations)
 
     for ( pi = pItems; pi < &pItems[iterations]; pi++ ) {
         epicsTimeGetCurrent ( &start_time );
-        status = ca_array_get ( pi->type, pi->count, 
+        status = ca_array_get ( pi->type, pi->count,
                         pi->chix, pi->pValue );
         SEVCHK ( status, NULL );
         status = ca_pend_io ( 100.0 );
@@ -395,13 +395,13 @@ static void measure_get_latency (ti *pItems, unsigned iterations)
 
     mean = X/iterations;
     stdDev = sqrt ( XX/iterations - mean*mean );
-    printf ( 
+    printf (
         "Get Latency - "
         "mean = %3.1f uS, "
         "std dev = %3.1f uS, "
         "min = %3.1f uS "
         "max = %3.1f uS\n",
-        mean * 1e6, stdDev * 1e6, 
+        mean * 1e6, stdDev * 1e6,
         min * 1e6, max * 1e6 );
 }
 
@@ -412,9 +412,9 @@ static void printSearchStat ( const ti * pi, unsigned iterations )
 {
     unsigned i;
     double  X = 0u;
-    double  XX = 0u; 
-    double  max = DBL_MIN; 
-    double  min = DBL_MAX; 
+    double  XX = 0u;
+    double  max = DBL_MIN;
+    double  min = DBL_MAX;
     double  mean;
     double  stdDev;
 
@@ -432,7 +432,7 @@ static void printSearchStat ( const ti * pi, unsigned iterations )
 
     mean = X / iterations;
     stdDev = sqrt( XX / iterations - mean * mean );
-    printf ( 
+    printf (
         "Search tries per chan - "
         "mean = %3.1f "
         "std dev = %3.1f "
@@ -458,10 +458,10 @@ void timeIt ( tf *pfunc, ti *pItems, unsigned iterations,
     delay = epicsTimeDiffInSeconds ( &end_time, &start_time );
     if ( delay > 0.0 ) {
         double freq = ( iterations * inlineIter ) / delay;
-        printf ( "Per Op, %8.4f uS ( %8.4f MHz )", 
+        printf ( "Per Op, %8.4f uS ( %8.4f MHz )",
             1e6 / freq, freq / 1e6 );
         if ( pItems != NULL ) {
-            printf(", %8.4f snd Mbps, %8.4f rcv Mbps\n", 
+            printf(", %8.4f snd Mbps, %8.4f rcv Mbps\n",
                 (inlineIter*nBytesSent*CHAR_BIT)/(delay*1e6),
                 (inlineIter*nBytesRecv*CHAR_BIT)/(delay*1e6) );
         }
@@ -479,13 +479,13 @@ static void test ( ti *pItems, unsigned iterations )
     unsigned payloadSize, dblPayloadSize;
     unsigned nBytesSent, nBytesRecv;
 
-    payloadSize =     
+    payloadSize =
         dbr_size_n ( pItems[0].type, pItems[0].count );
     payloadSize = CA_MESSAGE_ALIGN ( payloadSize );
 
     dblPayloadSize = dbr_size [ DBR_DOUBLE ];
     dblPayloadSize = CA_MESSAGE_ALIGN ( dblPayloadSize );
-    
+
     if ( payloadSize > dblPayloadSize ) {
         unsigned factor = payloadSize / dblPayloadSize;
         while ( factor ) {
@@ -500,15 +500,15 @@ static void test ( ti *pItems, unsigned iterations )
     printf ( "\t### async put test ###\n");
     nBytesSent = sizeof ( caHdr ) + CA_MESSAGE_ALIGN( payloadSize );
     nBytesRecv = 0u;
-    timeIt ( test_put, pItems, iterations, 
-        nBytesSent * iterations, 
+    timeIt ( test_put, pItems, iterations,
+        nBytesSent * iterations,
         nBytesRecv * iterations );
 
     printf ( "\t### async get test ###\n");
     nBytesSent = sizeof ( caHdr );
     nBytesRecv = sizeof ( caHdr ) + CA_MESSAGE_ALIGN ( payloadSize );
-    timeIt ( test_get, pItems, iterations, 
-        nBytesSent * ( iterations ), 
+    timeIt ( test_get, pItems, iterations,
+        nBytesSent * ( iterations ),
         nBytesRecv * ( iterations ) );
 
     printf ("\t### synch get test ###\n");
@@ -520,7 +520,7 @@ static void test ( ti *pItems, unsigned iterations )
     else if ( iterations > 10 ) {
         iterations /= 10;
     }
-    timeIt ( test_wait, pItems, iterations, 
+    timeIt ( test_wait, pItems, iterations,
         nBytesSent * iterations,
         nBytesRecv * iterations );
 }
@@ -528,7 +528,7 @@ static void test ( ti *pItems, unsigned iterations )
 /*
  * catime ()
  */
-int catime ( const char * channelName, 
+int catime ( const char * channelName,
     unsigned channelCount, enum appendNumberFlag appNF )
 {
     unsigned i;
@@ -536,7 +536,7 @@ int catime ( const char * channelName,
     unsigned strsize;
     unsigned nBytesSent, nBytesRecv;
     ti *pItemList;
-    
+
     if ( channelCount == 0 ) {
         printf ( "channel count was zero\n" );
         return 0;
@@ -547,15 +547,15 @@ int catime ( const char * channelName,
         return -1;
     }
 
-    SEVCHK ( ca_context_create ( ca_disable_preemptive_callback ), 
+    SEVCHK ( ca_context_create ( ca_disable_preemptive_callback ),
         "Unable to initialize" );
 
     if ( appNF == appendNumber ) {
-        printf ( "Testing with %u channels named %snnn\n", 
+        printf ( "Testing with %u channels named %snnn\n",
             channelCount, channelName );
     }
     else {
-        printf ( "Testing with %u channels named %s\n", 
+        printf ( "Testing with %u channels named %s\n",
              channelCount, channelName );
     }
 
@@ -573,7 +573,7 @@ int catime ( const char * channelName,
         pItemList[i].name[strsize]= '\0';
         pItemList[i].count = 0;
         pItemList[i].pValue = 0;
-        nBytesSent += 2 * ( CA_MESSAGE_ALIGN ( strlen ( pItemList[i].name ) ) 
+        nBytesSent += 2 * ( CA_MESSAGE_ALIGN ( strlen ( pItemList[i].name ) )
                             + sizeof (caHdr) );
         nBytesRecv += 2 * sizeof (caHdr);
     }
@@ -582,7 +582,7 @@ int catime ( const char * channelName,
     printf ( "--------------------\n" );
     timeIt ( test_search, pItemList, channelCount, nBytesSent, nBytesRecv );
     printSearchStat ( pItemList, channelCount );
-    
+
     for ( i = 0; i < channelCount; i++ ) {
         size_t count = ca_element_count ( pItemList[i].chix );
         size_t size = sizeof ( dbr_string_t ) * count;
@@ -608,7 +608,7 @@ int catime ( const char * channelName,
         for ( j = 0; j < pItemList[i].count; j++ ) {
             pFltVal[j] = (dbr_float_t) val;
         }
-        pItemList[i].type = DBR_FLOAT; 
+        pItemList[i].type = DBR_FLOAT;
     }
     printf ( "DBR_FLOAT Test\n" );
     printf ( "--------------\n" );
@@ -621,13 +621,13 @@ int catime ( const char * channelName,
         for ( j = 0; j < pItemList[i].count; j++ ) {
             pDblVal[j] = (dbr_double_t) val;
         }
-        pItemList[i].type = DBR_DOUBLE; 
+        pItemList[i].type = DBR_DOUBLE;
     }
     printf ( "DBR_DOUBLE Test\n" );
     printf ( "---------------\n" );
     test ( pItemList, channelCount );
 
-    
+
     for ( i = 0; i < channelCount; i++ ) {
         dbr_string_t * pStrVal = ( dbr_string_t * ) pItemList[i].pValue;
         double val = i;
@@ -635,7 +635,7 @@ int catime ( const char * channelName,
         for ( j = 0; j < pItemList[i].count; j++ ) {
             sprintf ( pStrVal[j], "%f", val );
         }
-        pItemList[i].type = DBR_STRING; 
+        pItemList[i].type = DBR_STRING;
     }
     printf ( "DBR_STRING Test\n" );
     printf ( "---------------\n" );
@@ -648,7 +648,7 @@ int catime ( const char * channelName,
         for ( j = 0; j < pItemList[i].count; j++ ) {
             pIntVal[j] = (dbr_int_t) val;
         }
-        pItemList[i].type = DBR_INT; 
+        pItemList[i].type = DBR_INT;
     }
     printf ( "DBR_INT Test\n" );
     printf ( "------------\n" );
@@ -661,8 +661,8 @@ int catime ( const char * channelName,
         for ( j = 0; j < pItemList[i].count; j++ ) {
             pDblVal[j] = 0;
         }
-        pItemList[i].type = DBR_DOUBLE; 
-    }   
+        pItemList[i].type = DBR_DOUBLE;
+    }
     measure_get_latency ( pItemList, channelCount );
 
     printf ( "Free Channel Test\n" );
@@ -670,10 +670,10 @@ int catime ( const char * channelName,
     timeIt ( test_free, pItemList, channelCount, 0, 0 );
 
     SEVCHK ( ca_task_exit (), "Unable to free resources at exit" );
-    
+
     for ( i = 0; i < channelCount; i++ ) {
         free ( pItemList[i].pValue );
-    }   
+    }
 
     free ( pItemList );
 
diff --git a/modules/ca/src/client/catimeMain.c b/modules/ca/src/client/catimeMain.c
index 598ec45..cc9ec83 100644
--- a/modules/ca/src/client/catimeMain.c
+++ b/modules/ca/src/client/catimeMain.c
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
 #include <stdio.h>
diff --git a/modules/ca/src/client/comBuf.cpp b/modules/ca/src/client/comBuf.cpp
index 94245d3..ec99ad0 100644
--- a/modules/ca/src/client/comBuf.cpp
+++ b/modules/ca/src/client/comBuf.cpp
@@ -5,20 +5,20 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
  */
 
 #include <stdexcept>
@@ -33,7 +33,7 @@ bool comBuf::flushToWire ( wireSendAdapter & wire, const epicsTime & currentTime
     unsigned index = this->nextReadIndex;
     unsigned finalIndex = this->commitIndex;
     while ( index < finalIndex ) {
-        unsigned nBytes = wire.sendBytes ( 
+        unsigned nBytes = wire.sendBytes (
             &this->buf[index], finalIndex - index, currentTime );
         if ( nBytes == 0u ) {
             this->nextReadIndex = index;
@@ -45,9 +45,9 @@ bool comBuf::flushToWire ( wireSendAdapter & wire, const epicsTime & currentTime
     return true;
 }
 
-// throwing the exception from a function that isnt inline 
+// throwing the exception from a function that isnt inline
 // shrinks the GNU compiled object code
-void comBuf::throwInsufficentBytesException () 
+void comBuf::throwInsufficentBytesException ()
 {
     throw comBuf::insufficentBytesAvailable ();
 }
diff --git a/modules/ca/src/client/comBuf.h b/modules/ca/src/client/comBuf.h
index 59e3878..3425bb3 100644
--- a/modules/ca/src/client/comBuf.h
+++ b/modules/ca/src/client/comBuf.h
@@ -5,7 +5,7 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 /*
  *
@@ -17,8 +17,8 @@
  *  Copyright, 1986, The Regents of the University of California.
  *
  *
- *	Author Jeffrey O. Hill
- *	[e-mail]
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
  */
 
 #ifndef comBufh
@@ -40,23 +40,23 @@ static const unsigned comBufSize = 0x4000;
 class comBufMemoryManager {
 public:
     virtual ~comBufMemoryManager ();
-    virtual void * allocate ( size_t ) = 0; 
-    virtual void release ( void * ) = 0; 
+    virtual void * allocate ( size_t ) = 0;
+    virtual void release ( void * ) = 0;
 };
 
 class wireSendAdapter {
 public:
-    virtual unsigned sendBytes ( const void * pBuf, 
-        unsigned nBytesInBuf, 
+    virtual unsigned sendBytes ( const void * pBuf,
+        unsigned nBytesInBuf,
         const class epicsTime & currentTime ) = 0;
 protected:
     virtual ~wireSendAdapter() {}
 };
 
-enum swioCircuitState { 
-        swioConnected, 
-        swioPeerHangup, 
-        swioPeerAbort, 
+enum swioCircuitState {
+        swioConnected,
+        swioPeerHangup,
+        swioPeerAbort,
         swioLinkFailure,
         swioLocalAbort
 };
@@ -67,7 +67,7 @@ struct statusWireIO {
 
 class wireRecvAdapter {
 public:
-    virtual void recvBytes ( void * pBuf, 
+    virtual void recvBytes ( void * pBuf,
         unsigned nBytesInBuf, statusWireIO & ) = 0;
 protected:
     virtual ~wireRecvAdapter() {}
@@ -106,7 +106,7 @@ public:
     template < class T >
     popStatus pop ( T & );
     static void throwInsufficentBytesException ();
-    void * operator new ( size_t size, 
+    void * operator new ( size_t size,
         comBufMemoryManager  & );
     epicsPlacementDeleteOperator (( void *, comBufMemoryManager & ))
 private:
@@ -119,14 +119,14 @@ private:
     bool push ( const T * ); // disabled
 };
 
-inline void * comBuf::operator new ( size_t size, 
+inline void * comBuf::operator new ( size_t size,
     comBufMemoryManager & mgr )
 {
     return mgr.allocate ( size );
 }
-    
+
 #ifdef CXX_PLACEMENT_DELETE
-inline void comBuf::operator delete ( void * pCadaver, 
+inline void comBuf::operator delete ( void * pCadaver,
     comBufMemoryManager & mgr )
 {
     mgr.release ( pCadaver );
@@ -162,8 +162,8 @@ inline unsigned comBuf :: uncommittedBytes () const
 
 inline unsigned comBuf :: push ( comBuf & bufIn )
 {
-    unsigned nBytes = this->copyInBytes ( 
-        & bufIn.buf[ bufIn.nextReadIndex ], 
+    unsigned nBytes = this->copyInBytes (
+        & bufIn.buf[ bufIn.nextReadIndex ],
         bufIn.commitIndex - bufIn.nextReadIndex );
     bufIn.nextReadIndex += nBytes;
     return nBytes;
@@ -174,11 +174,11 @@ inline unsigned comBuf :: capacityBytes ()
     return comBufSize;
 }
 
-inline void comBuf :: fillFromWire ( 
+inline void comBuf :: fillFromWire (
     wireRecvAdapter & wire, statusWireIO & stat )
 {
-    wire.recvBytes ( 
-        & this->buf[this->nextWriteIndex], 
+    wire.recvBytes (
+        & this->buf[this->nextWriteIndex],
         sizeof ( this->buf ) - this->nextWriteIndex, stat );
     if ( stat.circuitState == swioConnected ) {
         this->nextWriteIndex += stat.bytesCopied;
diff --git a/modules/ca/src/client/comQueRecv.cpp b/modules/ca/src/client/comQueRecv.cpp
index 8826354..4fe7d09 100644
--- a/modules/ca/src/client/comQueRecv.cpp
+++ b/modules/ca/src/client/comQueRecv.cpp
@@ -5,9 +5,9 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
-/*  
+/*
  *
  *
  *                    L O S  A L A M O S
@@ -26,8 +26,8 @@
 #include "iocinf.h"
 #include "virtualCircuit.h"
 
-comQueRecv::comQueRecv ( comBufMemoryManager & comBufMemoryManagerIn ): 
-    comBufMemMgr ( comBufMemoryManagerIn ), nBytesPending ( 0u ) 
+comQueRecv::comQueRecv ( comBufMemoryManager & comBufMemoryManagerIn ):
+    comBufMemMgr ( comBufMemoryManagerIn ), nBytesPending ( 0u )
 {
 }
 
@@ -101,7 +101,7 @@ void comQueRecv::popString ( epicsOldString *pStr )
 }
 
 void comQueRecv::pushLastComBufReceived ( comBuf & bufIn )
-   
+
 {
     bufIn.commitIncomming ();
     comBuf * pComBuf = this->bufs.last ();
@@ -172,7 +172,7 @@ void comQueRecv::removeAndDestroyBuf ( comBuf & buf )
     this->comBufMemMgr.release ( & buf );
 }
 
-epicsUInt8 comQueRecv::popUInt8 () 
+epicsUInt8 comQueRecv::popUInt8 ()
 {
     comBuf * pComBuf = this->bufs.first ();
     if ( ! pComBuf ) {
diff --git a/modules/ca/src/client/comQueRecv.h b/modules/ca/src/client/comQueRecv.h
index 7f3153d..2e71478 100644
--- a/modules/ca/src/client/comQueRecv.h
+++ b/modules/ca/src/client/comQueRecv.h
@@ -5,25 +5,25 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
- *	505 665 1831
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
+ *  505 665 1831
  */
 
-#ifndef comQueRecvh  
+#ifndef comQueRecvh
 #define comQueRecvh
 
 #include "comBuf.h"
@@ -54,8 +54,8 @@ private:
     epicsUInt16 multiBufferPopUInt16 ();
     epicsUInt32 multiBufferPopUInt32 ();
     void removeAndDestroyBuf ( comBuf & );
-	comQueRecv ( const comQueRecv & );
-	comQueRecv & operator = ( const comQueRecv & );
+    comQueRecv ( const comQueRecv & );
+    comQueRecv & operator = ( const comQueRecv & );
 };
 
 inline unsigned comQueRecv::occupiedBytes () const
diff --git a/modules/ca/src/client/comQueSend.cpp b/modules/ca/src/client/comQueSend.cpp
index 6ed516b..7bf75c7 100644
--- a/modules/ca/src/client/comQueSend.cpp
+++ b/modules/ca/src/client/comQueSend.cpp
@@ -5,21 +5,21 @@
 *     Operator of Los Alamos National Laboratory.
 * EPICS BASE Versions 3.13.7
 * and higher are distributed subject to a Software License Agreement found
-* in file LICENSE that is included with this distribution. 
+* in file LICENSE that is included with this distribution.
 \*************************************************************************/
 
-/*  
+/*
+ *
  *
- *                              
  *                    L O S  A L A M O S
  *              Los Alamos National Laboratory
  *               Los Alamos, New Mexico 87545
- *                                  
+ *
  *  Copyright, 1986, The Regents of the University of California.
- *                                  
- *           
- *	Author Jeffrey O. Hill
- *	[e-mail]
+ *
+ *
+ *  Author Jeffrey O. Hill
+ *  [e-mail]
  */
 
 //
@@ -35,7 +35,7 @@
 // a connection dropped.
 // 4) Do not allocate too much memory in exception situatons (such as
 // after a circuit disconnect).
-// 5) Avoid allocating more memory than is absolutely necessary to meet 
+// 5) Avoid allocating more memory than is absolutely necessary to meet
 // the above requirements.
 // 6) Message fragments must never be sent to the IOC when there isnt
 // enough memory to queue part of a message (we also must not force
@@ -44,7 +44,7 @@
 // protocol stream.
 //
 // Implementation:
-// 1) When queuing a complete message, first test to see if a flush is 
+// 1) When queuing a complete message, first test to see if a flush is
 // required. If it is a receive thread scheduals the flush with the
 // send thread, and otherwise directly execute the system call. The
 // send thread must run at a higher priority than the receive thread
@@ -52,14 +52,14 @@
 // 2) Preallocate space for the entire message prior to copying in the
 // message so that message fragments are not flushed out just prior
 // to detecting that memory is unavailable.
-// 3) Return a special error constant when the following situations 
+// 3) Return a special error constant when the following situations
 // are detected when the user is attempting to queue a request
 // from within a user callback executed by a receive thread:
-//      a) A user is queuing more requests that demand a response from a 
+//      a) A user is queuing more requests that demand a response from a
 //      callback than are removed by the response that initiated the
 //      callback, and this situation persists for many callbacks until
 //      all buffering in the system is exausted.
-//      b) A user is queuing many requests that demand a response from one 
+//      b) A user is queuing many requests that demand a response from one
 //      callback until all buffering in the system is exausted.
 //      c) Some combination of both (a) nad (b).
 //
@@ -73,15 +73,15 @@
 #include "db_access.h" // for dbr_short_t etc
 
 // nill message alignment pad bytes
-const char cacNillBytes [] = 
-{ 
+const char cacNillBytes [] =
+{
     0, 0, 0, 0,
     0, 0, 0, 0
 };
 
-comQueSend::comQueSend ( wireSendAdapter & wireIn, 
+comQueSend::comQueSend ( wireSendAdapter & wireIn,
     comBufMemoryManager & comBufMemMgrIn ):
-        comBufMemMgr ( comBufMemMgrIn ), wire ( wireIn ), 
+        comBufMemMgr ( comBufMemMgrIn ), wire ( wireIn ),
             nBytesPending ( 0u )
 {
 }
@@ -91,7 +91,7 @@ comQueSend::~comQueSend ()
     this->clear ();
 }
 
-void comQueSend::clear () 
+void comQueSend::clear ()
 {
     comBuf *pBuf;
 
@@ -181,32 +181,32 @@ const comQueSend::copyScalarFunc_t comQueSend::dbrCopyScalar [39] = {
     &comQueSend::copy_dbr_invalid  // DBR_CLASS_NAME
 };
 
-void comQueSend::copy_dbr_string ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_string ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast < const char * > ( pValue ), nElem * MAX_STRING_SIZE );
 }
 
-void comQueSend::copy_dbr_short ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_short ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast <const dbr_short_t *> ( pValue ), nElem );
 }
 
-void comQueSend::copy_dbr_float ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_float ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast <const dbr_float_t *> ( pValue ), nElem );
 }
 
-void comQueSend::copy_dbr_char ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_char ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast <const dbr_char_t *> ( pValue ), nElem );
 }
 
-void comQueSend::copy_dbr_long ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_long ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast <const dbr_long_t *> ( pValue ), nElem );
 }
 
-void comQueSend::copy_dbr_double ( const void *pValue, unsigned nElem ) 
+void comQueSend::copy_dbr_double ( const void *pValue, unsigned nElem )
 {
     this->push ( static_cast <const dbr_double_t *> ( pValue ), nElem );
 }
@@ -258,7 +258,7 @@ const comQueSend::copyVectorFunc_t comQueSend::dbrCopyVector [39] = {
     &comQueSend::copy_dbr_invalid  // DBR_CLASS_NAME
 };
 
-comBuf * comQueSend::popNextComBufToSend () 
+comBuf * comQueSend::popNextComBufToSend ()
 {
     comBuf *pBuf = this->bufs.get ();
     if ( pBuf ) {
@@ -279,9 +279,9 @@ comBuf * comQueSend::popNextComBufToSend ()
 }
 
 void comQueSend::insertRequestHeader (
-    ca_uint16_t request, ca_uint32_t payloadSize, 
-    ca_uint16_t dataType, ca_uint32_t nElem, ca_uint32_t cid, 
-    ca_uint32_t requestDependent, bool v49Ok ) 
+    ca_uint16_t request, ca_uint32_t payloadSize,
+    ca_uint16_t dataType, ca_uint32_t nElem, ca_uint32_t cid,
+    ca_uint32_t requestDependent, bool v49Ok )
 {
     if ( payloadSize < 0xffff && nElem < 0xffff ) {
         comBuf * pComBuf = this->bufs.last ();
@@ -289,12 +289,12 @@ void comQueSend::insertRequestHeader (
             pComBuf = newComBuf ();
             this->pushComBuf ( *pComBuf );
         }
-        pComBuf->push ( request ); 
-        pComBuf->push ( static_cast < ca_uint16_t > ( payloadSize ) ); 
-        pComBuf->push ( dataType ); 
-        pComBuf->push ( static_cast < ca_uint16_t > ( nElem ) ); 
-        pComBuf->push ( cid ); 
-        pComBuf->push ( requestDependent );  
+        pComBuf->push ( request );
+        pComBuf->push ( static_cast < ca_uint16_t > ( payloadSize ) );
+        pComBuf->push ( dataType );
+        pComBuf->push ( static_cast < ca_uint16_t > ( nElem ) );
+        pComBuf->push ( cid );
+        pComBuf->push ( requestDependent );
     }
     else if ( v49Ok ) {
         comBuf * pComBuf = this->bufs.last ();
@@ -302,14 +302,14 @@ void comQueSend::insertRequestHeader (
             pComBuf = newComBuf ();
             this->pushComBuf ( *pComBuf );
         }
-        pComBuf->push ( request ); 
-        pComBuf->push ( static_cast < ca_uint16_t > ( 0xffff ) ); 
-        pComBuf->push ( dataType ); 
-        pComBuf->push ( static_cast < ca_uint16_t > ( 0u ) ); 
-        pComBuf->push ( cid ); 
-        pComBuf->push ( requestDependent );  
-        pComBuf->push ( payloadSize ); 
-        pComBuf->push ( nElem ); 
+        pComBuf->push ( request );
+        pComBuf->push ( static_cast < ca_uint16_t > ( 0xffff ) );
+        pComBuf->push ( dataType );
+        pComBuf->push ( static_cast < ca_uint16_t > ( 0u ) );
+        pComBuf->push ( cid );
+        pComBuf->push ( requestDependent );
+        pComBuf->push ( payloadSize );
+        pComBuf->push ( nElem );
     }
     else {
         throw cacChannel::outOfBounds ();
@@ -317,9 +317,9 @@ void comQueSend::insertRequestHeader (
 }
 
 void comQueSend::insertRequestWithPayLoad (
-    ca_uint16_t request, unsigned dataType, arrayElementCount nElem, 
-    ca_uint32_t cid, ca_uint32_t requestDependent, 
-    const void * pPayload, bool v49Ok ) 
+    ca_uint16_t request, unsigned dataType, arrayElementCount nElem,
+    ca_uint32_t cid, ca_uint32_t requestDependent,
+    const void * pPayload, bool v49Ok )
 {
     if ( INVALID_DB_REQ ( dataType ) ) {