Merge pull request #19 from esp8266/esp8266

pull latest changes

Author: ficeto

build/linux/dist/linux64-xtensa-lx106-elf.tgz.sha

@@ -1 +1 @@
-43ca9c53d70655456a28c297526204447f65d9cb
+183d85c10ca3aabf1f57e03780fadfad589dc0bc

build/macosx/dist/osx-xtensa-lx106-elf.tgz

@@ -1 +1 @@
-123cd06d38cfe9f09bfad89cf209a2486221849f
+9c1c27e8d8027292dca18c7a6b5fab69d17ae540

build/macosx/dist/osx-xtensa-lx106-elf.tgz.sha

@@ -1 +1 @@
-8d52c4bc92aac25a87352f790038a6e1af5241c5
+7ec8f2ffdf65dc51262fccfa7a68d9ae885c06c2

build/windows/dist/win32-xtensa-lx106-elf.tgz.sha

@@ -214,6 +214,7 @@ void loop(void);
 #include "HardwareSerial.h"
 #include "FileSystem.h"
 #include "Esp.h"
+#include "debug.h"
 
 uint16_t makeWord(uint16_t w);
 uint16_t makeWord(byte h, byte l);
@@ -231,6 +232,7 @@ long random(long, long);
 void randomSeed(unsigned int);
 long map(long, long, long, long, long);
 
+
 #endif
 
 #include "pins_arduino.h"

build/windows/win32-xtensa-lx106-elf.tgz.sha

@@ -18,6 +18,7 @@
  
  Modified 23 November 2006 by David A. Mellis
  Modified December 2014 by Ivan Grokhotkov
+ Modified May 2015 by Michael C. Miller - esp8266 progmem support
  */
 
 #include <stdlib.h>
@@ -42,6 +43,18 @@ size_t ICACHE_FLASH_ATTR Print::write(const uint8_t *buffer, size_t size) {
     return n;
 }
 
+size_t ICACHE_FLASH_ATTR Print::print(const __FlashStringHelper *ifsh) {
+    PGM_P p = reinterpret_cast<PGM_P>(ifsh);
+
+    size_t n = 0;
+    while (1) {
+        uint8_t c = pgm_read_byte(p++);
+        if (c == 0) break;
+        n += write(c);
+    }
+    return n;
+}
+
 size_t ICACHE_FLASH_ATTR Print::print(const String &s) {
     return write(s.c_str(), s.length());
 }
@@ -92,6 +105,12 @@ size_t ICACHE_FLASH_ATTR Print::print(double n, int digits) {
     return printFloat(n, digits);
 }
 
+size_t ICACHE_FLASH_ATTR Print::println(const __FlashStringHelper *ifsh) {
+    size_t n = print(ifsh);
+    n += println();
+    return n;
+}
+
 size_t ICACHE_FLASH_ATTR Print::print(const Printable& x) {
     return x.printTo(*this);
 }

hardware/esp8266com/esp8266/cores/esp8266/Arduino.h

@@ -63,6 +63,7 @@ class Print {
             return write((const uint8_t *) buffer, size);
         }
 
+        size_t print(const __FlashStringHelper *);
         size_t print(const String &);
         size_t print(const char[]);
         size_t print(char);
