Merge pull request #56 from sparkfun/release_candidate

PaulZC · web-flow · commit 99f261a6f45e · 2021-08-09T09:36:55.000+01:00
v2.0.11
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=SparkFun u-blox GNSS Arduino Library
-version=2.0.10
+version=2.0.11
 author=SparkFun Electronics <techsupport@sparkfun.com>
 maintainer=SparkFun Electronics <sparkfun.com>
 sentence=Library for I2C and Serial Communication with u-blox GNSS modules<br/><br/>
diff --git a/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp b/src/SparkFun_u-blox_GNSS_Arduino_Library.cpp
@@ -70,83 +70,83 @@ void SFE_UBLOX_GNSS::end(void)
       _debugSerial->println(F("end: the file buffer has been deleted. You will need to call setFileBufferSize before .begin to create a new one."));
     }
 #endif
-    delete[] ubxFileBuffer;
+    delete[] ubxFileBuffer; // Created with new[]
     ubxFileBuffer = NULL; // Redundant?
     fileBufferSize = 0; // Reset file buffer size. User will have to call setFileBufferSize again
     fileBufferMaxAvail = 0;
   }
 
   if (moduleSWVersion != NULL)
   {
-    delete[] moduleSWVersion;
+    delete moduleSWVersion; // Created with new moduleSWVersion_t
     moduleSWVersion = NULL; // Redundant?
   }
 
   if (currentGeofenceParams != NULL)
   {
-    delete[] currentGeofenceParams;
+    delete currentGeofenceParams; // Created with new geofenceParams_t
     currentGeofenceParams = NULL; // Redundant?
   }
 
   if (packetUBXNAVTIMELS != NULL)
   {
-    delete[] packetUBXNAVTIMELS;
+    delete packetUBXNAVTIMELS; // Created with new UBX_NAV_TIMELS_t
     packetUBXNAVTIMELS = NULL; // Redundant?
   }
 
   if (packetUBXNAVPOSECEF != NULL)
   {
     if (packetUBXNAVPOSECEF->callbackData != NULL)
     {
-      delete[] packetUBXNAVPOSECEF->callbackData;
+      delete packetUBXNAVPOSECEF->callbackData; // Created with new UBX_NAV_POSECEF_data_t
     }
-    delete[] packetUBXNAVPOSECEF;
+    delete packetUBXNAVPOSECEF; // Created with new UBX_NAV_POSECEF_t
     packetUBXNAVPOSECEF = NULL; // Redundant?
   }
 
   if (packetUBXNAVSTATUS != NULL)
   {
     if (packetUBXNAVSTATUS->callbackData != NULL)
     {
-      delete[] packetUBXNAVSTATUS->callbackData;
+      delete packetUBXNAVSTATUS->callbackData;
     }
-    delete[] packetUBXNAVSTATUS;
+    delete packetUBXNAVSTATUS;
     packetUBXNAVSTATUS = NULL; // Redundant?
   }
 
   if (packetUBXNAVDOP != NULL)
   {
     if (packetUBXNAVDOP->callbackData != NULL)
     {
-      delete[] packetUBXNAVDOP->callbackData;
+      delete packetUBXNAVDOP->callbackData;
     }
-    delete[] packetUBXNAVDOP;
+    delete packetUBXNAVDOP;
     packetUBXNAVDOP = NULL; // Redundant?
   }
 
   if (packetUBXNAVATT != NULL)
   {
     if (packetUBXNAVATT->callbackData != NULL)
     {
-      delete[] packetUBXNAVATT->callbackData;
+      delete packetUBXNAVATT->callbackData;
     }
-    delete[] packetUBXNAVATT;
+    delete packetUBXNAVATT;
     packetUBXNAVATT = NULL; // Redundant?
   }
 
   if (packetUBXNAVPVT != NULL)
   {
     if (packetUBXNAVPVT->callbackData != NULL)
     {
-      delete[] packetUBXNAVPVT->callbackData;
+      delete packetUBXNAVPVT->callbackData;
 #ifndef SFE_UBLOX_REDUCED_PROG_MEM
       if (_printDebug == true)
       {
         _debugSerial->println(F("end: packetUBXNAVPVT->callbackData has been deleted"));
       }
 #endif
     }
-    delete[] packetUBXNAVPVT;
+    delete packetUBXNAVPVT;
     packetUBXNAVPVT = NULL; // Redundant?
 #ifndef SFE_UBLOX_REDUCED_PROG_MEM
     if (_printDebug == true)
@@ -160,199 +160,199 @@ void SFE_UBLOX_GNSS::end(void)
   {
     if (packetUBXNAVODO->callbackData != NULL)
     {
-      delete[] packetUBXNAVODO->callbackData;
+      delete packetUBXNAVODO->callbackData;
     }
-    delete[] packetUBXNAVODO;
+    delete packetUBXNAVODO;
     packetUBXNAVODO = NULL; // Redundant?
   }
 
   if (packetUBXNAVVELECEF != NULL)
   {
     if (packetUBXNAVVELECEF->callbackData != NULL)
     {
-      delete[] packetUBXNAVVELECEF->callbackData;
+      delete packetUBXNAVVELECEF->callbackData;
     }
-    delete[] packetUBXNAVVELECEF;
+    delete packetUBXNAVVELECEF;
     packetUBXNAVVELECEF = NULL; // Redundant?
   }
 
   if (packetUBXNAVVELNED != NULL)
   {
     if (packetUBXNAVVELNED->callbackData != NULL)
     {
-      delete[] packetUBXNAVVELNED->callbackData;
+      delete packetUBXNAVVELNED->callbackData;
     }
-    delete[] packetUBXNAVVELNED;
+    delete packetUBXNAVVELNED;
     packetUBXNAVVELNED = NULL; // Redundant?
   }
 
   if (packetUBXNAVHPPOSECEF != NULL)
   {
     if (packetUBXNAVHPPOSECEF->callbackData != NULL)
     {
-      delete[] packetUBXNAVHPPOSECEF->callbackData;
+      delete packetUBXNAVHPPOSECEF->callbackData;
     }
-    delete[] packetUBXNAVHPPOSECEF;
+    delete packetUBXNAVHPPOSECEF;
     packetUBXNAVHPPOSECEF = NULL; // Redundant?
   }
 
   if (packetUBXNAVHPPOSLLH != NULL)
   {
     if (packetUBXNAVHPPOSLLH->callbackData != NULL)
     {
-      delete[] packetUBXNAVHPPOSLLH->callbackData;
+      delete packetUBXNAVHPPOSLLH->callbackData;
     }
-    delete[] packetUBXNAVHPPOSLLH;
+    delete packetUBXNAVHPPOSLLH;
     packetUBXNAVHPPOSLLH = NULL; // Redundant?
   }
 
   if (packetUBXNAVCLOCK != NULL)
   {
     if (packetUBXNAVCLOCK->callbackData != NULL)
     {
-      delete[] packetUBXNAVCLOCK->callbackData;
+      delete packetUBXNAVCLOCK->callbackData;
     }
-    delete[] packetUBXNAVCLOCK;
+    delete packetUBXNAVCLOCK;
     packetUBXNAVCLOCK = NULL; // Redundant?
   }
 
   if (packetUBXNAVSVIN != NULL)
   {
     if (packetUBXNAVSVIN->callbackData != NULL)
     {
-      delete[] packetUBXNAVSVIN->callbackData;
+      delete packetUBXNAVSVIN->callbackData;
     }
-    delete[] packetUBXNAVSVIN;
+    delete packetUBXNAVSVIN;
     packetUBXNAVSVIN = NULL; // Redundant?
   }
 
   if (packetUBXNAVRELPOSNED != NULL)
   {
     if (packetUBXNAVRELPOSNED->callbackData != NULL)
     {
-      delete[] packetUBXNAVRELPOSNED->callbackData;
+      delete packetUBXNAVRELPOSNED->callbackData;
     }
-    delete[] packetUBXNAVRELPOSNED;
+    delete packetUBXNAVRELPOSNED;
     packetUBXNAVRELPOSNED = NULL; // Redundant?
   }
 
   if (packetUBXRXMSFRBX != NULL)
   {
     if (packetUBXRXMSFRBX->callbackData != NULL)
     {
-      delete[] packetUBXRXMSFRBX->callbackData;
+      delete packetUBXRXMSFRBX->callbackData;
     }
-    delete[] packetUBXRXMSFRBX;
+    delete packetUBXRXMSFRBX;
     packetUBXRXMSFRBX = NULL; // Redundant?
   }
 
   if (packetUBXRXMRAWX != NULL)
   {
     if (packetUBXRXMRAWX->callbackData != NULL)
     {
-      delete[] packetUBXRXMRAWX->callbackData;
+      delete packetUBXRXMRAWX->callbackData;
     }
-    delete[] packetUBXRXMRAWX;
+    delete packetUBXRXMRAWX;
     packetUBXRXMRAWX = NULL; // Redundant?
   }
 
   if (packetUBXCFGRATE != NULL)
   {
     if (packetUBXCFGRATE->callbackData != NULL)
     {
-      delete[] packetUBXCFGRATE->callbackData;
+      delete packetUBXCFGRATE->callbackData;
     }
-    delete[] packetUBXCFGRATE;
+    delete packetUBXCFGRATE;
     packetUBXCFGRATE = NULL; // Redundant?
   }
 
   if (packetUBXTIMTM2 != NULL)
   {
     if (packetUBXTIMTM2->callbackData != NULL)
     {
-      delete[] packetUBXTIMTM2->callbackData;
+      delete packetUBXTIMTM2->callbackData;
     }
-    delete[] packetUBXTIMTM2;
+    delete packetUBXTIMTM2;
     packetUBXTIMTM2 = NULL; // Redundant?
   }
 
   if (packetUBXESFALG != NULL)
   {
     if (packetUBXESFALG->callbackData != NULL)
     {
-      delete[] packetUBXESFALG->callbackData;
+      delete packetUBXESFALG->callbackData;
     }
-    delete[] packetUBXESFALG;
+    delete packetUBXESFALG;
     packetUBXESFALG = NULL; // Redundant?
   }
 
   if (packetUBXESFSTATUS != NULL)
   {
     if (packetUBXESFSTATUS->callbackData != NULL)
     {
-      delete[] packetUBXESFSTATUS->callbackData;
+      delete packetUBXESFSTATUS->callbackData;
     }
-    delete[] packetUBXESFSTATUS;
+    delete packetUBXESFSTATUS;
     packetUBXESFSTATUS = NULL; // Redundant?
   }
 
   if (packetUBXESFINS != NULL)
   {
     if (packetUBXESFINS->callbackData != NULL)
     {
-      delete[] packetUBXESFINS->callbackData;
+      delete packetUBXESFINS->callbackData;
     }
-    delete[] packetUBXESFINS;
+    delete packetUBXESFINS;
     packetUBXESFINS = NULL; // Redundant?
   }
 
   if (packetUBXESFMEAS != NULL)
   {
     if (packetUBXESFMEAS->callbackData != NULL)
     {
-      delete[] packetUBXESFMEAS->callbackData;
+      delete packetUBXESFMEAS->callbackData;
     }
-    delete[] packetUBXESFMEAS;
+    delete packetUBXESFMEAS;
     packetUBXESFMEAS = NULL; // Redundant?
   }
 
   if (packetUBXESFRAW != NULL)
   {
     if (packetUBXESFRAW->callbackData != NULL)
     {
-      delete[] packetUBXESFRAW->callbackData;
+      delete packetUBXESFRAW->callbackData;
     }
-    delete[] packetUBXESFRAW;
+    delete packetUBXESFRAW;
     packetUBXESFRAW = NULL; // Redundant?
   }
 
   if (packetUBXHNRATT != NULL)
   {
     if (packetUBXHNRATT->callbackData != NULL)
     {
-      delete[] packetUBXHNRATT->callbackData;
+      delete packetUBXHNRATT->callbackData;
     }
-    delete[] packetUBXHNRATT;
+    delete packetUBXHNRATT;
     packetUBXHNRATT = NULL; // Redundant?
   }
 
   if (packetUBXHNRINS != NULL)
   {
     if (packetUBXHNRINS->callbackData != NULL)
     {
-      delete[] packetUBXHNRINS->callbackData;
+      delete packetUBXHNRINS->callbackData;
     }
-    delete[] packetUBXHNRINS;
+    delete packetUBXHNRINS;
     packetUBXHNRINS = NULL; // Redundant?
   }
 
   if (packetUBXHNRPVT != NULL)
   {
     if (packetUBXHNRPVT->callbackData != NULL)
     {
-      delete[] packetUBXHNRPVT->callbackData;
+      delete packetUBXHNRPVT->callbackData;
     }
-    delete[] packetUBXHNRPVT;
+    delete packetUBXHNRPVT;
     packetUBXHNRPVT = NULL; // Redundant?
   }
 
@@ -365,7 +365,7 @@ void SFE_UBLOX_GNSS::setPacketCfgPayloadSize(size_t payloadSize)
   if ((payloadSize == 0) && (payloadCfg != NULL))
   {
     // Zero payloadSize? Dangerous! But we'll free the memory anyway...
-    delete[] payloadCfg;
+    delete[] payloadCfg; // Created with new[]
     payloadCfg = NULL; // Redundant?
     packetCfg.payload = payloadCfg;
     if ((_printDebug == true) || (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging
@@ -386,7 +386,7 @@ void SFE_UBLOX_GNSS::setPacketCfgPayloadSize(size_t payloadSize)
     uint8_t *newPayload = new uint8_t[payloadSize];
     for (size_t i = 0; (i < payloadSize) && (i < packetCfgPayloadSize); i++) // Copy as much existing data as we can
       newPayload[i] = payloadCfg[i];
-    delete[] payloadCfg;
+    delete[] payloadCfg; // Created with new[]
     payloadCfg = newPayload;
     packetCfg.payload = payloadCfg;
     if (payloadCfg == NULL)
@@ -1260,7 +1260,7 @@ void SFE_UBLOX_GNSS::process(uint8_t incoming, ubxPacket *incomingUBX, uint8_t r
             {
               _debugSerial->println(F("process: memory is already allocated for payloadAuto! Deleting..."));
             }
-            delete[] payloadAuto;
+            delete[] payloadAuto; // Created with new[]
             payloadAuto = NULL; // Redundant?
             packetAuto.payload = payloadAuto;
           }
@@ -1797,7 +1797,7 @@ void SFE_UBLOX_GNSS::processUBX(uint8_t incoming, ubxPacket *incomingUBX, uint8_
     // allocated for packetAuto
     if (activePacketBuffer == SFE_UBLOX_PACKET_PACKETAUTO)
     {
-      delete[] payloadAuto;
+      delete[] payloadAuto; // Created with new[]
       payloadAuto = NULL; // Redundant?
       packetAuto.payload = payloadAuto;
     }

Original file line number	Diff line number	Diff line change
`@@ -70,83 +70,83 @@ void SFE_UBLOX_GNSS::end(void)`
`70`	`70`	`_debugSerial->println(F("end: the file buffer has been deleted. You will need to call setFileBufferSize before .begin to create a new one."));`
`71`	`71`	`}`
`72`	`72`	`#endif`
`73`		`- delete[] ubxFileBuffer;`
	`73`	`+ delete[] ubxFileBuffer; // Created with new[]`
`74`	`74`	`ubxFileBuffer = NULL; // Redundant?`
`75`	`75`	`fileBufferSize = 0; // Reset file buffer size. User will have to call setFileBufferSize again`
`76`	`76`	`fileBufferMaxAvail = 0;`
`77`	`77`	`}`
`78`	`78`
`79`	`79`	`if (moduleSWVersion != NULL)`
`80`	`80`	`{`
`81`		`- delete[] moduleSWVersion;`
	`81`	`+ delete moduleSWVersion; // Created with new moduleSWVersion_t`
`82`	`82`	`moduleSWVersion = NULL; // Redundant?`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`if (currentGeofenceParams != NULL)`
`86`	`86`	`{`
`87`		`- delete[] currentGeofenceParams;`
	`87`	`+ delete currentGeofenceParams; // Created with new geofenceParams_t`
`88`	`88`	`currentGeofenceParams = NULL; // Redundant?`
`89`	`89`	`}`
`90`	`90`
`91`	`91`	`if (packetUBXNAVTIMELS != NULL)`
`92`	`92`	`{`
`93`		`- delete[] packetUBXNAVTIMELS;`
	`93`	`+ delete packetUBXNAVTIMELS; // Created with new UBX_NAV_TIMELS_t`
`94`	`94`	`packetUBXNAVTIMELS = NULL; // Redundant?`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`if (packetUBXNAVPOSECEF != NULL)`
`98`	`98`	`{`
`99`	`99`	`if (packetUBXNAVPOSECEF->callbackData != NULL)`
`100`	`100`	`{`
`101`		`- delete[] packetUBXNAVPOSECEF->callbackData;`
	`101`	`+ delete packetUBXNAVPOSECEF->callbackData; // Created with new UBX_NAV_POSECEF_data_t`
`102`	`102`	`}`
`103`		`- delete[] packetUBXNAVPOSECEF;`
	`103`	`+ delete packetUBXNAVPOSECEF; // Created with new UBX_NAV_POSECEF_t`
`104`	`104`	`packetUBXNAVPOSECEF = NULL; // Redundant?`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`if (packetUBXNAVSTATUS != NULL)`
`108`	`108`	`{`
`109`	`109`	`if (packetUBXNAVSTATUS->callbackData != NULL)`
`110`	`110`	`{`
`111`		`- delete[] packetUBXNAVSTATUS->callbackData;`
	`111`	`+ delete packetUBXNAVSTATUS->callbackData;`
`112`	`112`	`}`
`113`		`- delete[] packetUBXNAVSTATUS;`
	`113`	`+ delete packetUBXNAVSTATUS;`
`114`	`114`	`packetUBXNAVSTATUS = NULL; // Redundant?`
`115`	`115`	`}`
`116`	`116`
`117`	`117`	`if (packetUBXNAVDOP != NULL)`
`118`	`118`	`{`
`119`	`119`	`if (packetUBXNAVDOP->callbackData != NULL)`
`120`	`120`	`{`
`121`		`- delete[] packetUBXNAVDOP->callbackData;`
	`121`	`+ delete packetUBXNAVDOP->callbackData;`
`122`	`122`	`}`
`123`		`- delete[] packetUBXNAVDOP;`
	`123`	`+ delete packetUBXNAVDOP;`
`124`	`124`	`packetUBXNAVDOP = NULL; // Redundant?`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`if (packetUBXNAVATT != NULL)`
`128`	`128`	`{`
`129`	`129`	`if (packetUBXNAVATT->callbackData != NULL)`
`130`	`130`	`{`
`131`		`- delete[] packetUBXNAVATT->callbackData;`
	`131`	`+ delete packetUBXNAVATT->callbackData;`
`132`	`132`	`}`
`133`		`- delete[] packetUBXNAVATT;`
	`133`	`+ delete packetUBXNAVATT;`
`134`	`134`	`packetUBXNAVATT = NULL; // Redundant?`
`135`	`135`	`}`
`136`	`136`
`137`	`137`	`if (packetUBXNAVPVT != NULL)`
`138`	`138`	`{`
`139`	`139`	`if (packetUBXNAVPVT->callbackData != NULL)`
`140`	`140`	`{`
`141`		`- delete[] packetUBXNAVPVT->callbackData;`
	`141`	`+ delete packetUBXNAVPVT->callbackData;`
`142`	`142`	`#ifndef SFE_UBLOX_REDUCED_PROG_MEM`
`143`	`143`	`if (_printDebug == true)`
`144`	`144`	`{`
`145`	`145`	`_debugSerial->println(F("end: packetUBXNAVPVT->callbackData has been deleted"));`
`146`	`146`	`}`
`147`	`147`	`#endif`
`148`	`148`	`}`
`149`		`- delete[] packetUBXNAVPVT;`
	`149`	`+ delete packetUBXNAVPVT;`
`150`	`150`	`packetUBXNAVPVT = NULL; // Redundant?`
`151`	`151`	`#ifndef SFE_UBLOX_REDUCED_PROG_MEM`
`152`	`152`	`if (_printDebug == true)`
`@@ -160,199 +160,199 @@ void SFE_UBLOX_GNSS::end(void)`
`160`	`160`	`{`
`161`	`161`	`if (packetUBXNAVODO->callbackData != NULL)`
`162`	`162`	`{`
`163`		`- delete[] packetUBXNAVODO->callbackData;`
	`163`	`+ delete packetUBXNAVODO->callbackData;`
`164`	`164`	`}`
`165`		`- delete[] packetUBXNAVODO;`
	`165`	`+ delete packetUBXNAVODO;`
`166`	`166`	`packetUBXNAVODO = NULL; // Redundant?`
`167`	`167`	`}`
`168`	`168`
`169`	`169`	`if (packetUBXNAVVELECEF != NULL)`
`170`	`170`	`{`
`171`	`171`	`if (packetUBXNAVVELECEF->callbackData != NULL)`
`172`	`172`	`{`
`173`		`- delete[] packetUBXNAVVELECEF->callbackData;`
	`173`	`+ delete packetUBXNAVVELECEF->callbackData;`
`174`	`174`	`}`
`175`		`- delete[] packetUBXNAVVELECEF;`
	`175`	`+ delete packetUBXNAVVELECEF;`
`176`	`176`	`packetUBXNAVVELECEF = NULL; // Redundant?`
`177`	`177`	`}`
`178`	`178`
`179`	`179`	`if (packetUBXNAVVELNED != NULL)`
`180`	`180`	`{`
`181`	`181`	`if (packetUBXNAVVELNED->callbackData != NULL)`
`182`	`182`	`{`
`183`		`- delete[] packetUBXNAVVELNED->callbackData;`
	`183`	`+ delete packetUBXNAVVELNED->callbackData;`
`184`	`184`	`}`
`185`		`- delete[] packetUBXNAVVELNED;`
	`185`	`+ delete packetUBXNAVVELNED;`
`186`	`186`	`packetUBXNAVVELNED = NULL; // Redundant?`
`187`	`187`	`}`
`188`	`188`
`189`	`189`	`if (packetUBXNAVHPPOSECEF != NULL)`
`190`	`190`	`{`
`191`	`191`	`if (packetUBXNAVHPPOSECEF->callbackData != NULL)`
`192`	`192`	`{`
`193`		`- delete[] packetUBXNAVHPPOSECEF->callbackData;`
	`193`	`+ delete packetUBXNAVHPPOSECEF->callbackData;`
`194`	`194`	`}`
`195`		`- delete[] packetUBXNAVHPPOSECEF;`
	`195`	`+ delete packetUBXNAVHPPOSECEF;`
`196`	`196`	`packetUBXNAVHPPOSECEF = NULL; // Redundant?`
`197`	`197`	`}`
`198`	`198`
`199`	`199`	`if (packetUBXNAVHPPOSLLH != NULL)`
`200`	`200`	`{`
`201`	`201`	`if (packetUBXNAVHPPOSLLH->callbackData != NULL)`
`202`	`202`	`{`
`203`		`- delete[] packetUBXNAVHPPOSLLH->callbackData;`
	`203`	`+ delete packetUBXNAVHPPOSLLH->callbackData;`
`204`	`204`	`}`
`205`		`- delete[] packetUBXNAVHPPOSLLH;`
	`205`	`+ delete packetUBXNAVHPPOSLLH;`
`206`	`206`	`packetUBXNAVHPPOSLLH = NULL; // Redundant?`
`207`	`207`	`}`
`208`	`208`
`209`	`209`	`if (packetUBXNAVCLOCK != NULL)`
`210`	`210`	`{`
`211`	`211`	`if (packetUBXNAVCLOCK->callbackData != NULL)`
`212`	`212`	`{`
`213`		`- delete[] packetUBXNAVCLOCK->callbackData;`
	`213`	`+ delete packetUBXNAVCLOCK->callbackData;`
`214`	`214`	`}`
`215`		`- delete[] packetUBXNAVCLOCK;`
	`215`	`+ delete packetUBXNAVCLOCK;`
`216`	`216`	`packetUBXNAVCLOCK = NULL; // Redundant?`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`if (packetUBXNAVSVIN != NULL)`
`220`	`220`	`{`
`221`	`221`	`if (packetUBXNAVSVIN->callbackData != NULL)`
`222`	`222`	`{`
`223`		`- delete[] packetUBXNAVSVIN->callbackData;`
	`223`	`+ delete packetUBXNAVSVIN->callbackData;`
`224`	`224`	`}`
`225`		`- delete[] packetUBXNAVSVIN;`
	`225`	`+ delete packetUBXNAVSVIN;`
`226`	`226`	`packetUBXNAVSVIN = NULL; // Redundant?`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`if (packetUBXNAVRELPOSNED != NULL)`
`230`	`230`	`{`
`231`	`231`	`if (packetUBXNAVRELPOSNED->callbackData != NULL)`
`232`	`232`	`{`
`233`		`- delete[] packetUBXNAVRELPOSNED->callbackData;`
	`233`	`+ delete packetUBXNAVRELPOSNED->callbackData;`
`234`	`234`	`}`
`235`		`- delete[] packetUBXNAVRELPOSNED;`
	`235`	`+ delete packetUBXNAVRELPOSNED;`
`236`	`236`	`packetUBXNAVRELPOSNED = NULL; // Redundant?`
`237`	`237`	`}`
`238`	`238`
`239`	`239`	`if (packetUBXRXMSFRBX != NULL)`
`240`	`240`	`{`
`241`	`241`	`if (packetUBXRXMSFRBX->callbackData != NULL)`
`242`	`242`	`{`
`243`		`- delete[] packetUBXRXMSFRBX->callbackData;`
	`243`	`+ delete packetUBXRXMSFRBX->callbackData;`
`244`	`244`	`}`
`245`		`- delete[] packetUBXRXMSFRBX;`
	`245`	`+ delete packetUBXRXMSFRBX;`
`246`	`246`	`packetUBXRXMSFRBX = NULL; // Redundant?`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`if (packetUBXRXMRAWX != NULL)`
`250`	`250`	`{`
`251`	`251`	`if (packetUBXRXMRAWX->callbackData != NULL)`
`252`	`252`	`{`
`253`		`- delete[] packetUBXRXMRAWX->callbackData;`
	`253`	`+ delete packetUBXRXMRAWX->callbackData;`
`254`	`254`	`}`
`255`		`- delete[] packetUBXRXMRAWX;`
	`255`	`+ delete packetUBXRXMRAWX;`
`256`	`256`	`packetUBXRXMRAWX = NULL; // Redundant?`
`257`	`257`	`}`
`258`	`258`
`259`	`259`	`if (packetUBXCFGRATE != NULL)`
`260`	`260`	`{`
`261`	`261`	`if (packetUBXCFGRATE->callbackData != NULL)`
`262`	`262`	`{`
`263`		`- delete[] packetUBXCFGRATE->callbackData;`
	`263`	`+ delete packetUBXCFGRATE->callbackData;`
`264`	`264`	`}`
`265`		`- delete[] packetUBXCFGRATE;`
	`265`	`+ delete packetUBXCFGRATE;`
`266`	`266`	`packetUBXCFGRATE = NULL; // Redundant?`
`267`	`267`	`}`
`268`	`268`
`269`	`269`	`if (packetUBXTIMTM2 != NULL)`
`270`	`270`	`{`
`271`	`271`	`if (packetUBXTIMTM2->callbackData != NULL)`
`272`	`272`	`{`
`273`		`- delete[] packetUBXTIMTM2->callbackData;`
	`273`	`+ delete packetUBXTIMTM2->callbackData;`
`274`	`274`	`}`
`275`		`- delete[] packetUBXTIMTM2;`
	`275`	`+ delete packetUBXTIMTM2;`
`276`	`276`	`packetUBXTIMTM2 = NULL; // Redundant?`
`277`	`277`	`}`
`278`	`278`
`279`	`279`	`if (packetUBXESFALG != NULL)`
`280`	`280`	`{`
`281`	`281`	`if (packetUBXESFALG->callbackData != NULL)`
`282`	`282`	`{`
`283`		`- delete[] packetUBXESFALG->callbackData;`
	`283`	`+ delete packetUBXESFALG->callbackData;`
`284`	`284`	`}`
`285`		`- delete[] packetUBXESFALG;`
	`285`	`+ delete packetUBXESFALG;`
`286`	`286`	`packetUBXESFALG = NULL; // Redundant?`
`287`	`287`	`}`
`288`	`288`
`289`	`289`	`if (packetUBXESFSTATUS != NULL)`
`290`	`290`	`{`
`291`	`291`	`if (packetUBXESFSTATUS->callbackData != NULL)`
`292`	`292`	`{`
`293`		`- delete[] packetUBXESFSTATUS->callbackData;`
	`293`	`+ delete packetUBXESFSTATUS->callbackData;`
`294`	`294`	`}`
`295`		`- delete[] packetUBXESFSTATUS;`
	`295`	`+ delete packetUBXESFSTATUS;`
`296`	`296`	`packetUBXESFSTATUS = NULL; // Redundant?`
`297`	`297`	`}`
`298`	`298`
`299`	`299`	`if (packetUBXESFINS != NULL)`
`300`	`300`	`{`
`301`	`301`	`if (packetUBXESFINS->callbackData != NULL)`
`302`	`302`	`{`
`303`		`- delete[] packetUBXESFINS->callbackData;`
	`303`	`+ delete packetUBXESFINS->callbackData;`
`304`	`304`	`}`
`305`		`- delete[] packetUBXESFINS;`
	`305`	`+ delete packetUBXESFINS;`
`306`	`306`	`packetUBXESFINS = NULL; // Redundant?`
`307`	`307`	`}`
`308`	`308`
`309`	`309`	`if (packetUBXESFMEAS != NULL)`
`310`	`310`	`{`
`311`	`311`	`if (packetUBXESFMEAS->callbackData != NULL)`
`312`	`312`	`{`
`313`		`- delete[] packetUBXESFMEAS->callbackData;`
	`313`	`+ delete packetUBXESFMEAS->callbackData;`
`314`	`314`	`}`
`315`		`- delete[] packetUBXESFMEAS;`
	`315`	`+ delete packetUBXESFMEAS;`
`316`	`316`	`packetUBXESFMEAS = NULL; // Redundant?`
`317`	`317`	`}`
`318`	`318`
`319`	`319`	`if (packetUBXESFRAW != NULL)`
`320`	`320`	`{`
`321`	`321`	`if (packetUBXESFRAW->callbackData != NULL)`
`322`	`322`	`{`
`323`		`- delete[] packetUBXESFRAW->callbackData;`
	`323`	`+ delete packetUBXESFRAW->callbackData;`
`324`	`324`	`}`
`325`		`- delete[] packetUBXESFRAW;`
	`325`	`+ delete packetUBXESFRAW;`
`326`	`326`	`packetUBXESFRAW = NULL; // Redundant?`
`327`	`327`	`}`
`328`	`328`
`329`	`329`	`if (packetUBXHNRATT != NULL)`
`330`	`330`	`{`
`331`	`331`	`if (packetUBXHNRATT->callbackData != NULL)`
`332`	`332`	`{`
`333`		`- delete[] packetUBXHNRATT->callbackData;`
	`333`	`+ delete packetUBXHNRATT->callbackData;`
`334`	`334`	`}`
`335`		`- delete[] packetUBXHNRATT;`
	`335`	`+ delete packetUBXHNRATT;`
`336`	`336`	`packetUBXHNRATT = NULL; // Redundant?`
`337`	`337`	`}`
`338`	`338`
`339`	`339`	`if (packetUBXHNRINS != NULL)`
`340`	`340`	`{`
`341`	`341`	`if (packetUBXHNRINS->callbackData != NULL)`
`342`	`342`	`{`
`343`		`- delete[] packetUBXHNRINS->callbackData;`
	`343`	`+ delete packetUBXHNRINS->callbackData;`
`344`	`344`	`}`
`345`		`- delete[] packetUBXHNRINS;`
	`345`	`+ delete packetUBXHNRINS;`
`346`	`346`	`packetUBXHNRINS = NULL; // Redundant?`
`347`	`347`	`}`
`348`	`348`
`349`	`349`	`if (packetUBXHNRPVT != NULL)`
`350`	`350`	`{`
`351`	`351`	`if (packetUBXHNRPVT->callbackData != NULL)`
`352`	`352`	`{`
`353`		`- delete[] packetUBXHNRPVT->callbackData;`
	`353`	`+ delete packetUBXHNRPVT->callbackData;`
`354`	`354`	`}`
`355`		`- delete[] packetUBXHNRPVT;`
	`355`	`+ delete packetUBXHNRPVT;`
`356`	`356`	`packetUBXHNRPVT = NULL; // Redundant?`
`357`	`357`	`}`
`358`	`358`
`@@ -365,7 +365,7 @@ void SFE_UBLOX_GNSS::setPacketCfgPayloadSize(size_t payloadSize)`
`365`	`365`	`if ((payloadSize == 0) && (payloadCfg != NULL))`
`366`	`366`	`{`
`367`	`367`	`// Zero payloadSize? Dangerous! But we'll free the memory anyway...`
`368`		`- delete[] payloadCfg;`
	`368`	`+ delete[] payloadCfg; // Created with new[]`
`369`	`369`	`payloadCfg = NULL; // Redundant?`
`370`	`370`	`packetCfg.payload = payloadCfg;`
`371`	`371`	`if ((_printDebug == true) \|\| (_printLimitedDebug == true)) // This is important. Print this if doing limited debugging`
`@@ -386,7 +386,7 @@ void SFE_UBLOX_GNSS::setPacketCfgPayloadSize(size_t payloadSize)`
`386`	`386`	`uint8_t *newPayload = new uint8_t[payloadSize];`
`387`	`387`	`for (size_t i = 0; (i < payloadSize) && (i < packetCfgPayloadSize); i++) // Copy as much existing data as we can`
`388`	`388`	`newPayload[i] = payloadCfg[i];`
`389`		`- delete[] payloadCfg;`
	`389`	`+ delete[] payloadCfg; // Created with new[]`
`390`	`390`	`payloadCfg = newPayload;`
`391`	`391`	`packetCfg.payload = payloadCfg;`
`392`	`392`	`if (payloadCfg == NULL)`
`@@ -1260,7 +1260,7 @@ void SFE_UBLOX_GNSS::process(uint8_t incoming, ubxPacket *incomingUBX, uint8_t r`
`1260`	`1260`	`{`
`1261`	`1261`	`_debugSerial->println(F("process: memory is already allocated for payloadAuto! Deleting..."));`
`1262`	`1262`	`}`
`1263`		`- delete[] payloadAuto;`
	`1263`	`+ delete[] payloadAuto; // Created with new[]`
`1264`	`1264`	`payloadAuto = NULL; // Redundant?`
`1265`	`1265`	`packetAuto.payload = payloadAuto;`
`1266`	`1266`	`}`
`@@ -1797,7 +1797,7 @@ void SFE_UBLOX_GNSS::processUBX(uint8_t incoming, ubxPacket *incomingUBX, uint8_`
`1797`	`1797`	`// allocated for packetAuto`
`1798`	`1798`	`if (activePacketBuffer == SFE_UBLOX_PACKET_PACKETAUTO)`
`1799`	`1799`	`{`
`1800`		`- delete[] payloadAuto;`
	`1800`	`+ delete[] payloadAuto; // Created with new[]`
`1801`	`1801`	`payloadAuto = NULL; // Redundant?`
`1802`	`1802`	`packetAuto.payload = payloadAuto;`
`1803`	`1803`	`}`