Gcc15 and cleanup

.editorconfig

@@ -0,0 +1,12 @@
+# Documentation for this file: https://EditorConfig.org
+
+root = true
+
+# Unix-style newlines ending every file,
+# as some compilers complain about files not ending in newline
+# Enforce consistent space indent style in source code
+# and remove all trailing spaces
+[*.{c,cc,cpp,h,hpp,pl,py,yml,rst}]
+insert_final_newline = true
+indent_style = space
+trim_trailing_whitespace = true

.github/workflows/check-editorconfig.yml

@@ -0,0 +1,13 @@
+name: Check EditorConfig
+
+on:
+  push:
+  pull_request:
+
+jobs:
+  editorconfig:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: EditorConfig-Action
+        uses: greut/eclint-action@v0

asyn/Makefile

@@ -33,7 +33,7 @@ asyn_SYS_LIBS_cygwin32 = $(CYGWIN_RPC_LIB)
 # Some linux systems moved RPC related symbols to libtirpc
 # Define TIRPC in configure/CONFIG_SITE in this case
 ifeq ($(TIRPC),YES)
-  USR_INCLUDES_Linux += -I/usr/include/tirpc
+  USR_INCLUDES_Linux += -I$(SYSROOT)/usr/include/tirpc
   asyn_SYS_LIBS_Linux += tirpc
 endif
 

asyn/asynDriver/asynDriver.h

@@ -80,7 +80,7 @@ typedef struct asynUser {
     int            reason;
     epicsTimeStamp timestamp;
     /* The following are for additional information from method calls */
-    int            auxStatus;     /* For auxillary status*/
+    int            auxStatus;     /* For auxiliary status*/
     int            alarmStatus;   /* Typically for EPICS record alarm status */
     int            alarmSeverity; /* Typically for EPICS record alarm severity */
 }asynUser;

asyn/asynGpib/asynGpib.c

@@ -101,9 +101,9 @@ static asynStatus connect(void *drvPvt,asynUser *pasynUser);
 static asynStatus disconnect(void *drvPvt,asynUser *pasynUser);
 /*asynOctet methods */
 static asynStatus writeIt(void *drvPvt,asynUser *pasynUser,
-    const char *data,size_t maxchars,size_t *nbytesTransfered);
+    const char *data,size_t maxchars,size_t *nbytesTransferred);
 static asynStatus readIt(void *drvPvt,asynUser *pasynUser,
-    char *data,size_t maxchars,size_t *nbytesTransfered,int *eomReason);
+    char *data,size_t maxchars,size_t *nbytesTransferred,int *eomReason);
 static asynStatus gpibFlush(void *drvPvt,asynUser *pasynUser);
 static asynStatus setInputEos(void *drvPvt,asynUser *pasynUser,
     const char *eos,int eoslen);
@@ -389,28 +389,28 @@ static asynStatus disconnect(void *drvPvt,asynUser *pasynUser)
 
 /*asynOctet methods */
 static asynStatus writeIt(void *drvPvt,asynUser *pasynUser,
-    const char *data,size_t numchars,size_t *nbytesTransfered)
+    const char *data,size_t numchars,size_t *nbytesTransferred)
 {
     int nt;
     asynStatus status;
     GETgpibPvtasynGpibPort
 
     status =  pasynGpibPort->write(pgpibPvt->asynGpibPortPvt,pasynUser,
               data,(int)numchars,&nt);
-    *nbytesTransfered = (size_t)nt;
+    *nbytesTransferred = (size_t)nt;
     return status;
 }
 
 static asynStatus readIt(void *drvPvt,asynUser *pasynUser,
-    char *data,size_t maxchars,size_t *nbytesTransfered,int *eomReason)
+    char *data,size_t maxchars,size_t *nbytesTransferred,int *eomReason)
 {
     int nt;
     asynStatus status;
     GETgpibPvtasynGpibPort
 
     status = pasynGpibPort->read(pgpibPvt->asynGpibPortPvt,pasynUser,
                data,(int)maxchars,&nt,eomReason);
-    *nbytesTransfered = (size_t)nt;
+    *nbytesTransferred = (size_t)nt;
     if(status!=asynSuccess) return status;
     if(pgpibPvt->eoslen==1 && nt>0) {
         if(data[nt-1]==pgpibPvt->eos) {
@@ -420,9 +420,9 @@ static asynStatus readIt(void *drvPvt,asynUser *pasynUser,
     }
     if(nt<(int)maxchars) data[nt] = 0;
     if((nt==maxchars) && eomReason) *eomReason |= ASYN_EOM_CNT;
-    *nbytesTransfered = (size_t)nt;
+    *nbytesTransferred = (size_t)nt;
     pasynOctetBase->callInterruptUsers(pasynUser,pgpibPvt->pasynPvt,
-        data,nbytesTransfered,eomReason);
+        data,nbytesTransferred,eomReason);
     return status;
 }
 
@@ -538,7 +538,7 @@ static asynStatus pollAddr(void *drvPvt,asynUser *pasynUser, int onOff)
                  asynCommonType,0);
         if(!pasynInterface) {
             asynPrint(pasynUser, ASYN_TRACE_ERROR,
-                "%s asynGpib:pollIt cant find interface asynCommon\n",
+                "%s asynGpib:pollIt can't find interface asynCommon\n",
                 pgpibPvt->portName);
             return asynError;
         }

