write(), print(), and println() now return number of bytes written.

The type is long, and negative values indicate errors.  Needs more testing.
http://code.google.com/p/arduino/issues/detail?id=551

libraries/ArduinoTestSuite/examples/ATS_Write_Print/ATS_Write_Print.ino

@@ -0,0 +1,61 @@
+#include <ArduinoTestSuite.h>
+
+void Test_Equal(long actual, long expected)
+{
+  char buf[100];
+  boolean b = expected == actual;
+  ATS_PrintTestStatus("", b);
+  if (!b) {
+    Serial.print("expected '");
+    Serial.print(expected);
+    Serial.print("', actual '");
+    Serial.print(actual);
+    Serial.println("'");
+  }
+}
+
+void setup()
+{
+  byte buf[5] = { 65, 66, 67, 0, 69 };
+  ATS_begin("Arduino", "Write & Print Return Values Test");
+
+  Test_Equal(Serial.write('a'), 1);
+  Test_Equal(Serial.write(byte(0)), 1);
+  Test_Equal(Serial.write("abc"), 3);
+  Test_Equal(Serial.write(""), 0);
+  Test_Equal(Serial.write(buf, 5), 5);
+  Test_Equal(Serial.print(0), 1);
+  Test_Equal(Serial.print(""), 0);
+  Test_Equal(Serial.print("abc"), 3);
+  Test_Equal(Serial.print(0), 1);
+  Test_Equal(Serial.print(1), 1);
+  Test_Equal(Serial.print(11), 2);
+  Test_Equal(Serial.print(12345), 5);
+  Test_Equal(Serial.print(-1), 2);
+  Test_Equal(Serial.print(-123), 4);
+  Test_Equal(Serial.println(), 2);
+  Test_Equal(Serial.println(""), 2);
+  Test_Equal(Serial.println("abc"), 5);
+  Test_Equal(Serial.println(0), 3);
+  Test_Equal(Serial.println(1), 3);
+  Test_Equal(Serial.println(11), 4);
+  Test_Equal(Serial.println(12345), 7);
+  Test_Equal(Serial.println(-1), 4);
+  Test_Equal(Serial.println(-123), 6);
+  
+  ATS_end();
+}
+
+void loop() {}
+
+
+
+
+
+
+
+
+
+
+
+

libraries/Ethernet/Client.cpp

@@ -70,19 +70,18 @@ int Client::connect(IPAddress ip, uint16_t port) {
   return 1;
 }
 
-void Client::write(uint8_t b) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, &b, 1);
+long Client::write(uint8_t b) {
+  return write(&b, 1);
 }
 
-void Client::write(const char *str) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, (const uint8_t *)str, strlen(str));
+long Client::write(const char *str) {
+  return write((const uint8_t *) str, strlen(str));
 }
 
-void Client::write(const uint8_t *buf, size_t size) {
-  if (_sock != MAX_SOCK_NUM)
-    send(_sock, buf, size);
+long Client::write(const uint8_t *buf, size_t size) {
+  if (_sock == MAX_SOCK_NUM) return -1;
+  if (!send(_sock, buf, size)) return -2;
+  return size;
 }
 
 int Client::available() {

libraries/Ethernet/Client.h

@@ -12,9 +12,9 @@ public:
   uint8_t status();
   int connect(IPAddress ip, uint16_t port);
   int connect(const char *host, uint16_t port);
-  virtual void write(uint8_t);
-  virtual void write(const char *str);
-  virtual void write(const uint8_t *buf, size_t size);
+  virtual long write(uint8_t);
+  virtual long write(const char *str);
+  virtual long write(const uint8_t *buf, size_t size);
   virtual int available();
   virtual int read();
   virtual int read(uint8_t *buf, size_t size);

libraries/Ethernet/IPAddress.cpp

@@ -42,13 +42,15 @@ bool IPAddress::operator==(const uint8_t* addr)
     return memcmp(addr, _address, sizeof(_address)) == 0;
 }
 
-void IPAddress::printTo(Print& p) const
+long IPAddress::printTo(Print& p) const
 {
+    long n = 0, t;
     for (int i =0; i < 3; i++)
     {
-        p.print(_address[i], DEC);
-        p.print('.');
+        if ((t = p.print(_address[i], DEC)) > 0) n += t;
+        if ((t = p.print('.')) > 0) n+= t;
     }
-    p.print(_address[3], DEC);
+    if ((t = p.print(_address[3], DEC)) > 0) n += t;
+    return n;
 }
 

libraries/Ethernet/IPAddress.h

@@ -60,7 +60,7 @@ public:
     IPAddress& operator=(const uint8_t *address);
     IPAddress& operator=(uint32_t address);
 
-    virtual void printTo(Print& p) const;
+    virtual long printTo(Print& p) const;
 
     friend class EthernetClass;
     friend class UDP;

libraries/Ethernet/Server.cpp

@@ -67,18 +67,20 @@ Client Server::available()
   return Client(MAX_SOCK_NUM);
 }
 
