arduino_ci 0.2.0 → 1.1.0

data/cpp/arduino/IPAddress.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stdint.h>
+
+class IPAddress {
+private:
+  union {
+    uint8_t bytes[4];
+    uint32_t dword;
+    operator uint8_t *() const { return (uint8_t *)bytes; }
+  } _address;
+
+public:
+  // Constructors
+  IPAddress() : IPAddress(0, 0, 0, 0) {}
+  IPAddress(uint8_t octet1, uint8_t octet2, uint8_t octet3, uint8_t octet4) {
+    _address.bytes[0] = octet1;
+    _address.bytes[1] = octet2;
+    _address.bytes[2] = octet3;
+    _address.bytes[3] = octet4;
+  }
+  IPAddress(uint32_t dword) { _address.dword = dword; }
+  IPAddress(const uint8_t bytes[]) {
+    _address.bytes[0] = bytes[0];
+    _address.bytes[1] = bytes[1];
+    _address.bytes[2] = bytes[2];
+    _address.bytes[3] = bytes[3];
+  }
+  IPAddress(unsigned long dword) { _address.dword = (uint32_t)dword; }
+
+  // Accessors
+  uint32_t asWord() const { return _address.dword; }
+  uint8_t *raw_address() { return _address.bytes; }
+
+  // Comparisons
+  bool operator==(const IPAddress &rhs) const {
+    return _address.dword == rhs.asWord();
+  }
+
+  bool operator!=(const IPAddress &rhs) const {
+    return _address.dword != rhs.asWord();
+  }
+
+  // Indexing
+  uint8_t operator[](int index) const { return _address.bytes[index]; }
+  uint8_t &operator[](int index) { return _address.bytes[index]; }
+
+  // Conversions
+  operator uint32_t() const { return _address.dword; };
+
+  friend class EthernetClass;
+  friend class UDP;
+  friend class Client;
+  friend class Server;
+  friend class DhcpClass;
+  friend class DNSClient;
+};
+
+const IPAddress INADDR_NONE(0, 0, 0, 0);

data/cpp/arduino/Print.h

@@ -2,6 +2,8 @@
 
 #include <stdio.h>
 #include <avr/pgmspace.h>
+
+#include "Printable.h"
 #include "WString.h"
 
 #define DEC 10
@@ -12,22 +14,17 @@
 #endif
 #define BIN 2
 
-class Print;
-
-class Printable
-{
-  public:
-    virtual size_t printTo(Print& p) const = 0;
-};
-
 class Print
 {
+  private:
+    int write_error;
+  protected:
+    void setWriteError(int err = 1) { write_error = err; }
   public:
-    Print() {}
+    Print() : write_error(0) {}
 
-    // Arduino's version of this is richer but until I see an actual error case I'm not sure how to mock
-    int getWriteError() { return 0; }
-    void clearWriteError() { }
+    int getWriteError() { return write_error; }
+    void clearWriteError() { setWriteError(0); }
     virtual int availableForWrite() { return 0; }
 
     virtual size_t write(uint8_t) = 0;

data/cpp/arduino/Printable.h

@@ -0,0 +1,8 @@
+#pragma once
+
+class Print;
+
+class Printable {
+public:
+  virtual size_t printTo(Print &p) const = 0;
+};

data/cpp/arduino/SPI.h

@@ -40,7 +40,11 @@
 
 class SPISettings {
 public:
-  SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode){};
+  uint8_t bitOrder;
+
+  SPISettings(uint32_t clock, uint8_t bitOrder = MSBFIRST, uint8_t dataMode = SPI_MODE0) {
+    this->bitOrder = bitOrder;
+  };
   SPISettings(){};
 };
 