asyn/asynGpib/asynGpibDriver.h

@@ -69,10 +69,10 @@ struct asynGpibPort {
     asynStatus (*disconnect)(void *drvPvt,asynUser *pasynUser);
     /*asynOctet methods passed through from asynGpib*/
     asynStatus (*read)(void *drvPvt,asynUser *pasynUser,
-                      char *data,int maxchars,int *nbytesTransfered,
+                      char *data,int maxchars,int *nbytesTransferred,
                       int *eomReason);
     asynStatus (*write)(void *drvPvt,asynUser *pasynUser,
-                      const char *data,int numchars,int *nbytesTransfered);
+                      const char *data,int numchars,int *nbytesTransferred);
     asynStatus (*flush)(void *drvPvt,asynUser *pasynUser);
     asynStatus (*setEos)(void *drvPvt,asynUser *pasynUser,
                 const char *eos,int eoslen);

asyn/asynPortDriver/asynPortDriver.cpp

@@ -2710,16 +2710,16 @@ asynStatus asynPortDriver::flushOctet(asynUser *pasynUser)
 {
     double     savetimeout = pasynUser->timeout;
     char       buffer[100];
-    size_t     nbytesTransfered;
+    size_t     nbytesTransferred;
     static const char *functionName = "flushOctet";
 
     pasynUser->timeout = .05;
     while(1) {
-        nbytesTransfered = 0;
-        readOctet(pasynUser, buffer, sizeof(buffer), &nbytesTransfered, 0);
-        if (nbytesTransfered==0) break;
+        nbytesTransferred = 0;
+        readOctet(pasynUser, buffer, sizeof(buffer), &nbytesTransferred, 0);
+        if (nbytesTransferred==0) break;
         asynPrintIO(pasynUser, ASYN_TRACEIO_DEVICE,
-            buffer, nbytesTransfered, "%s:%s\n", driverName, functionName);
+            buffer, nbytesTransferred, "%s:%s\n", driverName, functionName);
     }
     pasynUser->timeout = savetimeout;
     return asynSuccess;