-void Server::write(uint8_t b) 
+long Server::write(uint8_t b) 
 {
   write(&b, 1);
 }
 
-void Server::write(const char *str) 
+long Server::write(const char *str) 
 {
   write((const uint8_t *)str, strlen(str));
 }
 
-void Server::write(const uint8_t *buffer, size_t size) 
+long Server::write(const uint8_t *buffer, size_t size) 
 {
+  long n = 0;
+  
   accept();
 
   for (int sock = 0; sock < MAX_SOCK_NUM; sock++) {
@@ -86,7 +88,9 @@ void Server::write(const uint8_t *buffer, size_t size)
 
     if (EthernetClass::_server_port[sock] == _port &&
       client.status() == SnSR::ESTABLISHED) {
-      client.write(buffer, size);
+      n += client.write(buffer, size);
     }
   }
+  
+  return n;
 }

libraries/Ethernet/Server.h

@@ -14,9 +14,9 @@ public:
   Server(uint16_t);
   Client available();
   void begin();
-  virtual void write(uint8_t);
-  virtual void write(const char *str);
-  virtual void write(const uint8_t *buf, size_t size);
+  virtual long write(uint8_t);
+  virtual long write(const char *str);
+  virtual long write(const uint8_t *buf, size_t size);
 };
 
 #endif

libraries/Ethernet/Udp.cpp

@@ -102,21 +102,22 @@ int UDP::endPacket()
   return sendUDP(_sock);
 }
 
-void UDP::write(uint8_t byte)
+long UDP::write(uint8_t byte)
 {
-  write(&byte, 1);
+  return write(&byte, 1);
 }
 
-void UDP::write(const char *str)
+long UDP::write(const char *str)
 {
   size_t len = strlen(str);
-  write((const uint8_t *)str, len);
+  return write((const uint8_t *)str, len);
 }
 
-void UDP::write(const uint8_t *buffer, size_t size)
+long UDP::write(const uint8_t *buffer, size_t size)
 {
   uint16_t bytes_written = bufferData(_sock, _offset, buffer, size);
   _offset += bytes_written;
+  return bytes_written;
 }
 
 int UDP::parsePacket()

libraries/Ethernet/Udp.h

@@ -67,11 +67,11 @@ public:
   // Returns 1 if the packet was sent successfully, 0 if there was an error
   int endPacket();
   // Write a single byte into the packet
-  virtual void write(uint8_t);
+  virtual long write(uint8_t);
   // Write a string of characters into the packet
-  virtual void write(const char *str);
+  virtual long write(const char *str);
   // Write size bytes from buffer into the packet
-  virtual void write(const uint8_t *buffer, size_t size);
+  virtual long write(const uint8_t *buffer, size_t size);
 
   // Start processing the next available incoming packet
   // Returns the size of the packet in bytes, or 0 if no packets are available

libraries/LiquidCrystal/LiquidCrystal.cpp

@@ -258,8 +258,9 @@ inline void LiquidCrystal::command(uint8_t value) {
   send(value, LOW);
 }
 
