Merge branch 'ide-1.5.x-warnings' of github.com:matthijskooijman/Arduino into ide-1.5.x

cmaglie · cmaglie · commit b673b72cfbed · 2014-04-20T19:36:29.000+02:00
diff --git a/hardware/arduino/avr/cores/arduino/Arduino.h b/hardware/arduino/avr/cores/arduino/Arduino.h
@@ -21,6 +21,7 @@
 #define Arduino_h
 
 #include <stdlib.h>
+#include <stdbool.h>
 #include <string.h>
 #include <math.h>
 
@@ -43,9 +44,6 @@ void yield(void);
 #define OUTPUT 0x1
 #define INPUT_PULLUP 0x2
 
-#define true 0x1
-#define false 0x0
-
 #define PI 3.1415926535897932384626433832795
 #define HALF_PI 1.5707963267948966192313216916398
 #define TWO_PI 6.283185307179586476925286766559
diff --git a/hardware/arduino/avr/cores/arduino/IPAddress.cpp b/hardware/arduino/avr/cores/arduino/IPAddress.cpp
@@ -22,53 +22,53 @@
 
 IPAddress::IPAddress()
 {
-    memset(_address, 0, sizeof(_address));
+    _address.dword = 0;
 }
 
 IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
 {
-    _address[0] = first_octet;
-    _address[1] = second_octet;
-    _address[2] = third_octet;
-    _address[3] = fourth_octet;
+    _address.bytes[0] = first_octet;
+    _address.bytes[1] = second_octet;
+    _address.bytes[2] = third_octet;
+    _address.bytes[3] = fourth_octet;
 }
 
 IPAddress::IPAddress(uint32_t address)
 {
-    memcpy(_address, &address, sizeof(_address));
+    _address.dword = address;
 }
 
 IPAddress::IPAddress(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
 }
 
 IPAddress& IPAddress::operator=(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
     return *this;
 }
 
 IPAddress& IPAddress::operator=(uint32_t address)
 {
-    memcpy(_address, (const uint8_t *)&address, sizeof(_address));
+    _address.dword = address;
     return *this;
 }
 
 bool IPAddress::operator==(const uint8_t* addr) const
 {
-    return memcmp(addr, _address, sizeof(_address)) == 0;
+    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
 }
 
 size_t IPAddress::printTo(Print& p) const
 {
     size_t n = 0;
     for (int i =0; i < 3; i++)
     {
-        n += p.print(_address[i], DEC);
+        n += p.print(_address.bytes[i], DEC);
         n += p.print('.');
     }
-    n += p.print(_address[3], DEC);
+    n += p.print(_address.bytes[3], DEC);
     return n;
 }
 