@@ -3929,7 +3929,7 @@ static asynDrvUser ifaceDrvUser = {
                This controls the number of parameter tables that are created.
   * \param[in] interfaceMask Bit mask defining the asyn interfaces that this driver supports.
                 The bit mask values are defined in asynPortDriver.h, e.g. asynInt32Mask.
-  * \param[in] interruptMask Bit mask definining the asyn interfaces that can generate interrupts (callbacks).
+  * \param[in] interruptMask Bit mask defining the asyn interfaces that can generate interrupts (callbacks).
                The bit mask values are defined in asynPortDriver.h, e.g. asynInt8ArrayMask.
   * \param[in] asynFlags Flags when creating the asyn port driver; includes ASYN_CANBLOCK, ASYN_MULTIDEVICE and ASYN_DESTRUCTIBLE.
   * \param[in] autoConnect The autoConnect flag for the asyn port driver.
@@ -3970,7 +3970,7 @@ void asynPortDriver::exceptionHandler(asynUser *pasynUser, asynException excepti
     asynPortDriver *pPvt = (asynPortDriver *)pasynUser->userPvt;
 
     if (exception == asynExceptionShutdown && pPvt->needsShutdown()) {
-        // This code is only excuted once: asynManager will not raise the
+        // This code is only executed once: asynManager will not raise the
         // exception if the port has been shut down before.
         asynPrint(pPvt->pasynUserSelf, ASYN_TRACE_FLOW,
                   "%s: port=%s Port is shutting down.\n",

asyn/asynPortDriver/asynPortDriver.h

@@ -59,7 +59,7 @@ class callbackThread;
   *    destructor. Remember, however, that no code from classes deriving from
   *    yours may run at this point, because the object is already partly
   *    destroyed. For example, virtual functions will behave as if not
-  *    overriden, and threads spawned by derived classes must already be
+  *    overridden, and threads spawned by derived classes must already be
   *    stopped.
   *
   * 3. To use functionality that requires an intact object, release resources by
@@ -68,7 +68,7 @@ class callbackThread;
   *    a derived class. On process exit, `shutdownPortDriver()` will be called
   *    before the destructors are executed.
   *
-  * 4. Your overriden `shutdownPortDriver()` must call the base class
+  * 4. Your overridden `shutdownPortDriver()` must call the base class
   *    implementation.
   *
   * 5. When deleting a driver instance directly (e.g., in your test code),

asyn/asynRecord/asynRecord.c

@@ -264,7 +264,7 @@ typedef struct asynRecordDset {
 } asynRecordDset;
 
 asynRecordDset asynRecordDevice = {
-    5,0,0,0,getIoIntInfo,0};
+    5, 0, 0, 0, (DEVSUPFUN)getIoIntInfo, 0 };
 epicsExportAddress(dset, asynRecordDevice);
 
 
@@ -470,7 +470,7 @@ static long special(struct dbAddr * paddr, int after)
         /* Set old value to this, so monitorStatus won't think another
          * thread changed it */
         /* Must do this before calling setTraceFile, because it generates
-         * an exeception, which calls monitorStatus() */
+         * an exception, which calls monitorStatus() */
         pasynRecPvt->old.traceFd = fd;
         status = pasynTrace->setTraceFile(pasynUser, fd);
         if(status != asynSuccess) {
@@ -1472,7 +1472,7 @@ static void performOctetIO(asynUser * pasynUser)
     asynRecPvt *pasynRecPvt = pasynUser->userPvt;
     asynRecord *pasynRec = pasynRecPvt->prec;
     asynStatus status = asynSuccess;
-    size_t nbytesTransfered = 0;
+    size_t nbytesTransferred = 0;
     char *inptr;
     char *outptr;
     size_t inlen;
@@ -1495,7 +1495,7 @@ static void performOctetIO(asynUser * pasynUser)
         outptr = pasynRecPvt->outbuff;
     } else {
         /* Binary output mode */
-        /* Check that nowt is not greated than omax */
+        /* Check that nowt is not greater than omax */
         if(pasynRec->nowt > pasynRec->omax) pasynRec->nowt = pasynRec->omax;
         nwrite = pasynRec->nowt;
         outptr = pasynRec->optr;
@@ -1524,7 +1524,7 @@ static void performOctetIO(asynUser * pasynUser)
     if((pasynRec->tmod == asynTMOD_Write) ||
         (pasynRec->tmod == asynTMOD_Write_Read)) {
         /* Send the message */
-        nbytesTransfered = 0;
+        nbytesTransferred = 0;
         if(pasynRec->ofmt == asynFMT_Binary) {
             status = pasynRecPvt->pasynOctet->getOutputEos(
                                     pasynRecPvt->asynOctetPvt,pasynUser,
@@ -1535,31 +1535,31 @@ static void performOctetIO(asynUser * pasynUser)
                 pasynRecPvt->pasynOctet->setOutputEos(pasynRecPvt->asynOctetPvt,
                                                       pasynUser,NULL,0);
             status = pasynRecPvt->pasynOctet->write(pasynRecPvt->asynOctetPvt,
-                                pasynUser, outptr, nwrite, &nbytesTransfered);
+                                pasynUser, outptr, nwrite, &nbytesTransferred);
             if (saveEosLen)
                 pasynRecPvt->pasynOctet->setOutputEos(pasynRecPvt->asynOctetPvt,
                                                       pasynUser,saveEosBuf,saveEosLen);
         } else {
             /* ASCII or Hybrid mode */
             status = pasynRecPvt->pasynOctet->write(pasynRecPvt->asynOctetPvt,
-                                 pasynUser, outptr, nwrite, &nbytesTransfered);
+                                 pasynUser, outptr, nwrite, &nbytesTransferred);
         }
-        pasynRec->nawt = (int)nbytesTransfered;
-        asynPrintIO(pasynUser, ASYN_TRACEIO_DEVICE, outptr, nbytesTransfered,
+        pasynRec->nawt = (int)nbytesTransferred;
+        asynPrintIO(pasynUser, ASYN_TRACEIO_DEVICE, outptr, nbytesTransferred,
            "%s: nwrite=%lu, status=%d, nawt=%lu\n", pasynRec->name, (unsigned long)nwrite,
-                    status, (unsigned long)nbytesTransfered);
-        if(status != asynSuccess || nbytesTransfered != nwrite) {
+                    status, (unsigned long)nbytesTransferred);
+        if(status != asynSuccess || nbytesTransferred != nwrite) {
             /* Something is wrong if we couldn't write everything */
             reportError(pasynRec, status, "Write error, nout=%d, %s",
-                        nbytesTransfered, pasynUser->errorMessage);
+                        nbytesTransferred, pasynUser->errorMessage);
         }
     }
     if((pasynRec->tmod == asynTMOD_Read) ||
         (pasynRec->tmod == asynTMOD_Write_Read)) {
         /* Set the input buffer to all zeros */
         memset(inptr, 0, inlen);
         /* Read the message  */
-        nbytesTransfered = 0;
+        nbytesTransferred = 0;
         status = asynSuccess;
         if(pasynRec->ifmt == asynFMT_Binary) {
             status = pasynRecPvt->pasynOctet->getInputEos(
@@ -1571,67 +1571,67 @@ static void performOctetIO(asynUser * pasynUser)
                 pasynRecPvt->pasynOctet->setInputEos(pasynRecPvt->asynOctetPvt,
                                                      pasynUser,NULL,0);
             status = pasynRecPvt->pasynOctet->read(pasynRecPvt->asynOctetPvt,
-                  pasynUser, inptr, nread, &nbytesTransfered,&eomReason);
+                  pasynUser, inptr, nread, &nbytesTransferred,&eomReason);
             if (saveEosLen)
                 pasynRecPvt->pasynOctet->setInputEos(pasynRecPvt->asynOctetPvt,
                                                      pasynUser,saveEosBuf,saveEosLen);
         } else {
             /* ASCII or Hybrid mode */
             status = pasynRecPvt->pasynOctet->read(pasynRecPvt->asynOctetPvt,
-                        pasynUser, inptr, nread, &nbytesTransfered, &eomReason);
+                        pasynUser, inptr, nread, &nbytesTransferred, &eomReason);
         }
         if(status!=asynSuccess) {
             reportError(pasynRec, status,
                 "Error %s", pasynUser->errorMessage);
         } else {
-            asynPrintIO(pasynUser, ASYN_TRACEIO_DEVICE, inptr, nbytesTransfered,
+            asynPrintIO(pasynUser, ASYN_TRACEIO_DEVICE, inptr, nbytesTransferred,
              "%s: inlen=%lu, status=%d, ninp=%lu\n", pasynRec->name, (unsigned long)inlen,
-                    status, (unsigned long)nbytesTransfered);
+                    status, (unsigned long)nbytesTransferred);
         }
         pasynRec->eomr = eomReason;
-        inlen = nbytesTransfered;
+        inlen = nbytesTransferred;
         if(status != asynSuccess) {
             reportError(pasynRec, status,
                 "%s  nread %d %s",
                 ((status==asynTimeout) ? "timeout" :
                  (status==asynOverflow) ? "overflow" : "error"),
-                 nbytesTransfered, pasynUser->errorMessage);
+                 nbytesTransferred, pasynUser->errorMessage);
             recGblSetSevr(pasynRec,READ_ALARM, MAJOR_ALARM);
         }
         /* Check for input buffer overflow */
         if((pasynRec->ifmt == asynFMT_ASCII) &&
-            (nbytesTransfered >= (int) sizeof(pasynRec->ainp))) {
+            (nbytesTransferred >= (int) sizeof(pasynRec->ainp))) {
             reportError(pasynRec, status, "Overflow nread %d %s",
-                nbytesTransfered, pasynUser->errorMessage);
+                nbytesTransferred, pasynUser->errorMessage);
             recGblSetSevr(pasynRec,READ_ALARM, MINOR_ALARM);
             /* terminate response with \0 */
             inptr[sizeof(pasynRec->ainp) - 1] = '\0';
         } else if((pasynRec->ifmt == asynFMT_Hybrid) &&
-                   ((int)nbytesTransfered >= pasynRec->imax)) {
+                   ((int)nbytesTransferred >= pasynRec->imax)) {
             reportError(pasynRec, status, "Overflow nread %d %s",
-                nbytesTransfered, pasynUser->errorMessage);
+                nbytesTransferred, pasynUser->errorMessage);
             recGblSetSevr(pasynRec,READ_ALARM, MINOR_ALARM);
             /* terminate response with \0 */
             inptr[pasynRec->imax - 1] = '\0';
         } else if((pasynRec->ifmt == asynFMT_Binary) &&
-                   ((int)nbytesTransfered > pasynRec->imax)) {
+                   ((int)nbytesTransferred > pasynRec->imax)) {
             /* This should not be able to happen */
             reportError(pasynRec, status, "Overflow nread %d %s",
-                nbytesTransfered, pasynUser->errorMessage);
+                nbytesTransferred, pasynUser->errorMessage);
             recGblSetSevr(pasynRec,READ_ALARM, MINOR_ALARM);
         } else if(pasynRec->ifmt != asynFMT_Binary) {
             /* Not binary and no input buffer overflow has occurred */
             /* Add null at end of input.  This is safe because of tests above */
-            inptr[nbytesTransfered] = '\0';
+            inptr[nbytesTransferred] = '\0';
         }
