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:
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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;
|
||||
|
@ -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();
|
||||
|
||||
|
@ -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
|
||||
|
@ -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;
|
||||
|
@ -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
|
||||
|
@ -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
|
||||
}
|
||||
|
@ -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);
|
||||
|
@ -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;
|
||||
}
|
||||
|
||||
|
@ -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();
|
||||
|
@ -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);
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -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));
|
||||
}
|
||||
//------------------------------------------------------------------------------
|
||||
|
@ -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
|
||||
|
@ -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();
|
||||
|
@ -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));
|
||||
}
|
||||
|
@ -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);
|
||||
|
Reference in New Issue
Block a user