-inline void LiquidCrystal::write(uint8_t value) {
+inline long LiquidCrystal::write(uint8_t value) {
   send(value, HIGH);
+  return 1; // assume sucess
 }
 
 /************ low level data pushing commands **********/

libraries/LiquidCrystal/LiquidCrystal.h

@@ -79,7 +79,7 @@ public:
 
   void createChar(uint8_t, uint8_t[]);
   void setCursor(uint8_t, uint8_t); 
-  virtual void write(uint8_t);
+  virtual long write(uint8_t);
   void command(uint8_t);
 private:
   void send(uint8_t, uint8_t);

libraries/SD/File.cpp

@@ -58,19 +58,20 @@ boolean File::isDirectory(void) {
 }
 
 
-void File::write(uint8_t val) {
-  if (_file)
-    _file->write(val);
+long File::write(uint8_t val) {
+  return write(&val, 1);
 }
 
-void File::write(const char *str) {
-  if (_file) 
-    _file->write(str);
+long File::write(const char *str) {
+  return write((const uint8_t *) str, strlen(str));
 }
 
-void File::write(const uint8_t *buf, size_t size) {
-  if (_file)
-    _file->write(buf, size);
+long File::write(const uint8_t *buf, size_t size) {
+  long t;
+  if (!_file) return -1;
+  t = _file->write(buf, size);
+  if (t < 0) return t - 1;
+  return t;
 }
 
 int File::peek() {

libraries/SD/SD.h

@@ -32,9 +32,9 @@ public:
   File(SdFile f, char *name);     // wraps an underlying SdFile
   File(void);      // 'empty' constructor
   ~File(void);     // destructor
-  virtual void write(uint8_t);
-  virtual void write(const char *str);
-  virtual void write(const uint8_t *buf, size_t size);
+  virtual long write(uint8_t);
+  virtual long write(const char *str);
+  virtual long write(const uint8_t *buf, size_t size);
   virtual int read();
   virtual int peek();
   virtual int available();

libraries/SD/utility/SdFat.h

@@ -283,9 +283,9 @@ class SdFile : public Print {
   }
   /** \return SdVolume that contains this file. */
   SdVolume* volume(void) const {return vol_;}
-  void write(uint8_t b);
-  int16_t write(const void* buf, uint16_t nbyte);
-  void write(const char* str);
+  long write(uint8_t b);
+  long write(const void* buf, uint16_t nbyte);
+  long write(const char* str);
   void write_P(PGM_P str);
   void writeln_P(PGM_P str);
 //------------------------------------------------------------------------------

libraries/SD/utility/SdFile.cpp

@@ -1121,7 +1121,7 @@ uint8_t SdFile::truncate(uint32_t length) {
  * for a read-only file, device is full, a corrupt file system or an I/O error.
  *
  */
-int16_t SdFile::write(const void* buf, uint16_t nbyte) {
+long SdFile::write(const void* buf, uint16_t nbyte) {
   // convert void* to uint8_t*  -  must be before goto statements
   const uint8_t* src = reinterpret_cast<const uint8_t*>(buf);
 
@@ -1219,8 +1219,8 @@ int16_t SdFile::write(const void* buf, uint16_t nbyte) {
  *
  * Use SdFile::writeError to check for errors.
  */
-void SdFile::write(uint8_t b) {
-  write(&b, 1);
+long SdFile::write(uint8_t b) {
+  return write(&b, 1);
 }
 //------------------------------------------------------------------------------
 /**
@@ -1228,8 +1228,8 @@ void SdFile::write(uint8_t b) {
  *
  * Use SdFile::writeError to check for errors.
  */
-void SdFile::write(const char* str) {
-  write(str, strlen(str));
+long SdFile::write(const char* str) {
+  return write(str, strlen(str));
 }
 //------------------------------------------------------------------------------
 /**

libraries/SoftwareSerial/SoftwareSerial.cpp

@@ -440,10 +440,10 @@ int SoftwareSerial::available()
   return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
 }
 
-void SoftwareSerial::write(uint8_t b)
+long SoftwareSerial::write(uint8_t b)
 {
   if (_tx_delay == 0)
-    return;
+    return -1;
 
   uint8_t oldSREG = SREG;
   cli();  // turn off interrupts for a clean txmit
@@ -484,6 +484,8 @@ void SoftwareSerial::write(uint8_t b)
 
   SREG = oldSREG; // turn interrupts back on
   tunedDelay(_tx_delay);
+  
+  return 1;
 }
 
 void SoftwareSerial::flush()

libraries/SoftwareSerial/SoftwareSerial.h

@@ -89,7 +89,7 @@ public:
   bool overflow() { bool ret = _buffer_overflow; _buffer_overflow = false; return ret; }
   int peek();
 
-  virtual void write(uint8_t byte);
+  virtual long write(uint8_t byte);
   virtual int read();
   virtual int available();
   virtual void flush();

libraries/Wire/Wire.cpp

@@ -124,13 +124,13 @@ uint8_t TwoWire::endTransmission(void)
 // must be called in:
 // slave tx event callback
 // or after beginTransmission(address)
-void TwoWire::write(uint8_t data)
+long TwoWire::write(uint8_t data)
 {
   if(transmitting){
   // in master transmitter mode
     // don't bother if buffer is full
     if(txBufferLength >= BUFFER_LENGTH){
-      return;
+      return -1;
     }
     // put byte in tx buffer
     txBuffer[txBufferIndex] = data;
@@ -142,31 +142,33 @@ void TwoWire::write(uint8_t data)
     // reply to master
     twi_transmit(&data, 1);
   }
+  return 1;
 }
 
 // must be called in:
 // slave tx event callback
 // or after beginTransmission(address)
-void TwoWire::write(const uint8_t *data, size_t quantity)
+long TwoWire::write(const uint8_t *data, size_t quantity)
 {
   if(transmitting){
   // in master transmitter mode
     for(size_t i = 0; i < quantity; ++i){
-      write(data[i]);
+      if (write(data[i]) < 0) return i;
     }
   }else{
   // in slave send mode
     // reply to master
     twi_transmit(data, quantity);
   }
+  return quantity;
 }
 
 // must be called in:
 // slave tx event callback
 // or after beginTransmission(address)
-void TwoWire::write(const char *data)
+long TwoWire::write(const char *data)
 {
-  write((uint8_t*)data, strlen(data));
+  return write((uint8_t*)data, strlen(data));
 }
 
 // must be called in:

libraries/Wire/Wire.h

@@ -52,9 +52,9 @@ class TwoWire : public Stream
     uint8_t endTransmission(void);
     uint8_t requestFrom(uint8_t, uint8_t);
     uint8_t requestFrom(int, int);
-    virtual void write(uint8_t);
-    virtual void write(const char *);
-    virtual void write(const uint8_t *, size_t);
+    virtual long write(uint8_t);
+    virtual long write(const char *);
+    virtual long write(const uint8_t *, size_t);
     virtual int available(void);
     virtual int read(void);
     virtual int peek(void);