Use modern C++ casts instead of current C-style casting approaches

api/HardwareSPI.h

@@ -55,9 +55,9 @@ class SPISettings {
 
   SPISettings(uint32_t clock, BitOrder bitOrder, int dataMode, SPIBusMode busMode = SPI_CONTROLLER) {
     if (__builtin_constant_p(clock)) {
-      init_AlwaysInline(clock, bitOrder, (SPIMode)dataMode, busMode);
+      init_AlwaysInline(clock, bitOrder, static_cast<SPIMode>(dataMode), busMode);
     } else {
-      init_MightInline(clock, bitOrder, (SPIMode)dataMode, busMode);
+      init_MightInline(clock, bitOrder, static_cast<SPIMode>(dataMode), busMode);
     }
   }
 

api/Interrupts.h

@@ -47,15 +47,19 @@ template<typename T> void attachInterrupt(pin_size_t interruptNum, voidTemplateF
   // TODO: add structure to delete(__container__) when detachInterrupt() is called
   auto f = [](void* a) -> void
   {
-    T param = *(T*)((struct __container__<T>*)a)->param;
-    (((struct __container__<T>*)a)->function)(param);
+    T param = *(static_cast<T*>((static_cast<struct __container__<T>*>(a))->param));
+    //T param = *(T*) ((struct __container__<T>*)a)->param;
+    (static_cast<struct __container__<T>*>)(a)->function(param);
+
+    //(((struct __container__<T>*)a)->function)(param);
   };
 
   attachInterruptParam(interruptNum, f, mode, cont);
 }
 
 template<typename T> void attachInterrupt(pin_size_t interruptNum, voidTemplateFuncPtrParam<T*> userFunc, PinStatus mode, T* param) {
-  attachInterruptParam(interruptNum, (voidFuncPtrParam)userFunc, mode, (void*)param);
+  //attachInterruptParam(interruptNum, (voidFuncPtrParam)userFunc, mode, (void*)param);
+  attachInterruptParam(interruptNum, static_cast<voidFuncPtrParam>(userFunc), mode, static_cast<void*>(param))
 }
 
 }

api/PluggableUSB.cpp

@@ -87,7 +87,9 @@ bool PluggableUSB_::plug(PluggableUSBModule *node)
 	node->pluggedEndpoint = lastEp;
 	lastIf += node->numInterfaces;
 	for (uint8_t i = 0; i < node->numEndpoints; i++) {
-		*(unsigned int*)(epBuffer(lastEp)) = node->endpointType[i];
+		*(static_cast<unsigned int*>(epBuffer(lastEp))) = node->endpointType[i];
+
+		//*(unsigned int*)(epBuffer(lastEp)) = node->endpointType[i];
 		lastEp++;
 	}
 	return true;

api/Print.cpp

@@ -73,17 +73,17 @@ size_t Print::print(char c)
 
 size_t Print::print(unsigned char b, int base)
 {
-  return print((unsigned long) b, base);
+  return print(static_cast<unsigned long>(b), base);
 }
 
 size_t Print::print(int n, int base)
 {
-  return print((long) n, base);
+  return print(static_cast<long>(n), base);
 }
 
 size_t Print::print(unsigned int n, int base)
 {
-  return print((unsigned long) n, base);
+  return print(static_cast<unsigned long>(n), base);
 }
 
 size_t Print::print(long n, int base)
@@ -366,8 +366,8 @@ size_t Print::printFloat(double number, int digits)
   number += rounding;
 
   // Extract the integer part of the number and print it
-  unsigned long int_part = (unsigned long)number;
-  double remainder = number - (double)int_part;
+  unsigned long int_part = static_cast<unsigned long>(number);
+  double remainder = number - static_cast<double>(int_part);
   n += print(int_part);
 
   // Print the decimal point, but only if there are digits beyond
