arduino_ci 0.1.5 → 0.1.6

data/cpp/arduino/WString.h.orig

@@ -0,0 +1,172 @@
+#pragma once
+
+#include <stdlib.h>
+#include <string>
+#include <algorithm>
+#include <iostream>
+#include "AvrMath.h"
+#include "WCharacter.h"
+
+typedef std::string string;
+
+typedef char __FlashStringHelper;
+<<<<<<< Updated upstream
+
+#define F(string_literal) (string_literal)
+=======
+//class __FlashStringHelper;
+#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
+>>>>>>> Stashed changes
+
+// Compatibility with string class
+class String: public string
+{
+  public:
+
+    // allow "string s; if (s) {}"
+    // http://www.artima.com/cppsource/safebool.html
+    typedef void (String::*TTDNSCstring)() const;
+    void ttdnsc() const {}
+    operator TTDNSCstring() const  { return &String::ttdnsc; }
+
+  private:
+    static const char* digit(int val) {
+      static const char* bank = "0123456789ABCDEF";
+      return bank + val;
+    }
+
+    static string mytoa(unsigned long val, int base) {
+      int n = val % base;
+      string place = string(digit(n), 1);
+      if (val < base) return place;
+      return mytoa(val / base, base) + place;
+    }
+
+    static string mytoas(long val, int base) {
+      string ret = mytoa(abs(val), base);
+      return 0 <= val ? ret : string("-") + ret;
+    }
+
+    static string dtoas(double val, int decimalPlaces) {
+      double r = 0.5 * pow(0.1, decimalPlaces); // make sure that integer truncation will properly round
+      if (::isnan(val)) return "nan";
+      if (::isinf(val)) return "inf";
+      val += val > 0 ? r : -r;
+      if (val > 4294967040.0) return "ovf";
+      if (val <-4294967040.0) return "ovf";
+      return mytoas(val, 10) + "." + mytoa(abs(val - (long)val) * pow(10, decimalPlaces), 10);
+    }
+
+public:
+  ~String(void) {}
+  String(const char *cstr = ""): string(cstr) {}
+  String(const string &str): string(str) {}
+  String(const String &str): string(str) {}
+  explicit String(char c): string(1, c) {}
+
+  explicit String(unsigned char val, unsigned char base=10): string(mytoa(val, base)) {}
+  explicit String(int val,           unsigned char base=10): string(mytoas(val, base)) {}
+  explicit String(unsigned int val , unsigned char base=10): string(mytoa(val, base)) {}
+  explicit String(long val,          unsigned char base=10): string(mytoas(val, base)) {}
+  explicit String(unsigned long val, unsigned char base=10): string(mytoa(val, base)) {}
+
+  explicit String(float val,  unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
+  explicit String(double val, unsigned char decimalPlaces=2): string(dtoas(val, decimalPlaces)) {}
+
+  String & operator = (const String &rhs) { assign(rhs); return *this; }
+  String & operator = (const string &rhs) { assign(rhs); return *this; }
+  String & operator = (const char *cstr)  { assign(cstr); return *this; }
+  String & operator = (const char c)      { assign(1, c); return *this; }
+
+  unsigned char concat(const String &str) { append(str); return 1; }
+  unsigned char concat(const char *cstr)  { append(cstr); return 1; }
+  unsigned char concat(char c)            { append(1, c); return 1; }
+  unsigned char concat(unsigned char c)   { append(1, c); return 1; }
+  unsigned char concat(int num)           { append(String(num)); return 1; }
+  unsigned char concat(unsigned int num)  { append(String(num)); return 1; }
+  unsigned char concat(long num)          { append(String(num)); return 1; }
+  unsigned char concat(unsigned long num) { append(String(num)); return 1; }
+  unsigned char concat(float num)         { append(String(num)); return 1; }
+  unsigned char concat(double num)        { append(String(num)); return 1; }
+
+  String & operator += (const String &rhs) { concat(rhs);  return *this; }
+  String & operator += (const char *cstr)  { concat(cstr); return *this; }
+  String & operator += (char c)            { concat(c);    return *this; }
+  String & operator += (unsigned char num) { concat(num);  return *this; }
+  String & operator += (int num)           { concat(num);  return *this; }
+  String & operator += (unsigned int num)  { concat(num);  return *this; }
+  String & operator += (long num)          { concat(num);  return *this; }
+  String & operator += (unsigned long num) { concat(num);  return *this; }
+  String & operator += (float num)         { concat(num);  return *this; }
+  String & operator += (double num)        { concat(num);  return *this; }
+
+
+  int compareTo(const String &s) const { return compare(s); }
+  unsigned char equals(const String &s) const { return compareTo(s) == 0; }
+	unsigned char equals(const char *cstr) const { return compareTo(String(cstr)) == 0; }
+  unsigned char equal(const String &s) const { return equals(s); }
+	unsigned char equal(const char *cstr) const { return equals(cstr); }
+  unsigned char equalsIgnoreCase(const String &s) const {
+    String a = String(*this);
+    String b = String(s);
+    a.toUpperCase();
+    b.toUpperCase();
+    return a.compare(b) == 0;
+  }
+
+  unsigned char startsWith(const String &prefix) const { return find(prefix) == 0; }
+  unsigned char startsWith(const String &prefix, unsigned int offset) const { return find(prefix, offset) == offset; }
+  unsigned char endsWith(const String &suffix) const { return rfind(suffix) == length() - suffix.length(); }
+
+  char charAt(unsigned int index) const {	return operator[](index); }
+  void setCharAt(unsigned int index, char c) { (*this)[index] = c; }
+
+  void getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index=0) const { copy((char*)buf, bufsize, index); }
+  void toCharArray(char *buf, unsigned int bufsize, unsigned int index=0) const
+    { getBytes((unsigned char *)buf, bufsize, index); }
+
+  int indexOf( char ch ) const                                   { return find(ch); }
+  int indexOf( char ch, unsigned int fromIndex ) const           { return find(ch, fromIndex); }
+  int indexOf( const String &str ) const                         { return find(str); }
+  int indexOf( const String &str, unsigned int fromIndex ) const { return find(str, fromIndex); }
+  int lastIndexOf( char ch ) const                                   { return rfind(ch); }
+  int lastIndexOf( char ch, unsigned int fromIndex ) const           { return rfind(ch, fromIndex); }
+  int lastIndexOf( const String &str ) const                         { return rfind(str); }
+  int lastIndexOf( const String &str, unsigned int fromIndex ) const { return rfind(str, fromIndex); }
+  String substring( unsigned int beginIndex ) const { return String(substr(beginIndex)); }
+  String substring( unsigned int beginIndex, unsigned int endIndex ) const { return String(substr(beginIndex, endIndex)); }
+
+  void replace(const String& target, const String& repl) {
+    int i = 0;
+    while ((i = find(target, i)) != npos) {
+      assign(substr(0, i) + repl + substr(i + target.length()));
+      i += repl.length();
+    }
+  }
+  void replace(char target, char repl) {
+    replace(String(target), String(repl));
+  }
+  void remove(unsigned int index) { assign(substr(0, index)); }
+  void remove(unsigned int index, unsigned int count) { assign(substr(0, index) + substr(min(length(), index + count), count)); }
+  void toLowerCase(void) { std::transform(begin(), end(), begin(), ::tolower); }
+  void toUpperCase(void) { std::transform(begin(), end(), begin(), ::toupper); }
+
+  void trim(void) {
+    int b;
+    int e;
+    for (b = 0; b < length() && isSpace(charAt(b)); ++b);
+    for (e = length() - 1; e > b && isSpace(charAt(e)); --e);
+    assign(substr(b, e - b + 1));
+  }
+
+  long toInt(void) const      { return std::stol(*this); }
+  float toFloat(void) const   { return std::stof(*this); }
+  double toDouble(void) const { return std::stod(*this); }
+
+};
+
+inline std::ostream& operator << ( std::ostream& out, const String& bs ) {
+  out << bs.c_str();
+  return out;
+}
+