@@ -68,6 +72,7 @@ public:
   // and configure the correct settings.
   void beginTransaction(SPISettings settings)
   {
+    this->bitOrder = settings.bitOrder;
     #ifdef SPI_TRANSACTION_MISMATCH_LED
     if (inTransactionFlag) {
       pinMode(SPI_TRANSACTION_MISMATCH_LED, OUTPUT);
@@ -94,10 +99,12 @@ public:
   uint16_t transfer16(uint16_t data) {
     union { uint16_t val; struct { uint8_t lsb; uint8_t msb; }; } in, out;
     in.val = data;
-    if (!(SPCR & (1 << DORD))) {
+    if (bitOrder == MSBFIRST) {
       out.msb = transfer(in.msb);
       out.lsb =  transfer(in.lsb);
-    } else {
+    }
+    else
+    {
       out.lsb =  transfer(in.lsb);
       out.msb = transfer(in.msb);
     }
@@ -143,6 +150,7 @@ private:
   #endif
 
   bool isStarted = false;
+  uint8_t bitOrder;
   String* dataIn;
   String* dataOut;
 };

data/cpp/arduino/Server.h

@@ -0,0 +1,5 @@
+#pragma once
+
+#include <Stream.h>
+
+class Server : public Print {};

data/cpp/arduino/Udp.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <IPAddress.h>
+#include <Stream.h>
+
+class UDP : public Stream {
+protected:
+  uint8_t *rawIPAddress(IPAddress &addr) { return addr.raw_address(); };
+
+public:
+  UDP() {
+    // The Stream mock defines a String buffer but never puts anyting in it!
+    if (!mGodmodeDataIn) {
+      mGodmodeDataIn = new String;
+    }
+  }
+  ~UDP() {
+    if (mGodmodeDataIn) {
+      delete mGodmodeDataIn;
+      mGodmodeDataIn = nullptr;
+    }
+  }
+  virtual size_t write(uint8_t value) {
+    mGodmodeDataIn->concat(value);
+    return 1;
+  }
+};

data/cpp/arduino/Wire.h

@@ -0,0 +1,234 @@
+/*
+ * The Wire Library (https://www.arduino.cc/en/Reference/Wire)
+ * allows you to communicate with I2C/TWI devices. The general
+ * TWI protocol supports one "master" device and many "slave"
+ * devices that share the same two wires (SDA and SCL for data
+ * and clock respectively).
+ *
+ * You initialize the library by calling begin() as a master or
+ * begin(myAddress) as a slave (with an int from 8-127). In the
+ * initial mock implementation we support only the master role.
+ *
+ * To send bytes from a master to a slave, start with
+ * beginTransmission(slaveAddress), then use write(byte) to
+ * enqueue data, and finish with endTransmission().
+ *
+ * When a master wants to read, it starts with a call to
+ * requestFrom(slaveAddress, quantity) which blocks until the
+ * request finishes. The return value is either 0 (if the slave
+ * does not respond) or the number of bytes requested (which
+ * might be more than the number sent since reading is simply
+ * looking at a pin value at each clock tick).
+ *
+ * A master can write to or read from two or more slaves in
+ * quick succession (say, during one loop() function), so our
+ * mock needs to support preloading data to be read from multiple
+ * slaves and archive data sent to multiple slaves.
+ *
+ * In the mock, this is handled by having an array of wireData_t
+ * structures, each of which contains a deque for input and a
+ * deque for output. You can preload data to be read and you can
+ * look at a log of data that has been written.
+ */
+
+#pragma once
+
+#include <inttypes.h>
+#include "Stream.h"
+#include <cassert>
+#include <deque>
+using std::deque;
+
+const size_t SLAVE_COUNT = 128;
+const size_t BUFFER_LENGTH = 32;
+
+struct wireData_t {
+  uint8_t misoSize;          // bytes remaining for this read
+  uint8_t mosiSize;          // bytes included in this write
+  deque<uint8_t> misoBuffer; // master in, slave out
+  deque<uint8_t> mosiBuffer; // master out, slave in
+};
+
+// Some inspiration taken from
+// https://github.com/arduino/ArduinoCore-megaavr/blob/d2a81093ba66d22dbda14c30d146c231c5910734/libraries/Wire/src/Wire.cpp
+class TwoWire : public ObservableDataStream {
+private:
+  bool _didBegin = false;
+  wireData_t *in = nullptr;  // pointer to current slave for writing
+  wireData_t *out = nullptr; // pointer to current slave for reading
+  wireData_t slaves[SLAVE_COUNT];
+
+public:
+  // constructor initializes internal data
+  TwoWire() {
+    for (int i = 0; i < SLAVE_COUNT; ++i) {
+      slaves[i].misoSize = 0;
+      slaves[i].mosiSize = 0;
+    }
+  }
+
+  // https://www.arduino.cc/en/Reference/WireBegin
+  // Initiate the Wire library and join the I2C bus as a master or slave. This
+  // should normally be called only once.
+  void begin() { begin(0); }
+  void begin(uint8_t address) {
+    assert(address == 0);
+    _didBegin = true;
+  }
+  void begin(int address) { begin((uint8_t)address); }
+  // NOTE: end() is not part of the published API so we ignore it
+  void end() {}
+
+  // https://www.arduino.cc/en/Reference/WireSetClock
+  // This function modifies the clock frequency for I2C communication. I2C slave
+  // devices have no minimum working clock frequency, however 100KHz is usually
+  // the baseline.
+  // Since the mock does not actually write pins we ignore this.
+  void setClock(uint32_t clock) {}
+
+  // https://www.arduino.cc/en/Reference/WireBeginTransmission
+  // Begin a transmission to the I2C slave device with the given address.
+  // Subsequently, queue bytes for transmission with the write() function and
+  // transmit them by calling endTransmission().
+  // For the mock we update our output to the proper destination.
+  void beginTransmission(uint8_t address) {
+    assert(_didBegin);
+    assert(address > 0 && address < SLAVE_COUNT);
+    assert(out == nullptr);
+    out = &slaves[address];
+    out->mosiSize = 0;
+  }
+  void beginTransmission(int address) { beginTransmission((uint8_t)address); }
+
+  // https://www.arduino.cc/en/Reference/WireEndTransmission
+  // Ends a transmission to a slave device that was begun by beginTransmission()
+  // and transmits the bytes that were queued by write().
+  // In the mock we just leave the bytes there in the buffer
+  // to be read by the testing API and we ignore the sendStop.
+  uint8_t endTransmission(bool sendStop) {
+    assert(_didBegin);
+    assert(out);
+    out = nullptr;
+    return 0; // success
+  }
+  uint8_t endTransmission(void) { return endTransmission(true); }
+
+  // https://www.arduino.cc/en/Reference/WireRequestFrom
+  // Used by the master to request bytes from a slave device. The bytes may then
+  // be retrieved with the available() and read() functions.
+  uint8_t requestFrom(uint8_t address, uint8_t quantity, uint32_t _iaddress, uint8_t _isize, uint8_t stop) {
+    assert(_didBegin);
+    assert(address > 0 && address < SLAVE_COUNT);
+    assert(quantity <= BUFFER_LENGTH);
+    in = &slaves[address];
+    // do we have enough data in the input buffer
+    if (quantity <= (in->misoBuffer).size()) { // enough data
+      in->misoSize = quantity;
+      return quantity;
+    } else { // not enough data
+      in->misoSize = 0;
+      in = nullptr;
+      return 0;
+    }
+  }
+
+  uint8_t requestFrom(uint8_t address, uint8_t quantity, uint8_t stop) {
+    return requestFrom((uint8_t)address, (uint8_t)quantity, (uint32_t)0, (uint8_t)0, (uint8_t)stop);
+  }
+
+  uint8_t requestFrom(uint8_t address, uint8_t quantity) {
+    return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true);
+  }
+
+  uint8_t requestFrom(int address, int quantity) {
+    return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)true);
+  }
+  uint8_t requestFrom(int address, int quantity, int stop) {
+    return requestFrom((uint8_t)address, (uint8_t)quantity, (uint8_t)stop);
+  }
+
+  // https://www.arduino.cc/en/Reference/WireWrite
+  // Writes data from a slave device in response to a request from a master, or
+  // queues bytes for transmission from a master to slave device (in-between
+  // calls to beginTransmission() and endTransmission()).
+  size_t write(uint8_t value) {
+    assert(out);
+    assert(++(out->mosiSize) <= BUFFER_LENGTH);
+    (out->mosiBuffer).push_back(value);
+    return 1; // number of bytes written
+  }
+  size_t write(const char *str) {
+    return str == NULL ? 0 : write((const uint8_t *)str, String(str).length());
+  }
+  size_t write(const uint8_t *buffer, size_t size) {
+    size_t n;
+    for (n = 0; size && write(*buffer++) && ++n; --size)
+      ;
+    return n;
+  }
+  size_t write(const char *buffer, size_t size) {
+    return write((const uint8_t *)buffer, size);
+  }
+  size_t write(unsigned long n) { return write((uint8_t)n); }
+  size_t write(long n) { return write((uint8_t)n); }
+  size_t write(unsigned int n) { return write((uint8_t)n); }
+  size_t write(int n) { return write((uint8_t)n); }
+
+  // https://www.arduino.cc/en/Reference/WireAvailable
+  // Returns the number of bytes available for retrieval with read(). This
+  // should be called on a master device after a call to requestFrom() or on a
+  // slave inside the onReceive() handler.
+  int available(void) {
+    assert(in);
+    return in->misoSize;
+  }
+
+  // https://www.arduino.cc/en/Reference/WireRead
+  // Reads a byte that was transmitted from a slave device to a master after a
+  // call to requestFrom() or was transmitted from a master to a slave. read()
+  // inherits from the Stream utility class.
+  // In the mock we simply return the next byte from the input buffer.
+  uint8_t read(void) {
+    uint8_t value = peek();
+    --in->misoSize;
+    in->misoBuffer.pop_front();
+    return value; // The next byte received
+  }
+
+  // part of the Stream API
+  uint8_t peek(void) {
+    assert(in);
+    assert(0 < in->misoSize);
+    return in->misoBuffer.front(); // The next byte received
+  }
+
+  // part of the Stream API
+  void flush(void) {
+    // NOTE: commented out in the megaavr repository
+    // data already at the (mock) destination
+  }
+
+  // https://www.arduino.cc/en/Reference/WireOnReceive
+  // Registers a function to be called when a slave device receives a
+  // transmission from a master.
+  // We don't (yet) support the slave role in the mock
+  void onReceive(void (*callback)(int)) { assert(false); }
+
+  // https://www.arduino.cc/en/Reference/WireOnRequest
+  // Register a function to be called when a master requests data from this
+  // slave device.
+  // We don't (yet) support the slave role in the mock
+  void onRequest(void (*callback)(void)) { assert(false); }
+
+  // testing methods
+  bool didBegin() { return _didBegin; }
+
+  deque<uint8_t> *getMiso(uint8_t address) {
+    return &slaves[address].misoBuffer;
+  }
+  deque<uint8_t> *getMosi(uint8_t address) {
+    return &slaves[address].mosiBuffer;
+  }
+};
+
+extern TwoWire Wire;