@@ -379,7 +379,7 @@ size_t Print::printFloat(double number, int digits)
   while (digits-- > 0)
   {
     remainder *= 10.0;
-    unsigned int toPrint = (unsigned int)remainder;
+    unsigned int toPrint = static_cast<unsigned int>(remainder);
     n += print(toPrint);
     remainder -= toPrint;
   }

api/Print.h

@@ -50,11 +50,11 @@ class Print
     virtual size_t write(uint8_t) = 0;
     size_t write(const char *str) {
       if (str == NULL) return 0;
-      return write((const uint8_t *)str, strlen(str));
+      return write(reinterpret_cast<const uint8_t *>(str), strlen(str));
     }
     virtual size_t write(const uint8_t *buffer, size_t size);
     size_t write(const char *buffer, size_t size) {
-      return write((const uint8_t *)buffer, size);
+      return write(reinterpret_cast<const uint8_t *>(buffer), size);
     }
 
     // default to zero, meaning "a single write may block"

api/RingBuffer.h

@@ -127,7 +127,7 @@ int RingBufferN<N>::peek()
 template <int N>
 int RingBufferN<N>::nextIndex(int index)
 {
-  return (uint32_t)(index + 1) % N;
+  return static_cast<uint32_t>(index + 1) % N;
 }
 
 template <int N>

api/Stream.h

@@ -69,20 +69,20 @@ class Stream : public Print
   unsigned long getTimeout(void) { return _timeout; }
 
   bool find(const char *target);   // reads data from the stream until the target string is found
-  bool find(const uint8_t *target) { return find ((const char *)target); }
+  bool find(const uint8_t *target) { return find (reinterpret_cast<const char *>(target)); }
   // returns true if target string is found, false if timed out (see setTimeout)
 
   bool find(const char *target, size_t length);   // reads data from the stream until the target string of given length is found
-  bool find(const uint8_t *target, size_t length) { return find ((const char *)target, length); }
+  bool find(const uint8_t *target, size_t length) { return find (reinterpret_cast<const char *>(target), length); }
   // returns true if target string is found, false if timed out
 
   bool find(char target) { return find (&target, 1); }
 
   bool findUntil(const char *target, const char *terminator);   // as find but search ends if the terminator string is found
-  bool findUntil(const uint8_t *target, const char *terminator) { return findUntil((const char *)target, terminator); }
+  bool findUntil(const uint8_t *target, const char *terminator) { return findUntil(reinterpret_cast<const char *>(target), terminator); }
 
   bool findUntil(const char *target, size_t targetLen, const char *terminate, size_t termLen);   // as above but search ends if the terminate string is found
-  bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen) {return findUntil((const char *)target, targetLen, terminate, termLen); }
+  bool findUntil(const uint8_t *target, size_t targetLen, const char *terminate, size_t termLen) {return findUntil(reinterpret_cast<const char *>(target), targetLen, terminate, termLen); }
 
   long parseInt(LookaheadMode lookahead = SKIP_ALL, char ignore = NO_IGNORE_CHAR);
   // returns the first valid (long) integer value from the current position.
@@ -95,12 +95,12 @@ class Stream : public Print
   // float version of parseInt
 
   size_t readBytes( char *buffer, size_t length); // read chars from stream into buffer
-  size_t readBytes( uint8_t *buffer, size_t length) { return readBytes((char *)buffer, length); }
+  size_t readBytes( uint8_t *buffer, size_t length) { return readBytes(reinterpret_cast<char *>(buffer), length); }
   // terminates if length characters have been read or timeout (see setTimeout)
   // returns the number of characters placed in the buffer (0 means no valid data found)
 
   size_t readBytesUntil( char terminator, char *buffer, size_t length); // as readBytes with terminator character
-  size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
+  size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, reinterpret_cast<char *>(buffer), length); }
   // terminates if length characters have been read, timeout, or if the terminator character  detected
   // returns the number of characters placed in the buffer (0 means no valid data found)
 

api/String.cpp

