1
0
mirror of https://github.com/esp8266/Arduino.git synced 2025-07-30 16:24:09 +03:00

Moving write errors out of return value into separate API methods.

write(), print(), println() now return size_t (and don't use negative values to signal errors).
Print adds writeError() for checking for write errors, clearWriteError() to reset the flag to false, and a protected setWriteError() for signalling errors.

http://code.google.com/p/arduino/issues/detail?id=598
This commit is contained in:
David A. Mellis
2011-08-26 16:08:14 -04:00
parent 929597375b
commit b73cf39d94
23 changed files with 184 additions and 173 deletions

View File

@ -70,17 +70,23 @@ int Client::connect(IPAddress ip, uint16_t port) {
return 1;
}
ssize_t Client::write(uint8_t b) {
size_t Client::write(uint8_t b) {
return write(&b, 1);
}
ssize_t Client::write(const char *str) {
size_t Client::write(const char *str) {
return write((const uint8_t *) str, strlen(str));
}
ssize_t Client::write(const uint8_t *buf, size_t size) {
if (_sock == MAX_SOCK_NUM) return -1;
if (!send(_sock, buf, size)) return -2;
size_t Client::write(const uint8_t *buf, size_t size) {
if (_sock == MAX_SOCK_NUM) {
setWriteError();
return 0;
}
if (!send(_sock, buf, size)) {
setWriteError();
return 0;
}
return size;
}

View File

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

View File

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

View File

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

View File

@ -67,19 +67,19 @@ Client Server::available()
return Client(MAX_SOCK_NUM);
}
ssize_t Server::write(uint8_t b)
size_t Server::write(uint8_t b)
{
write(&b, 1);
}
ssize_t Server::write(const char *str)
size_t Server::write(const char *str)
{
write((const uint8_t *)str, strlen(str));
}
ssize_t Server::write(const uint8_t *buffer, size_t size)
size_t Server::write(const uint8_t *buffer, size_t size)
{
ssize_t n = 0;
size_t n = 0;
accept();

View File

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

View File

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

View File

@ -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 ssize_t write(uint8_t);
virtual size_t write(uint8_t);
// Write a string of characters into the packet
virtual ssize_t write(const char *str);
virtual size_t write(const char *str);
// Write size bytes from buffer into the packet
virtual ssize_t write(const uint8_t *buffer, size_t size);
virtual size_t 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

View File

@ -258,7 +258,7 @@ inline void LiquidCrystal::command(uint8_t value) {
send(value, LOW);
}
inline ssize_t LiquidCrystal::write(uint8_t value) {
inline size_t LiquidCrystal::write(uint8_t value) {
send(value, HIGH);
return 1; // assume sucess
}

View File

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

View File

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

View File

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

View File

@ -141,7 +141,7 @@ class SdFile : public Print {
* Set writeError to false before calling print() and/or write() and check
* for true after calls to print() and/or write().
*/
bool writeError;
//bool writeError;
/**
* Cancel unbuffered reads for this file.
* See setUnbufferedRead()
@ -283,9 +283,9 @@ class SdFile : public Print {
}
/** \return SdVolume that contains this file. */
SdVolume* volume(void) const {return vol_;}
ssize_t write(uint8_t b);
ssize_t write(const void* buf, uint16_t nbyte);
ssize_t write(const char* str);
size_t write(uint8_t b);
size_t write(const void* buf, uint16_t nbyte);
size_t write(const char* str);
void write_P(PGM_P str);
void writeln_P(PGM_P str);
//------------------------------------------------------------------------------

View File

@ -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.
*
*/
ssize_t SdFile::write(const void* buf, uint16_t nbyte) {
size_t 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);
@ -1210,8 +1210,9 @@ ssize_t SdFile::write(const void* buf, uint16_t nbyte) {
writeErrorReturn:
// return for write error
writeError = true;
return -1;
//writeError = true;
setWriteError();
return 0;
}
//------------------------------------------------------------------------------
/**
@ -1219,7 +1220,7 @@ ssize_t SdFile::write(const void* buf, uint16_t nbyte) {
*
* Use SdFile::writeError to check for errors.
*/
ssize_t SdFile::write(uint8_t b) {
size_t SdFile::write(uint8_t b) {
return write(&b, 1);
}
//------------------------------------------------------------------------------
@ -1228,7 +1229,7 @@ ssize_t SdFile::write(uint8_t b) {
*
* Use SdFile::writeError to check for errors.
*/
ssize_t SdFile::write(const char* str) {
size_t SdFile::write(const char* str) {
return write(str, strlen(str));
}
//------------------------------------------------------------------------------

View File

@ -440,10 +440,12 @@ int SoftwareSerial::available()
return (_receive_buffer_tail + _SS_MAX_RX_BUFF - _receive_buffer_head) % _SS_MAX_RX_BUFF;
}
ssize_t SoftwareSerial::write(uint8_t b)
size_t SoftwareSerial::write(uint8_t b)
{
if (_tx_delay == 0)
return -1;
if (_tx_delay == 0) {
setWriteError();
return 0;
}
uint8_t oldSREG = SREG;
cli(); // turn off interrupts for a clean txmit

View File

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

View File

@ -124,13 +124,14 @@ uint8_t TwoWire::endTransmission(void)
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
ssize_t TwoWire::write(uint8_t data)
size_t TwoWire::write(uint8_t data)
{
if(transmitting){
// in master transmitter mode
// don't bother if buffer is full
if(txBufferLength >= BUFFER_LENGTH){
return -1;
setWriteError();
return 0;
}
// put byte in tx buffer
txBuffer[txBufferIndex] = data;
@ -148,12 +149,12 @@ ssize_t TwoWire::write(uint8_t data)
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
ssize_t TwoWire::write(const uint8_t *data, size_t quantity)
size_t TwoWire::write(const uint8_t *data, size_t quantity)
{
if(transmitting){
// in master transmitter mode
for(size_t i = 0; i < quantity; ++i){
if (write(data[i]) < 0) return i;
write(data[i]);
}
}else{
// in slave send mode
@ -166,7 +167,7 @@ ssize_t TwoWire::write(const uint8_t *data, size_t quantity)
// must be called in:
// slave tx event callback
// or after beginTransmission(address)
ssize_t TwoWire::write(const char *data)
size_t TwoWire::write(const char *data)
{
return write((uint8_t*)data, strlen(data));
}

View File

@ -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 ssize_t write(uint8_t);
virtual ssize_t write(const char *);
virtual ssize_t write(const uint8_t *, size_t);
virtual size_t write(uint8_t);
virtual size_t write(const char *);
virtual size_t write(const uint8_t *, size_t);
virtual int available(void);
virtual int read(void);
virtual int peek(void);