data/cpp/arduino/avr/io.h

@@ -96,7 +96,16 @@
 #ifndef _AVR_IO_H_
 #define _AVR_IO_H_
 
-#define _SFR_IO8(io_addr) (io_addr) // this macro is all we need from the sfr file
+#include <stdint.h>
+
+// hardware mocks
+// this set of macros is all we need from the sfr file
+extern volatile uint8_t __ARDUINO_CI_SFR_MOCK[1024];
+#define _SFR_IO8(io_addr) (*(volatile uint8_t *)(__ARDUINO_CI_SFR_MOCK + io_addr))
+#define _SFR_IO16(io_addr) (*(volatile uint16_t *)(__ARDUINO_CI_SFR_MOCK + io_addr))
+#define _SFR_MEM8(io_addr) (*(volatile uint8_t *)(__ARDUINO_CI_SFR_MOCK + io_addr))
+#define _SFR_MEM16(io_addr) (*(volatile uint16_t *)(__ARDUINO_CI_SFR_MOCK + io_addr))
+#define _SFR_MEM32(io_addr) (*(volatile uint32_t *)(__ARDUINO_CI_SFR_MOCK + io_addr))
 
 #if defined (__AVR_AT94K__)
 #  include "ioat94k.h"

data/cpp/arduino/avr/pgmspace.h