data/cpp/arduino/avr/pgmspace.h

@@ -1,10 +1,9 @@
 #pragma once
 
-
 /*
 def d(var_raw)
    var = var_raw.split("_")[0]
-   out = "#define #{var}_P(...) #{var}(__VA_ARGS__)\n"
+   out = "#define #{var}_P(...) ::#{var}(__VA_ARGS__)\n"
    IO.popen('pbcopy', 'w') { |f| f << out }
    out
  end
@@ -16,6 +15,7 @@ out.each { |l| puts d(l) }
 */
 
 #include <avr/io.h>
+#include <string.h>
 
 #define PROGMEM
 
@@ -49,46 +49,46 @@ out.each { |l| puts d(l) }
 #define pgm_read_ptr(x) (x)
 #define pgm_get_far_address(x) (x)
 
-#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__)
+#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__)

data/cpp/arduino/avr/pgmspace.h.orig

@@ -0,0 +1,95 @@
+#pragma once
+
+
+/*
+def d(var_raw)
+   var = var_raw.split("_")[0]
+   out = "#define #{var}_P(...) ::#{var}(__VA_ARGS__)\n"
+   IO.popen('pbcopy', 'w') { |f| f << out }
+   out
+ end
+
+text = File.open("arduino-1.8.5/hardware/tools/avr/avr/include/avr/pgmspace.h").read
+externs = text.split("\n").select {|l| l.start_with? "extern"}
+out = externs.map {|l| l.split("(")[0].split(" ")[-1].gsub("*", "") }.uniq
+out.each { |l| puts d(l) }
+*/
+
+#include <avr/io.h>
+#include <string>
+
+#define PROGMEM
+
+#ifndef PGM_P
+#define PGM_P const char *
+#endif
+
+#ifndef PGM_VOID_P
+#define PGM_VOID_P const void *
+#endif
+
+// everything's a no-op
+#define PSTR(s) ((const char *)(s))
+#define pgm_read_byte_near(x)  (x)
+#define pgm_read_word_near(x)  (x)
+#define pgm_read_dword_near(x) (x)
+#define pgm_read_float_near(x) (x)
+#define pgm_read_ptr_near(x)   (x)
+
+#define pgm_read_byte_far(x)  (x)
+#define pgm_read_word_far(x)  (x)
+#define pgm_read_dword_far(x) (x)
+#define pgm_read_float_far(x) (x)
+#define pgm_read_ptr_far(x)   (x)
+
+
+#define pgm_read_byte(x) (x)
+#define pgm_read_word(x) (x)
+#define pgm_read_dword(x) (x)
+#define pgm_read_float(x) (x)
+#define pgm_read_ptr(x) (x)
+#define pgm_get_far_address(x) (x)
+
+#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__)