-        pasynRec->nord = (int)nbytesTransfered;    /* Number of bytes read */
+        pasynRec->nord = (int)nbytesTransferred;    /* Number of bytes read */
         /* Copy to tinp with dbTranslateEscape */
         ntranslate = epicsStrSnPrintEscaped(pasynRec->tinp,
                                            sizeof(pasynRec->tinp),
                                            inptr, inlen);
         asynPrint(pasynUser, ASYN_TRACEIO_DEVICE,
-             "%s: inlen=%lu, nbytesTransfered=%lu, ntranslate=%d\n",
-             pasynRec->name, (unsigned long)inlen, (unsigned long)nbytesTransfered, ntranslate);
+             "%s: inlen=%lu, nbytesTransferred=%lu, ntranslate=%d\n",
+             pasynRec->name, (unsigned long)inlen, (unsigned long)nbytesTransferred, ntranslate);
     }
 }
 
@@ -1685,7 +1685,7 @@ static void gpibAddressedCmd(asynUser * pasynUser)
     asynGpib   *pasynGpib = pasynRecPvt->pasynGpib;
     void       *asynGpibPvt = pasynRecPvt->asynGpibPvt;
     asynStatus status;
-    size_t     nbytesTransfered;
+    size_t     nbytesTransferred;
     char       acmd[6];
     char       cmd_char = 0;
     int lenCmd = 6;