@@ -14,8 +14,10 @@ out = externs.map {|l| l.split("(")[0].split(" ")[-1].gsub("*", "") }.uniq
 out.each { |l| puts d(l) }
 */
 
-#include <avr/io.h>
 #include <string.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdarg.h>
 
 #define PROGMEM
 
@@ -27,6 +29,11 @@ out.each { |l| puts d(l) }
 #define PGM_VOID_P const void *
 #endif
 
+// These are normally 32-bit, but here use (u)intptr_t to ensure a pointer can
+// always be safely cast to these types.
+typedef intptr_t int_farptr_t;
+typedef uintptr_t uint_farptr_t;
+
 // everything's a no-op
 #define PSTR(s) ((const char *)(s))
 
@@ -34,13 +41,13 @@ out.each { |l| puts d(l) }
 #define pgm_read_word_near(address_short)  (* (const uint16_t *) (address_short) )
 #define pgm_read_dword_near(address_short) (* (const uint32_t *) (address_short) )
 #define pgm_read_float_near(address_short) (* (const float *)    (address_short) )
-#define pgm_read_ptr_near(address_short)   (* (const void *)     (address_short) )
+#define pgm_read_ptr_near(address_short)   (* (const void **)    (address_short) )
 
 #define pgm_read_byte_far(address_long)    (* (const uint8_t *)  (address_long) )
 #define pgm_read_word_far(address_long)    (* (const uint16_t *) (address_long) )
 #define pgm_read_dword_far(address_long)   (* (const uint32_t *) (address_long) )
 #define pgm_read_float_far(address_long)   (* (const float *)    (address_long) )