data/cpp/arduino/ci/Queue.h

@@ -30,9 +30,9 @@ class Queue {
 
     inline bool empty() const { return 0 == mSize; }
 
-    const T& front() const { return empty() ? mNil : mFront->data; }
+    T front() const { return empty() ? mNil : mFront->data; }
 
-    const T& back() const { return empty() ? mNil : mBack->data; }
+    T back() const { return empty() ? mNil : mBack->data; }
 
     bool push(const T& v)
     {

data/cpp/unittest/ArduinoUnitTests.h

@@ -113,8 +113,8 @@ class Test
     static const int RESULT_FAIL = 2;
     static const int RESULT_SKIP = 3;
 
-    const inline char *name() { return mName; }
-    const inline int result() { return mResult; }
+    inline const char *name() const { return mName; }
+    inline int result() const { return mResult; }
 
     Test(const char* _name) : mName(_name) {
       mResult = RESULT_NONE;

data/cpp/unittest/Compare.h

@@ -1,5 +1,6 @@
 #pragma once
-#include "string.h"
+#include <avr/pgmspace.h>
+#include <WString.h>
 
 template  < typename A, typename B > struct Compare
 {
@@ -34,17 +35,250 @@ template  < typename A, typename B > struct Compare
     return !(a<b);
   } // moreOrEqual
 };
-
+template  <  > struct Compare<String,String>;
+template  <  > struct Compare<String,const char *>;
+#if defined(F)
+template  <  > struct Compare<String,const __FlashStringHelper *>;
+#endif
+template  <  > struct Compare<String,char *>;
+template  < size_t M > struct Compare<String,char [M]>;
+template  <  > struct Compare<const char *,String>;
 template  <  > struct Compare<const char *,const char *>;
+#if defined(F)
+template  <  > struct Compare<const char *,const __FlashStringHelper *>;
+#endif
 template  <  > struct Compare<const char *,char *>;
-template  < long M > struct Compare<const char *,char [M]>;
+template  < size_t M > struct Compare<const char *,char [M]>;
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,String>;
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,const char *>;
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,const __FlashStringHelper *>;
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,char *>;
+#endif
+#if defined(F)
+template  < size_t M > struct Compare<const __FlashStringHelper *,char [M]>;
+#endif
+template  <  > struct Compare<char *,String>;
 template  <  > struct Compare<char *,const char *>;
+#if defined(F)
+template  <  > struct Compare<char *,const __FlashStringHelper *>;
+#endif
 template  <  > struct Compare<char *,char *>;
-template  < long M > struct Compare<char *,char [M]>;
-template  < long N > struct Compare<char [N],const char *>;
-template  < long N > struct Compare<char [N],char *>;
-template  < long N, long M > struct Compare<char [N],char [M]>;
+template  < size_t M > struct Compare<char *,char [M]>;
+template  < size_t N > struct Compare<char [N],String>;
+template  < size_t N > struct Compare<char [N],const char *>;
+#if defined(F)
+template  < size_t N > struct Compare<char [N],const __FlashStringHelper *>;
+#endif
+template  < size_t N > struct Compare<char [N],char *>;
+template  < size_t N, size_t M > struct Compare<char [N],char [M]>;
+template  <  > struct Compare<String,String>
+{
+  inline static int between(const String &a,const String &b)
+  {
+    return a.compareTo(b);
+  } // between
+  inline static bool equal(const String &a,const String &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const String &a,const String &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const String &a,const String &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const String &a,const String &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const String &a,const String &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const String &a,const String &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+template  <  > struct Compare<String,const char *>
+{
+  inline static int between(const String &a,const char * const &b)
+  {
+    return a.compareTo(b);
+  } // between
+  inline static bool equal(const String &a,const char * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const String &a,const char * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const String &a,const char * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const String &a,const char * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const String &a,const char * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const String &a,const char * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#if defined(F)
+template  <  > struct Compare<String,const __FlashStringHelper *>
+{
+  inline static int between(const String &a,const __FlashStringHelper * const &b)
+  {
+    uint8_t a_buf[4],b_buf[4];
+    uint16_t i=0;
 
+    for (;;) {
+      uint8_t j=(i%4);
+      if (j == 0) {
+         a.getBytes(a_buf,4,i);
+         memcpy_P(b_buf,((const char *)b)+i,4);
+      }
+      if (a_buf[j] < b_buf[j]) return -1;
+      if (a_buf[j] > b_buf[j]) return  1;
+      if (a_buf[j] == 0) return 0;
+      ++i;
+    }
+  } // between
+  inline static bool equal(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const String &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+template  <  > struct Compare<String,char *>
+{
+  inline static int between(const String &a,char * const &b)
+  {
+    return a.compareTo(b);
+  } // between
+  inline static bool equal(const String &a,char * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const String &a,char * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const String &a,char * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const String &a,char * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const String &a,char * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const String &a,char * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+template  < size_t M > struct Compare<String,char [M]>
+{
+  inline static int between(const String &a,const char (&b)[M])
+  {
+    return a.compareTo(b);
+  } // between
+  inline static bool equal(const String &a,const char (&b)[M])
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const String &a,const char (&b)[M])
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const String &a,const char (&b)[M])
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const String &a,const char (&b)[M])
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const String &a,const char (&b)[M])
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const String &a,const char (&b)[M])
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+template  <  > struct Compare<const char *,String>
+{
+  inline static int between(const char * const &a,const String &b)
+  {
+    return -b.compareTo(a);
+  } // between
+  inline static bool equal(const char * const &a,const String &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const char * const &a,const String &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const char * const &a,const String &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const char * const &a,const String &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const char * const &a,const String &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const char * const &a,const String &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
 template  <  > struct Compare<const char *,const char *>
 {
   inline static int between(const char * const &a,const char * const &b)
@@ -76,6 +310,39 @@ template  <  > struct Compare<const char *,const char *>
     return between(a,b) >= 0;
   } // moreOrEqual
 };
+#if defined(F)
+template  <  > struct Compare<const char *,const __FlashStringHelper *>
+{
+  inline static int between(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return strcmp_P(a,(const char *)b);
+  } // between
+  inline static bool equal(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const char * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
 template  <  > struct Compare<const char *,char *>
 {
   inline static int between(const char * const &a,char * const &b)
@@ -107,7 +374,7 @@ template  <  > struct Compare<const char *,char *>
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < long M > struct Compare<const char *,char [M]>
+template  < size_t M > struct Compare<const char *,char [M]>
 {
   inline static int between(const char * const &a,const char (&b)[M])
   {
@@ -138,6 +405,215 @@ template  < long M > struct Compare<const char *,char [M]>
     return between(a,b) >= 0;
   } // moreOrEqual
 };
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,String>
+{
+  inline static int between(const __FlashStringHelper * const &a,const String &b)
+  {
+    return -Compare < String,const __FlashStringHelper * >::between(b,a);
+  } // between
+  inline static bool equal(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const __FlashStringHelper * const &a,const String &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,const char *>
+{
+  inline static int between(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return -strcmp_P(b,(const char *)a);
+  } // between
+  inline static bool equal(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const __FlashStringHelper * const &a,const char * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,const __FlashStringHelper *>
+{
+  inline static int between(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    uint8_t a_buf[4],b_buf[4];
+    uint16_t i=0;
+
+    for (;;) {
+      uint8_t j=(i%4);
+      if (j == 0) {
+         memcpy_P(a_buf,((const char *)a)+i,4);
+         memcpy_P(b_buf,((const char *)b)+i,4);
+      }
+      if (a_buf[j] < b_buf[j]) return -1;
+      if (a_buf[j] > b_buf[j]) return  1;
+      if (a_buf[j] == 0) return 0;
+      ++i;
+    }
+  } // between
+  inline static bool equal(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const __FlashStringHelper * const &a,const __FlashStringHelper * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+#if defined(F)
+template  <  > struct Compare<const __FlashStringHelper *,char *>
+{
+  inline static int between(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return -strcmp_P(b,(const char *)a);
+  } // between
+  inline static bool equal(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const __FlashStringHelper * const &a,char * const &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+#if defined(F)
+template  < size_t M > struct Compare<const __FlashStringHelper *,char [M]>
+{
+  inline static int between(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return -strcmp_P(b,(const char *)a);
+  } // between
+  inline static bool equal(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(const __FlashStringHelper * const &a,const char (&b)[M])
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
+#endif
+template  <  > struct Compare<char *,String>
+{
+  inline static int between(char * const &a,const String &b)
+  {
+    return -b.compareTo(a);
+  } // between
+  inline static bool equal(char * const &a,const String &b)
+  {
+    return between(a,b) == 0;
+  } // equal
+  inline static bool notEqual(char * const &a,const String &b)
+  {
+    return between(a,b) != 0;
+  } // notEqual
+  inline static bool less(char * const &a,const String &b)
+  {
+    return between(a,b) < 0;
+  } // less
+  inline static bool more(char * const &a,const String &b)
+  {
+    return between(a,b) > 0;
+  } // more
+  inline static bool lessOrEqual(char * const &a,const String &b)
+  {
+    return between(a,b) <= 0;
+  } // lessOrEqual
+  inline static bool moreOrEqual(char * const &a,const String &b)
+  {
+    return between(a,b) >= 0;
+  } // moreOrEqual
+};
 template  <  > struct Compare<char *,const char *>
 {
   inline static int between(char * const &a,const char * const &b)
@@ -169,255 +645,258 @@ template  <  > struct Compare<char *,const char *>
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  <  > struct Compare<char *,char *>
+#if defined(F)
+template  <  > struct Compare<char *,const __FlashStringHelper *>
 {
-  inline static int between(char * const &a,char * const &b)
+  inline static int between(char * const &a,const __FlashStringHelper * const &b)
   {
-    return strcmp(a,b);
+    return strcmp_P(a,(const char *)b);
   } // between
-  inline static bool equal(char * const &a,char * const &b)
+  inline static bool equal(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(char * const &a,char * const &b)
+  inline static bool notEqual(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(char * const &a,char * const &b)
+  inline static bool less(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(char * const &a,char * const &b)
+  inline static bool more(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(char * const &a,char * const &b)
+  inline static bool lessOrEqual(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(char * const &a,char * const &b)
+  inline static bool moreOrEqual(char * const &a,const __FlashStringHelper * const &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < long M > struct Compare<char *,char [M]>
+#endif
+template  <  > struct Compare<char *,char *>
 {
-  inline static int between(char * const &a,const char (&b)[M])
+  inline static int between(char * const &a,char * const &b)
   {
     return strcmp(a,b);
   } // between
-  inline static bool equal(char * const &a,const char (&b)[M])
+  inline static bool equal(char * const &a,char * const &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(char * const &a,const char (&b)[M])
+  inline static bool notEqual(char * const &a,char * const &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(char * const &a,const char (&b)[M])
+  inline static bool less(char * const &a,char * const &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(char * const &a,const char (&b)[M])
+  inline static bool more(char * const &a,char * const &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(char * const &a,const char (&b)[M])
+  inline static bool lessOrEqual(char * const &a,char * const &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(char * const &a,const char (&b)[M])
+  inline static bool moreOrEqual(char * const &a,char * const &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < long N > struct Compare<char [N],const char *>
+template  < size_t M > struct Compare<char *,char [M]>
 {
-  inline static int between(const char (&a)[N],const char * const &b)
+  inline static int between(char * const &a,const char (&b)[M])
   {
     return strcmp(a,b);
   } // between
-  inline static bool equal(const char (&a)[N],const char * const &b)
+  inline static bool equal(char * const &a,const char (&b)[M])
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(const char (&a)[N],const char * const &b)
+  inline static bool notEqual(char * const &a,const char (&b)[M])
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(const char (&a)[N],const char * const &b)
+  inline static bool less(char * const &a,const char (&b)[M])
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(const char (&a)[N],const char * const &b)
+  inline static bool more(char * const &a,const char (&b)[M])
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(const char (&a)[N],const char * const &b)
+  inline static bool lessOrEqual(char * const &a,const char (&b)[M])
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(const char (&a)[N],const char * const &b)
+  inline static bool moreOrEqual(char * const &a,const char (&b)[M])
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < long N > struct Compare<char [N],char *>
+template  < size_t N > struct Compare<char [N],String>
 {
-  inline static int between(const char (&a)[N],char * const &b)
+  inline static int between(const char (&a)[N],const String &b)
   {
-    return strcmp(a,b);
+    return -b.compareTo(a);
   } // between
-  inline static bool equal(const char (&a)[N],char * const &b)
+  inline static bool equal(const char (&a)[N],const String &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(const char (&a)[N],char * const &b)
+  inline static bool notEqual(const char (&a)[N],const String &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(const char (&a)[N],char * const &b)
+  inline static bool less(const char (&a)[N],const String &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(const char (&a)[N],char * const &b)
+  inline static bool more(const char (&a)[N],const String &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(const char (&a)[N],char * const &b)
+  inline static bool lessOrEqual(const char (&a)[N],const String &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(const char (&a)[N],char * const &b)
+  inline static bool moreOrEqual(const char (&a)[N],const String &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < long N, long M > struct Compare<char [N],char [M]>
+template  < size_t N > struct Compare<char [N],const char *>
 {
-  inline static int between(const char (&a)[N],const char (&b)[M])
+  inline static int between(const char (&a)[N],const char * const &b)
   {
     return strcmp(a,b);
   } // between
-  inline static bool equal(const char (&a)[N],const char (&b)[M])
+  inline static bool equal(const char (&a)[N],const char * const &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(const char (&a)[N],const char (&b)[M])
+  inline static bool notEqual(const char (&a)[N],const char * const &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(const char (&a)[N],const char (&b)[M])
+  inline static bool less(const char (&a)[N],const char * const &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(const char (&a)[N],const char (&b)[M])
+  inline static bool more(const char (&a)[N],const char * const &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(const char (&a)[N],const char (&b)[M])
+  inline static bool lessOrEqual(const char (&a)[N],const char * const &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(const char (&a)[N],const char (&b)[M])
+  inline static bool moreOrEqual(const char (&a)[N],const char * const &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  < > struct Compare<bool, bool>
+#if defined(F)
+template  < size_t N > struct Compare<char [N],const __FlashStringHelper *>
 {
-  inline static int between(bool a, bool b)
+  inline static int between(const char (&a)[N],const __FlashStringHelper * const &b)
   {
-    return b ? (a ? 0 : -1) : (a ? 1 : 0);
+    return strcmp_P(a,(const char *)b);
   } // between
-  inline static bool equal(bool a, bool b)
+  inline static bool equal(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(bool a, bool b)
+  inline static bool notEqual(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(bool a, bool b)
+  inline static bool less(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(bool a, bool b)
+  inline static bool more(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(bool a, bool b)
+  inline static bool lessOrEqual(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(bool a, bool b)
+  inline static bool moreOrEqual(const char (&a)[N],const __FlashStringHelper * const &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  <typename T> struct Compare<bool, T>
+#endif
+template  < size_t N > struct Compare<char [N],char *>
 {
-  inline static int between(bool a, T b)
+  inline static int between(const char (&a)[N],char * const &b)
   {
-    return b ? (a ? 0 : -1) : (a ? 1 : 0);
+    return strcmp(a,b);
   } // between
-  inline static bool equal(bool a, T b)
+  inline static bool equal(const char (&a)[N],char * const &b)
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(bool a, T b)
+  inline static bool notEqual(const char (&a)[N],char * const &b)
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(bool a, T b)
+  inline static bool less(const char (&a)[N],char * const &b)
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(bool a, T b)
+  inline static bool more(const char (&a)[N],char * const &b)
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(bool a, T b)
+  inline static bool lessOrEqual(const char (&a)[N],char * const &b)
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(bool a, T b)
+  inline static bool moreOrEqual(const char (&a)[N],char * const &b)
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-template  <typename T> struct Compare<T, bool>
+template  < size_t N, size_t M > struct Compare<char [N],char [M]>
 {
-  inline static int between(T a, bool b)
+  inline static int between(const char (&a)[N],const char (&b)[M])
   {
-    return b ? (a ? 0 : -1) : (a ? 1 : 0);
+    return strcmp(a,b);
   } // between
-  inline static bool equal(T a, bool b)
+  inline static bool equal(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) == 0;
   } // equal
-  inline static bool notEqual(T a, bool b)
+  inline static bool notEqual(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) != 0;
   } // notEqual
-  inline static bool less(T a, bool b)
+  inline static bool less(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) < 0;
   } // less
-  inline static bool more(T a, bool b)
+  inline static bool more(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) > 0;
   } // more
-  inline static bool lessOrEqual(T a, bool b)
+  inline static bool lessOrEqual(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) <= 0;
   } // lessOrEqual
-  inline static bool moreOrEqual(T a, bool b)
+  inline static bool moreOrEqual(const char (&a)[N],const char (&b)[M])
   {
     return between(a,b) >= 0;
   } // moreOrEqual
 };
-
 template <typename A, typename B> int compareBetween(const A &a, const B &b) { return Compare<A,B>::between(a,b); }
 template <typename A, typename B> bool compareEqual(const A &a, const B &b) { return Compare<A,B>::equal(a,b); }
 template <typename A, typename B> bool compareNotEqual(const A &a, const B &b) { return Compare<A,B>::notEqual(a,b); }