@@ -74,6 +75,7 @@ class Print {
         size_t print(double, int = 2);
         size_t print(const Printable&);
 
+        size_t println(const __FlashStringHelper *);
         size_t println(const String &s);
         size_t println(const char[]);
         size_t println(char);

hardware/esp8266com/esp8266/cores/esp8266/Print.cpp

@@ -4,6 +4,7 @@
  Copyright (c) 2009-10 Hernando Barragan.  All rights reserved.
  Copyright 2011, Paul Stoffregen, [email protected]
  Modified by Ivan Grokhotkov, 2014 - esp8266 support
+ Modified by Michael C. Miller, 2015 - esp8266 progmem support
 
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
@@ -44,6 +45,11 @@ ICACHE_FLASH_ATTR String::String(const String &value) {
     *this = value;
 }
 
+ICACHE_FLASH_ATTR String::String(const __FlashStringHelper *pstr) {
+    init();
+    *this = pstr; // see operator =
+}
+
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 ICACHE_FLASH_ATTR String::String(String &&rval) {
     init();
@@ -167,6 +173,16 @@ String & ICACHE_FLASH_ATTR String::copy(const char *cstr, unsigned int length) {
     return *this;
 }
 
+String & ICACHE_FLASH_ATTR String::copy(const __FlashStringHelper *pstr, unsigned int length) {
+    if (!reserve(length)) {
+        invalidate();
+        return *this;
+    }
+    len = length;
+    strcpy_P(buffer, (PGM_P)pstr);
+    return *this;
+}
+
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
 void ICACHE_FLASH_ATTR String::move(String &rhs) {
     if(buffer) {
@@ -223,6 +239,14 @@ String & ICACHE_FLASH_ATTR String::operator =(const char *cstr) {
     return *this;
 }
 
+String & ICACHE_FLASH_ATTR String::operator = (const __FlashStringHelper *pstr)
+{
+    if (pstr) copy(pstr, strlen_P((PGM_P)pstr));
+    else invalidate();
+
+    return *this;
+}
+
 // /*********************************************/
 // /*  concat                                   */
 // /*********************************************/
@@ -299,6 +323,17 @@ unsigned char ICACHE_FLASH_ATTR String::concat(double num) {
     return concat(string, strlen(string));
 }
 
+unsigned char ICACHE_FLASH_ATTR String::concat(const __FlashStringHelper * str) {
+    if (!str) return 0;
+    int length = strlen_P((PGM_P)str);
+    if (length == 0) return 1;
+    unsigned int newlen = len + length;
+    if (!reserve(newlen)) return 0;
+    strcpy_P(buffer + len, (PGM_P)str);
+    len = newlen;
+    return 1;
+}
+
 /*********************************************/
 /*  Concatenate                              */
 /*********************************************/
@@ -373,6 +408,13 @@ StringSumHelper & ICACHE_FLASH_ATTR operator +(const StringSumHelper &lhs, doubl
     return a;
 }
 
+StringSumHelper & ICACHE_FLASH_ATTR operator + (const StringSumHelper &lhs, const __FlashStringHelper *rhs)
+{
+    StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+    if (!a.concat(rhs))	a.invalidate();
+    return a;
+}
+
 // /*********************************************/
 // /*  Comparison                               */
 // /*********************************************/

hardware/esp8266com/esp8266/cores/esp8266/Print.h

@@ -26,15 +26,17 @@
 #include <stdlib.h>
 #include <string.h>
 #include <ctype.h>
-#define PROGMEM
+#include <pgmspace.h>
 
 // An inherited class for holding the result of a concatenation.  These
 // result objects are assumed to be writable by subsequent concatenations.
 class StringSumHelper;
 
-typedef char* __FlashStringHelper;
-//#define F(str)  []() -> const char * { static const char tmp[] ICACHE_RODATA_ATTR = str; return &tmp[0]; }()
-#define F(str) str
+// an abstract class used as a means to proide a unique pointer type
+// but really has no body
+class __FlashStringHelper;
+#define F(string_literal) (reinterpret_cast<const __FlashStringHelper *>(PSTR(string_literal)))
+
 
 // The string class
 class String {
@@ -53,6 +55,7 @@ class String {
         // be false).
         String(const char *cstr = "");
         String(const String &str);
+        String(const __FlashStringHelper *str);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
         String(String &&rval);
         String(StringSumHelper &&rval);
@@ -81,6 +84,7 @@ class String {
         // marked as invalid ("if (s)" will be false).
         String & operator =(const String &rhs);
         String & operator =(const char *cstr);
+        String & operator = (const __FlashStringHelper *str);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
         String & operator =(String &&rval);
         String & operator =(StringSumHelper &&rval);
@@ -101,6 +105,7 @@ class String {
         unsigned char concat(unsigned long num);
         unsigned char concat(float num);
         unsigned char concat(double num);
+        unsigned char concat(const __FlashStringHelper * str);
 
         // if there's not enough memory for the concatenated value, the string
         // will be left unchanged (but this isn't signalled in any way)
@@ -144,6 +149,10 @@ class String {
             concat(num);
             return (*this);
         }
+        String & operator += (const __FlashStringHelper *str){
+            concat(str);
+            return (*this);
+        }
 
         friend StringSumHelper & operator +(const StringSumHelper &lhs, const String &rhs);
         friend StringSumHelper & operator +(const StringSumHelper &lhs, const char *cstr);
@@ -155,6 +164,7 @@ class String {
         friend StringSumHelper & operator +(const StringSumHelper &lhs, unsigned long num);
         friend StringSumHelper & operator +(const StringSumHelper &lhs, float num);
         friend StringSumHelper & operator +(const StringSumHelper &lhs, double num);
+        friend StringSumHelper & operator +(const StringSumHelper &lhs, const __FlashStringHelper *rhs);
 
         // comparison (only works w/ Strings and "strings")
         operator StringIfHelperType() const {
@@ -237,6 +247,7 @@ class String {
 
         // copy and move
         String & copy(const char *cstr, unsigned int length);
+        String & copy(const __FlashStringHelper *pstr, unsigned int length);
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
         void move(String &rhs);
 #endif