-#define pgm_read_ptr_far(address_long)     (* (const void *)     (address_long) )
+#define pgm_read_ptr_far(address_long)     (* (const void **)    (address_long) )
 
 #define pgm_read_byte(address_short)   pgm_read_byte_near(address_short)
 #define pgm_read_word(address_short)   pgm_read_word_near(address_short)
@@ -50,46 +57,69 @@ out.each { |l| puts d(l) }
 
 #define pgm_get_far_address(var) ( (uint_farptr_t) (&(var)) )
 
-#define memchr_P(...) ::memchr(__VA_ARGS__)
-#define memcmp_P(...) ::memcmp(__VA_ARGS__)
-#define memccpy_P(...) ::memccpy(__VA_ARGS__)
-#define memcpy_P(...) ::memcpy(__VA_ARGS__)
-#define memmem_P(...) ::memmem(__VA_ARGS__)
-#define memrchr_P(...) ::memrchr(__VA_ARGS__)
-#define strcat_P(...) ::strcat(__VA_ARGS__)
-#define strchr_P(...) ::strchr(__VA_ARGS__)
-#define strchrnul_P(...) ::strchrnul(__VA_ARGS__)
-#define strcmp_P(...) ::strcmp(__VA_ARGS__)
-#define strcpy_P(...) ::strcpy(__VA_ARGS__)
-#define strcasecmp_P(...) ::strcasecmp(__VA_ARGS__)
-#define strcasestr_P(...) ::strcasestr(__VA_ARGS__)
-#define strcspn_P(...) ::strcspn(__VA_ARGS__)
-#define strlcat_P(...) ::strlcat(__VA_ARGS__)
-#define strlcpy_P(...) ::strlcpy(__VA_ARGS__)
-#define strnlen_P(...) ::strnlen(__VA_ARGS__)
-#define strncmp_P(...) ::strncmp(__VA_ARGS__)
-#define strncasecmp_P(...) ::strncasecmp(__VA_ARGS__)
-#define strncat_P(...) ::strncat(__VA_ARGS__)
-#define strncpy_P(...) ::strncpy(__VA_ARGS__)
-#define strpbrk_P(...) ::strpbrk(__VA_ARGS__)
-#define strrchr_P(...) ::strrchr(__VA_ARGS__)
-#define strsep_P(...) ::strsep(__VA_ARGS__)
-#define strspn_P(...) ::strspn(__VA_ARGS__)
-#define strstr_P(...) ::strstr(__VA_ARGS__)
-#define strtok_P(...) ::strtok(__VA_ARGS__)
-#define strtok_P(...) ::strtok(__VA_ARGS__)
-#define strlen_P(...) ::strlen(__VA_ARGS__)
-#define strnlen_P(...) ::strnlen(__VA_ARGS__)
-#define memcpy_P(...) ::memcpy(__VA_ARGS__)
-#define strcpy_P(...) ::strcpy(__VA_ARGS__)
-#define strncpy_P(...) ::strncpy(__VA_ARGS__)
-#define strcat_P(...) ::strcat(__VA_ARGS__)
-#define strlcat_P(...) ::strlcat(__VA_ARGS__)
-#define strncat_P(...) ::strncat(__VA_ARGS__)
-#define strcmp_P(...) ::strcmp(__VA_ARGS__)
-#define strncmp_P(...) ::strncmp(__VA_ARGS__)
-#define strcasecmp_P(...) ::strcasecmp(__VA_ARGS__)
-#define strncasecmp_P(...) ::strncasecmp(__VA_ARGS__)
-#define strstr_P(...) ::strstr(__VA_ARGS__)
-#define strlcpy_P(...) ::strlcpy(__VA_ARGS__)
-#define memcmp_P(...) ::memcmp(__VA_ARGS__)
+inline const void * memchr_P(const void *s, int val, size_t len) { return memchr(s, val, len); }
+inline int memcmp_P(const void *s1, const void *s2, size_t len) { return memcmp(s1, s2, len); }
+inline void *memcpy_P(void *dest, const void *src, size_t n) { return memcpy(dest, src, n); }
+inline char *strcat_P(char *dest, const char *src) { return strcat(dest, src); }
+inline const char *strchr_P(const char *s, int val) { return strchr(s, val); }
+inline int strcmp_P(const char *s1, const char *s2) { return strcmp(s1, s2); }
+inline char *strcpy_P(char *dest, const char *src) { return strcpy(dest, src); }
+inline size_t strcspn_P(const char *s, const char *reject) { return strcspn(s, reject); }
+// strlcat and strlcpy are AVR-specific and not entirely trivial to reimplement using strncat it seems
+//inline size_t strlcat_P(char *dst, const char *src, size_t siz) { return strlcat(dst, src, siz); }
+//inline size_t strlcpy_P(char *dst, const char *src, size_t siz) { return strlcpy(dst, src, siz); }
+//inline size_t strlcat_PF(char *dst, uint_farptr_t src, size_t n) { return strlcat(dst, (const char*)src, n); }
+//inline size_t strlcpy_PF(char *dst, uint_farptr_t src, size_t siz) { return strlcpy(dst, (const char*)src, siz); }
+inline int strncmp_P(const char *s1, const char *s2, size_t n) { return strncmp(s1, s2, n); }
+inline char *strncat_P(char *dest, const char *src, size_t len) { return strncat(dest, src, len); }
+inline char *strncpy_P(char *dest, const char *src, size_t n) { return strncpy(dest, src, n); }
+inline char *strpbrk_P(const char *s, const char *accept) { return (char*)strpbrk(s, accept); }
+inline const char *strrchr_P(const char *s, int val) { return strrchr(s, val); }
+inline size_t strspn_P(const char *s, const char *accept) { return strspn(s, accept); }
+inline char *strstr_P(const char *s1, const char *s2) { return (char*)strstr(s1, s2); }
+inline char *strtok_P(char *s, const char * delim) { return strtok(s, delim); }
+inline size_t strlen_PF(uint_farptr_t s) { return strlen((char*)s); }
+inline void *memcpy_PF(void *dest, uint_farptr_t src, size_t n) { return memcpy(dest, (const char*)src, n); }
+inline char *strcpy_PF(char *dst, uint_farptr_t src) { return strcpy(dst, (const char*)src); }
+inline char *strncpy_PF(char *dst, uint_farptr_t src, size_t n) { return strncpy(dst, (const char*)src, n); }
+inline char *strcat_PF(char *dst, uint_farptr_t src) { return strcat(dst, (const char*)src); }
+inline char *strncat_PF(char *dst, uint_farptr_t src, size_t n) { return strncat(dst, (const char*)src, n); }
+inline int strcmp_PF(const char *s1, uint_farptr_t s2) { return strcmp(s1, (const char*)s2); }
+inline int strncmp_PF(const char *s1, uint_farptr_t s2, size_t n) { return strncmp(s1, (const char*)s2, n); }
+inline char *strstr_PF(const char *s1, uint_farptr_t s2) { return (char*)strstr(s1, (const char*)s2); }
+inline int memcmp_PF(const void *s1, uint_farptr_t s2, size_t len) { return memcmp(s1, (const char*)s2, len); }
+inline size_t strlen_P(const char *src) { return strlen(src); }
+
+// TODO: These functions cannot be found on the CYGWIN test build for
+// some reason, so disable them for now. Most of these are less common
+// and/or GNU-specific addons anyway
+//inline void *memccpy_P(void *dest, const void *src, int val, size_t len) { return memccpy(dest, src, val, len); }
+//inline void *memmem_P(const void *s1, size_t len1, const void *s2, size_t len2) { return memmem(s1, len1, s2, len2); }
+//inline const void *memrchr_P(const void *src, int val, size_t len) { return memrchr(src, val, len); }
+//inline const char *strchrnul_P(const char *s, int c) { return strchrnul(s, c); }
+//inline int strcasecmp_P(const char *s1, const char *s2) { return strcasecmp(s1, s2); }
+//inline char *strcasestr_P(const char *s1, const char *s2) { return (char*)strcasestr(s1, s2); }
+//inline int strncasecmp_P(const char *s1, const char *s2, size_t n) { return strncasecmp(s1, s2, n); }
+//inline char *strsep_P(char **sp, const char *delim) { return strsep(sp, delim); }
+//inline char *strtok_r_P(char *string, const char *delim, char **last) { return strtok_r(string, delim, last); }
+//inline int strcasecmp_PF(const char *s1, uint_farptr_t s2) { return strcasecmp(s1, (const char*)s2); }
+//inline int strncasecmp_PF(const char *s1, uint_farptr_t s2, size_t n) { return strncasecmp(s1, (const char*)s2, n); }
+//inline size_t strnlen_P(uint_farptr_t s, size_t len) { return strnlen((char*)s, len); }
+
+// These are normally defined by stdio.h on AVR, but we cannot override that
+// include file (at least not without no longer being able to include the
+// original as well), so just define these here. It seems likely that any
+// sketch that uses these progmem-stdio functions will also include pgmspace.h
+inline int  vfprintf_P(FILE *stream, const char *__fmt, va_list __ap) { return vfprintf(stream, __fmt, __ap); }
+inline int  printf_P(const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vprintf(__fmt, args); va_end(args); }
+inline int  sprintf_P(char *s, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return sprintf(s, __fmt, args); va_end(args); }
+inline int  snprintf_P(char *s, size_t __n, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vsnprintf(s, __n, __fmt, args); va_end(args); }
+inline int  vsprintf_P(char *s, const char *__fmt, va_list ap) { return vsprintf(s, __fmt, ap); }
+inline int  vsnprintf_P(char *s, size_t __n, const char *__fmt, va_list ap) { return vsnprintf(s, __n, __fmt, ap); }
+inline int  fprintf_P(FILE *stream, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vfprintf(stream, __fmt, args); va_end(args); }
+inline int  fputs_P(const char *str, FILE *__stream) { return fputs(str, __stream); }
+inline int  puts_P(const char *str) { return puts(str); }
+inline int  vfscanf_P(FILE *stream, const char *__fmt, va_list __ap) { return vfscanf(stream, __fmt, __ap); }
+inline int  fscanf_P(FILE *stream, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vfscanf(stream, __fmt, args); va_end(args); }
+inline int  scanf_P(const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vscanf(__fmt, args); va_end(args); }
+inline int  sscanf_P(const char *buf, const char *__fmt, ...) { va_list args; va_start(args, __fmt); return vsscanf(buf, __fmt, args); va_end(args); }