diff --git a/hardware/arduino/avr/cores/arduino/IPAddress.h b/hardware/arduino/avr/cores/arduino/IPAddress.h
@@ -27,12 +27,16 @@
 
 class IPAddress : public Printable {
 private:
-    uint8_t _address[4];  // IPv4 address
+    union {
+	uint8_t bytes[4];  // IPv4 address
+	uint32_t dword;
+    } _address;
+
     // Access the raw byte array containing the address.  Because this returns a pointer
     // to the internal structure rather than a copy of the address this function should only
     // be used when you know that the usage of the returned uint8_t* will be transient and not
     // stored.
-    uint8_t* raw_address() { return _address; };
+    uint8_t* raw_address() { return _address.bytes; };
 
 public:
     // Constructors
@@ -43,13 +47,13 @@ class IPAddress : public Printable {
 
     // Overloaded cast operator to allow IPAddress objects to be used where a pointer
     // to a four-byte uint8_t array is expected
-    operator uint32_t() const { return *((uint32_t*)_address); };
-    bool operator==(const IPAddress& addr) const { return (*((uint32_t*)_address)) == (*((uint32_t*)addr._address)); };
+    operator uint32_t() const { return _address.dword; };
+    bool operator==(const IPAddress& addr) const { return _address.dword == addr._address.dword; };
     bool operator==(const uint8_t* addr) const;
 
     // Overloaded index operator to allow getting and setting individual octets of the address
-    uint8_t operator[](int index) const { return _address[index]; };
-    uint8_t& operator[](int index) { return _address[index]; };
+    uint8_t operator[](int index) const { return _address.bytes[index]; };
+    uint8_t& operator[](int index) { return _address.bytes[index]; };
 
     // Overloaded copy operators to allow initialisation of IPAddress objects from other types
     IPAddress& operator=(const uint8_t *address);
diff --git a/hardware/arduino/avr/cores/arduino/Stream.cpp b/hardware/arduino/avr/cores/arduino/Stream.cpp
@@ -176,7 +176,7 @@ float Stream::parseFloat(char skipChar){
   boolean isNegative = false;
   boolean isFraction = false;
   long value = 0;
-  char c;
+  int c;
   float fraction = 1.0;
 
   c = peekNextDigit();
diff --git a/hardware/arduino/sam/cores/arduino/IPAddress.cpp b/hardware/arduino/sam/cores/arduino/IPAddress.cpp
@@ -22,53 +22,53 @@
 
 IPAddress::IPAddress()
 {
-    memset(_address, 0, sizeof(_address));
+    _address.dword = 0;
 }
 
 IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)
 {
-    _address[0] = first_octet;
-    _address[1] = second_octet;
-    _address[2] = third_octet;
-    _address[3] = fourth_octet;
+    _address.bytes[0] = first_octet;
+    _address.bytes[1] = second_octet;
+    _address.bytes[2] = third_octet;
+    _address.bytes[3] = fourth_octet;
 }
 
 IPAddress::IPAddress(uint32_t address)
 {
-    memcpy(_address, &address, sizeof(_address));
+    _address.dword = address;
 }
 
 IPAddress::IPAddress(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
 }
 
 IPAddress& IPAddress::operator=(const uint8_t *address)
 {
-    memcpy(_address, address, sizeof(_address));
+    memcpy(_address.bytes, address, sizeof(_address.bytes));
     return *this;
 }
 
 IPAddress& IPAddress::operator=(uint32_t address)
 {
-    memcpy(_address, (const uint8_t *)&address, sizeof(_address));
+    _address.dword = address;
     return *this;
 }
 
 bool IPAddress::operator==(const uint8_t* addr) const
 {
-    return memcmp(addr, _address, sizeof(_address)) == 0;
+    return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;
 }
 
 size_t IPAddress::printTo(Print& p) const
 {
     size_t n = 0;
     for (int i =0; i < 3; i++)
     {
-        n += p.print(_address[i], DEC);
+        n += p.print(_address.bytes[i], DEC);
         n += p.print('.');
     }
-    n += p.print(_address[3], DEC);
+    n += p.print(_address.bytes[3], DEC);
     return n;
 }
 
diff --git a/hardware/arduino/sam/cores/arduino/IPAddress.h b/hardware/arduino/sam/cores/arduino/IPAddress.h
@@ -20,18 +20,23 @@
 #ifndef IPAddress_h
 #define IPAddress_h
 
+#include <stdint.h>
 #include <Printable.h>
 
 // A class to make it easier to handle and pass around IP addresses
 
 class IPAddress : public Printable {
 private:
-    uint8_t _address[4];  // IPv4 address
+    union {
+	uint8_t bytes[4];  // IPv4 address
+	uint32_t dword;
+    } _address;
+
     // Access the raw byte array containing the address.  Because this returns a pointer
     // to the internal structure rather than a copy of the address this function should only
     // be used when you know that the usage of the returned uint8_t* will be transient and not
     // stored.
-    uint8_t* raw_address() { return _address; };
+    uint8_t* raw_address() { return _address.bytes; };
 
 public:
     // Constructors
@@ -42,13 +47,13 @@ class IPAddress : public Printable {
 
     // Overloaded cast operator to allow IPAddress objects to be used where a pointer
     // to a four-byte uint8_t array is expected
-    operator uint32_t() const { return *((uint32_t*)_address); };
-    bool operator==(const IPAddress& addr) const { return (*((uint32_t*)_address)) == (*((uint32_t*)addr._address)); };
+    operator uint32_t() const { return _address.dword; };
+    bool operator==(const IPAddress& addr) const { return _address.dword == addr._address.dword; };
     bool operator==(const uint8_t* addr) const;
 
     // Overloaded index operator to allow getting and setting individual octets of the address
-    uint8_t operator[](int index) const { return _address[index]; };
-    uint8_t& operator[](int index) { return _address[index]; };
+    uint8_t operator[](int index) const { return _address.bytes[index]; };
+    uint8_t& operator[](int index) { return _address.bytes[index]; };
 
     // Overloaded copy operators to allow initialisation of IPAddress objects from other types
     IPAddress& operator=(const uint8_t *address);
diff --git a/hardware/arduino/sam/cores/arduino/Stream.cpp b/hardware/arduino/sam/cores/arduino/Stream.cpp
@@ -176,7 +176,7 @@ float Stream::parseFloat(char skipChar){
   boolean isNegative = false;
   boolean isFraction = false;
   long value = 0;
-  char c;
+  int c;
   float fraction = 1.0;
 
   c = peekNextDigit();
diff --git a/hardware/arduino/sam/cores/arduino/USB/CDC.cpp b/hardware/arduino/sam/cores/arduino/USB/CDC.cpp
@@ -147,10 +147,15 @@ bool WEAK CDC_Setup(Setup& setup)
 int _serialPeek = -1;
 void Serial_::begin(uint32_t baud_count)
 {
+	// suppress "unused parameter" warning
+	(void)baud_count;
 }
 
 void Serial_::begin(uint32_t baud_count, uint8_t config)
 {
+	// suppress "unused parameter" warning
+	(void)baud_count;
+	(void)config;
 }
 
 void Serial_::end(void)
diff --git a/hardware/arduino/sam/cores/arduino/USB/USBCore.cpp b/hardware/arduino/sam/cores/arduino/USB/USBCore.cpp
@@ -139,7 +139,7 @@ uint32_t USBD_Available(uint32_t ep)
 //	Return number of bytes read
 uint32_t USBD_Recv(uint32_t ep, void* d, uint32_t len)
 {
-	if (!_usbConfiguration || len < 0)
+	if (!_usbConfiguration)
 		return -1;
 
 	LockEP lock(ep);
diff --git a/hardware/arduino/sam/cores/arduino/avr/dtostrf.c b/hardware/arduino/sam/cores/arduino/avr/dtostrf.c
@@ -18,6 +18,8 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
+#include <stdio.h>
+
 char *dtostrf (double val, signed char width, unsigned char prec, char *sout) {
   char fmt[20];
   sprintf(fmt, "%%%d.%df", width, prec);
diff --git a/hardware/arduino/sam/cores/arduino/syscalls_sam3.c b/hardware/arduino/sam/cores/arduino/syscalls_sam3.c
@@ -38,6 +38,14 @@
   #include <sys/stat.h>
 #endif
 
+// Helper macro to mark unused parameters and prevent compiler warnings.
+// Appends _UNUSED to the variable name to prevent accidentally using them.
+#ifdef __GNUC__
+#  define UNUSED(x) x ## _UNUSED __attribute__((__unused__))
+#else
+#  define UNUSED(x) x ## _UNUSED
+#endif
+
 /*----------------------------------------------------------------------------
  *        Exported variables
  *----------------------------------------------------------------------------*/
@@ -69,39 +77,39 @@ extern caddr_t _sbrk ( int incr )
     return (caddr_t) prev_heap ;
 }
 
-extern int link( char *cOld, char *cNew )
+extern int link( UNUSED(char *cOld), UNUSED(char *cNew) )
 {
     return -1 ;
 }
 
-extern int _close( int file )
+extern int _close( UNUSED(int file) )
 {
     return -1 ;
 }
 
-extern int _fstat( int file, struct stat *st )
+extern int _fstat( UNUSED(int file), struct stat *st )
 {
     st->st_mode = S_IFCHR ;
 
     return 0 ;
 }
 
-extern int _isatty( int file )
+extern int _isatty( UNUSED(int file) )
 {
     return 1 ;
 }
 
-extern int _lseek( int file, int ptr, int dir )
+extern int _lseek( UNUSED(int file), UNUSED(int ptr), UNUSED(int dir) )
 {
     return 0 ;
 }
 
-extern int _read(int file, char *ptr, int len)
+extern int _read(UNUSED(int file), UNUSED(char *ptr), UNUSED(int len) )
 {
     return 0 ;
 }
 
-extern int _write( int file, char *ptr, int len )
+extern int _write( UNUSED(int file), char *ptr, int len )
 {
     int iIndex ;
 
@@ -129,7 +137,7 @@ extern void _exit( int status )
     for ( ; ; ) ;
 }
 
-extern void _kill( int pid, int sig )
+extern void _kill( UNUSED(int pid), UNUSED(int sig) )
 {
     return ;
 }
diff --git a/hardware/arduino/sam/cores/arduino/wiring_analog.c b/hardware/arduino/sam/cores/arduino/wiring_analog.c
@@ -150,7 +150,7 @@ uint32_t analogRead(uint32_t ulPin)
 			// Enable the corresponding channel
 			if (ulChannel != latestSelectedChannel) {
 				adc_enable_channel( ADC, ulChannel );
-				if ( latestSelectedChannel != -1 )
+				if ( latestSelectedChannel != (uint32_t)-1 )
 					adc_disable_channel( ADC, latestSelectedChannel );
 				latestSelectedChannel = ulChannel;
 			}
@@ -293,7 +293,7 @@ void analogWrite(uint32_t ulPin, uint32_t ulValue) {
 		ETCChannel channel = g_APinDescription[ulPin].ulTCChannel;
 		static const uint32_t channelToChNo[] = { 0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2, 0, 0, 1, 1, 2, 2 };
 		static const uint32_t channelToAB[]   = { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 };
-		static const Tc *channelToTC[] = {
+		static Tc *channelToTC[] = {
 			TC0, TC0, TC0, TC0, TC0, TC0,
 			TC1, TC1, TC1, TC1, TC1, TC1,
 			TC2, TC2, TC2, TC2, TC2, TC2 };
diff --git a/hardware/arduino/sam/variants/arduino_due_x/variant.cpp b/hardware/arduino/sam/variants/arduino_due_x/variant.cpp
@@ -380,7 +380,7 @@ void init( void )
   __libc_init_array();
 
   // Disable pull-up on every pin
-  for (int i = 0; i < PINS_COUNT; i++)
+  for (unsigned i = 0; i < PINS_COUNT; i++)
 	  digitalWrite(i, LOW);
 
   // Enable parallel access on PIO output data registers
diff --git a/libraries/Ethernet/src/Ethernet.cpp b/libraries/Ethernet/src/Ethernet.cpp
@@ -62,9 +62,9 @@ void EthernetClass::begin(uint8_t *mac, IPAddress local_ip, IPAddress dns_server
 {
   W5100.init();
   W5100.setMACAddress(mac);
-  W5100.setIPAddress(local_ip._address);
-  W5100.setGatewayIp(gateway._address);
-  W5100.setSubnetMask(subnet._address);
+  W5100.setIPAddress(local_ip.raw_address());
+  W5100.setGatewayIp(gateway.raw_address());
+  W5100.setSubnetMask(subnet.raw_address());
   _dnsServerAddress = dns_server;
 }
 
diff --git a/libraries/SD/src/SD.cpp b/libraries/SD/src/SD.cpp
diff --git a/libraries/SD/src/utility/Sd2Card.cpp b/libraries/SD/src/utility/Sd2Card.cpp

Original file line number	Diff line number	Diff line change
`@@ -22,53 +22,53 @@`
`22`	`22`
`23`	`23`	`IPAddress::IPAddress()`
`24`	`24`	`{`
`25`		`- memset(_address, 0, sizeof(_address));`
	`25`	`+ _address.dword = 0;`
`26`	`26`	`}`
`27`	`27`
`28`	`28`	`IPAddress::IPAddress(uint8_t first_octet, uint8_t second_octet, uint8_t third_octet, uint8_t fourth_octet)`
`29`	`29`	`{`
`30`		`- _address[0] = first_octet;`
`31`		`- _address[1] = second_octet;`
`32`		`- _address[2] = third_octet;`
`33`		`- _address[3] = fourth_octet;`
	`30`	`+ _address.bytes[0] = first_octet;`
	`31`	`+ _address.bytes[1] = second_octet;`
	`32`	`+ _address.bytes[2] = third_octet;`
	`33`	`+ _address.bytes[3] = fourth_octet;`
`34`	`34`	`}`
`35`	`35`
`36`	`36`	`IPAddress::IPAddress(uint32_t address)`
`37`	`37`	`{`
`38`		`- memcpy(_address, &address, sizeof(_address));`
	`38`	`+ _address.dword = address;`
`39`	`39`	`}`
`40`	`40`
`41`	`41`	`IPAddress::IPAddress(const uint8_t *address)`
`42`	`42`	`{`
`43`		`- memcpy(_address, address, sizeof(_address));`
	`43`	`+ memcpy(_address.bytes, address, sizeof(_address.bytes));`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`IPAddress& IPAddress::operator=(const uint8_t *address)`
`47`	`47`	`{`
`48`		`- memcpy(_address, address, sizeof(_address));`
	`48`	`+ memcpy(_address.bytes, address, sizeof(_address.bytes));`
`49`	`49`	`return *this;`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`IPAddress& IPAddress::operator=(uint32_t address)`
`53`	`53`	`{`
`54`		`- memcpy(_address, (const uint8_t *)&address, sizeof(_address));`
	`54`	`+ _address.dword = address;`
`55`	`55`	`return *this;`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`bool IPAddress::operator==(const uint8_t* addr) const`
`59`	`59`	`{`
`60`		`- return memcmp(addr, _address, sizeof(_address)) == 0;`
	`60`	`+ return memcmp(addr, _address.bytes, sizeof(_address.bytes)) == 0;`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`size_t IPAddress::printTo(Print& p) const`
`64`	`64`	`{`
`65`	`65`	`size_t n = 0;`
`66`	`66`	`for (int i =0; i < 3; i++)`
`67`	`67`	`{`
`68`		`- n += p.print(_address[i], DEC);`
	`68`	`+ n += p.print(_address.bytes[i], DEC);`
`69`	`69`	`n += p.print('.');`
`70`	`70`	`}`
`71`		`- n += p.print(_address[3], DEC);`
	`71`	`+ n += p.print(_address.bytes[3], DEC);`
`72`	`72`	`return n;`
`73`	`73`	`}`
`74`	`74`
Original file line number	Diff line number	Diff line change
`@@ -147,10 +147,15 @@ bool WEAK CDC_Setup(Setup& setup)`
`147`	`147`	`int _serialPeek = -1;`
`148`	`148`	`void Serial_::begin(uint32_t baud_count)`
`149`	`149`	`{`
	`150`	`+ // suppress "unused parameter" warning`
	`151`	`+ (void)baud_count;`
`150`	`152`	`}`
`151`	`153`
`152`	`154`	`void Serial_::begin(uint32_t baud_count, uint8_t config)`
`153`	`155`	`{`
	`156`	`+ // suppress "unused parameter" warning`
	`157`	`+ (void)baud_count;`
	`158`	`+ (void)config;`
`154`	`159`	`}`
`155`	`160`
`156`	`161`	`void Serial_::end(void)`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ uint32_t USBD_Available(uint32_t ep)`
`139`	`139`	`// Return number of bytes read`
`140`	`140`	`uint32_t USBD_Recv(uint32_t ep, void* d, uint32_t len)`
`141`	`141`	`{`
`142`		`- if (!_usbConfiguration \|\| len < 0)`
	`142`	`+ if (!_usbConfiguration)`
`143`	`143`	`return -1;`
`144`	`144`
`145`	`145`	`LockEP lock(ep);`