@@ -1727,8 +1727,8 @@ static void gpibAddressedCmd(asynUser * pasynUser)
         }
         /* Read the response byte  */
         status = pasynRecPvt->pasynOctet->read(pasynRecPvt->asynOctetPvt,
-                pasynUser, (char *) &pasynRec->spr, 1, &nbytesTransfered,0);
-        if(status != asynSuccess || nbytesTransfered != 1) {
+                pasynUser, (char *) &pasynRec->spr, 1, &nbytesTransferred,0);
+        if(status != asynSuccess || nbytesTransferred != 1) {
             reportError(pasynRec, status,
                         "Error in GPIB Serial Poll read, %s",
                         pasynUser->errorMessage);

asyn/devEpics/devAsynFloat64.c

@@ -126,11 +126,11 @@ typedef struct analogDset { /* analog  dset */
 } analogDset;
 
 analogDset asynAiFloat64 = {
-    6, 0, 0, initAi,        getIoIntInfo, processAi, 0};
+    6, 0, 0, (DEVSUPFUN)initAi,        (DEVSUPFUN)getIoIntInfo, (DEVSUPFUN)processAi, 0 };
 analogDset asynAoFloat64 = {
-    6, 0, 0, initAo,        getIoIntInfo, processAo, 0};
+    6, 0, 0, (DEVSUPFUN)initAo,        (DEVSUPFUN)getIoIntInfo, (DEVSUPFUN)processAo, 0 };
 analogDset asynAiFloat64Average = {
-    6, 0, 0, initAiAverage, getIoIntInfo, processAiAverage, 0};
+    6, 0, 0, (DEVSUPFUN)initAiAverage, (DEVSUPFUN)getIoIntInfo, (DEVSUPFUN)processAiAverage, 0 };
 
 epicsExportAddress(dset, asynAiFloat64);
 epicsExportAddress(dset, asynAoFloat64);