@@ -175,7 +175,7 @@ bool String::reserve(unsigned int size)
 
 bool String::changeBuffer(unsigned int maxStrLen)
 {
-	char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
+	char *newbuffer = static_cast<char *>(realloc(buffer, maxStrLen + 1));
 	if (newbuffer) {
 		buffer = newbuffer;
 		capacity = maxStrLen;
@@ -207,7 +207,7 @@ String & String::copy(const __FlashStringHelper *pstr, unsigned int length)
 		return *this;
 	}
 	len = length;
-	strcpy_P(buffer, (PGM_P)pstr);
+	strcpy_P(buffer, reinterpret_cast<PGM_P>(pstr));
 	return *this;
 }
 
@@ -253,7 +253,7 @@ String & String::operator = (const char *cstr)
 
 String & String::operator = (const __FlashStringHelper *pstr)
 {
-	if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
+	if (pstr) copy(pstr, strlen_P(reinterpret_cast<PGM_P>(pstr)));
 	else invalidate();
 
 	return *this;
@@ -343,11 +343,11 @@ bool String::concat(double num)
 bool String::concat(const __FlashStringHelper * str)
 {
 	if (!str) return false;
-	int length = strlen_P((const char *) str);
+	int length = strlen_P(reinterpret_cast<const char*>(str));
 	if (length == 0) return true;
 	unsigned int newlen = len + length;
 	if (!reserve(newlen)) return false;
-	strcpy_P(buffer + len, (const char *) str);
+	strcpy_P(buffer + len, reinterpret_cast<const char*>(str));
 	len = newlen;
 	return true;
 }
@@ -440,8 +440,8 @@ StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHel
 int String::compareTo(const String &s) const
 {
 	if (!buffer || !s.buffer) {
-		if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer;
-		if (buffer && len > 0) return *(unsigned char *)buffer;
+		if (s.buffer && s.len > 0) return 0 - *(reinterpret_cast<unsigned char *>(s.buffer));
+		if (buffer && len > 0) return *(reinterpret_cast<unsigned char *>(buffer));
 		return 0;
 	}
 	return strcmp(buffer, s.buffer);
@@ -450,8 +450,8 @@ int String::compareTo(const String &s) const
 int String::compareTo(const char *cstr) const
 {
 	if (!buffer || !cstr) {
-		if (cstr && *cstr) return 0 - *(unsigned char *)cstr;
-		if (buffer && len > 0) return *(unsigned char *)buffer;
+		if (cstr && *cstr) return 0 - *(const_cast<unsigned char *>(reinterpret_cast<const unsigned char*>(cstr)));
+		if (buffer && len > 0) return *(reinterpret_cast<unsigned char *>(buffer));
 		return 0;
 	}
 	return strcmp(buffer, cstr);
@@ -539,7 +539,7 @@ void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int ind
 	}
 	unsigned int n = bufsize - 1;
 	if (n > len - index) n = len - index;
-	strncpy((char *)buf, buffer + index, n);
+	strncpy(reinterpret_cast<char *>(buf), buffer + index, n);
 	buf[n] = 0;
 }
 
@@ -602,7 +602,7 @@ int String::lastIndexOf(const String &s2, unsigned int fromIndex) const
 	for (char *p = buffer; p <= buffer + fromIndex; p++) {
 		p = strstr(p, s2.buffer);
 		if (!p) break;
-		if ((unsigned int)(p - buffer) <= fromIndex) found = p - buffer;
+		if (static_cast<unsigned int>(p - buffer) <= fromIndex) found = p - buffer;
 	}
 	return found;
 }
@@ -685,7 +685,7 @@ void String::remove(unsigned int index){
 	// Pass the biggest integer as the count. The remove method
 	// below will take care of truncating it at the end of the
 	// string.
-	remove(index, (unsigned int)-1);
+	remove(index, static_cast<unsigned int>(-1));
 }
 
 void String::remove(unsigned int index, unsigned int count){