Merge pull request #1713 from esp8266/core_cleanup

Clean up core files

Author: igrr

cores/esp8266/FS.h

@@ -21,8 +21,8 @@
 #ifndef FS_H
 #define FS_H
 
-#include <Arduino.h>
 #include <memory>
+#include <Arduino.h>
 
 namespace fs {
 

cores/esp8266/Print.cpp

@@ -1,21 +1,21 @@
 /*
  Print.cpp - Base class that provides print() and println()
  Copyright (c) 2008 David A. Mellis.  All right reserved.
- 
+
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
- 
+
  This library is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  Lesser General Public License for more details.
- 
+
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
- 
+
  Modified 23 November 2006 by David A. Mellis
  Modified December 2014 by Ivan Grokhotkov
  Modified May 2015 by Michael C. Miller - esp8266 progmem support
@@ -25,18 +25,14 @@
 #include <stdio.h>
 #include <string.h>
 #include <math.h>
-#include "Arduino.h"
+#include <Arduino.h>
 
 #include "Print.h"
-extern "C" {
-#include "c_types.h"
-#include "ets_sys.h"
-}
 
 // Public Methods //////////////////////////////////////////////////////////////
 
 /* default implementation: may be overridden */
-size_t ICACHE_FLASH_ATTR Print::write(const uint8_t *buffer, size_t size) {
+size_t Print::write(const uint8_t *buffer, size_t size) {
     size_t n = 0;
     while(size--) {
         n += write(*buffer++);
@@ -67,7 +63,7 @@ size_t Print::printf(const char *format, ...) {
     return len;
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(const __FlashStringHelper *ifsh) {
+size_t Print::print(const __FlashStringHelper *ifsh) {
     PGM_P p = reinterpret_cast<PGM_P>(ifsh);
 
     size_t n = 0;
@@ -79,31 +75,31 @@ size_t ICACHE_FLASH_ATTR Print::print(const __FlashStringHelper *ifsh) {
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(const String &s) {
+size_t Print::print(const String &s) {
     return write(s.c_str(), s.length());
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(const char str[]) {
+size_t Print::print(const char str[]) {
     return write(str);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(char c) {
+size_t Print::print(char c) {
     return write(c);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(unsigned char b, int base) {
+size_t Print::print(unsigned char b, int base) {
     return print((unsigned long) b, base);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(int n, int base) {
+size_t Print::print(int n, int base) {
     return print((long) n, base);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(unsigned int n, int base) {
+size_t Print::print(unsigned int n, int base) {
     return print((unsigned long) n, base);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(long n, int base) {
+size_t Print::print(long n, int base) {
     if(base == 0) {
         return write(n);
     } else if(base == 10) {
@@ -118,94 +114,94 @@ size_t ICACHE_FLASH_ATTR Print::print(long n, int base) {
     }
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(unsigned long n, int base) {
+size_t Print::print(unsigned long n, int base) {
     if(base == 0)
         return write(n);
     else
         return printNumber(n, base);
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(double n, int digits) {
+size_t Print::print(double n, int digits) {
     return printFloat(n, digits);
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(const __FlashStringHelper *ifsh) {
+size_t Print::println(const __FlashStringHelper *ifsh) {
     size_t n = print(ifsh);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::print(const Printable& x) {
+size_t Print::print(const Printable& x) {
     return x.printTo(*this);
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(void) {
+size_t Print::println(void) {
     return print("\r\n");
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(const String &s) {
+size_t Print::println(const String &s) {
     size_t n = print(s);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(const char c[]) {
+size_t Print::println(const char c[]) {
     size_t n = print(c);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(char c) {
+size_t Print::println(char c) {
     size_t n = print(c);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(unsigned char b, int base) {
+size_t Print::println(unsigned char b, int base) {
     size_t n = print(b, base);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(int num, int base) {
+size_t Print::println(int num, int base) {
     size_t n = print(num, base);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(unsigned int num, int base) {
+size_t Print::println(unsigned int num, int base) {
     size_t n = print(num, base);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(long num, int base) {
+size_t Print::println(long num, int base) {
     size_t n = print(num, base);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(unsigned long num, int base) {
+size_t Print::println(unsigned long num, int base) {
     size_t n = print(num, base);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(double num, int digits) {
+size_t Print::println(double num, int digits) {
     size_t n = print(num, digits);
     n += println();
     return n;
 }
 
-size_t ICACHE_FLASH_ATTR Print::println(const Printable& x) {
+size_t Print::println(const Printable& x) {
     size_t n = print(x);
     n += println();
     return n;
 }
 
 // Private Methods /////////////////////////////////////////////////////////////
 
-size_t ICACHE_FLASH_ATTR Print::printNumber(unsigned long n, uint8_t base) {
+size_t Print::printNumber(unsigned long n, uint8_t base) {
     char buf[8 * sizeof(long) + 1]; // Assumes 8-bit chars plus zero byte.
     char *str = &buf[sizeof(buf) - 1];
 
@@ -225,7 +221,7 @@ size_t ICACHE_FLASH_ATTR Print::printNumber(unsigned long n, uint8_t base) {
     return write(str);
 }
 
-size_t ICACHE_FLASH_ATTR Print::printFloat(double number, uint8_t digits) {
+size_t Print::printFloat(double number, uint8_t digits) {
     size_t n = 0;
 
     if(isnan(number))

cores/esp8266/Stream.cpp

@@ -20,16 +20,13 @@
  parsing functions based on TextFinder library by Michael Margolis
  */
 
-#include "Arduino.h"
-#include "Stream.h"
-extern "C" {
-#include "c_types.h"
-}
+#include <Arduino.h>
+#include <Stream.h>
 #define PARSE_TIMEOUT 1000  // default number of milli-seconds to wait
 #define NO_SKIP_CHAR  1  // a magic char not found in a valid ASCII numeric field
 
 // private method to read stream with timeout
-int ICACHE_FLASH_ATTR Stream::timedRead() {
+int Stream::timedRead() {
     int c;
     _startMillis = millis();
     do {
@@ -42,7 +39,7 @@ int ICACHE_FLASH_ATTR Stream::timedRead() {
 }
 
 // private method to peek stream with timeout
-int ICACHE_FLASH_ATTR Stream::timedPeek() {
+int Stream::timedPeek() {
     int c;
     _startMillis = millis();
     do {
@@ -56,7 +53,7 @@ int ICACHE_FLASH_ATTR Stream::timedPeek() {
 
 // returns peek of the next digit in the stream or -1 if timeout
 // discards non-numeric characters
-int ICACHE_FLASH_ATTR Stream::peekNextDigit() {
+int Stream::peekNextDigit() {
     int c;
     while(1) {
         c = timedPeek();
@@ -73,31 +70,31 @@ int ICACHE_FLASH_ATTR Stream::peekNextDigit() {
 // Public Methods
 //////////////////////////////////////////////////////////////
 
-void ICACHE_FLASH_ATTR Stream::setTimeout(unsigned long timeout)  // sets the maximum number of milliseconds to wait
+void Stream::setTimeout(unsigned long timeout)  // sets the maximum number of milliseconds to wait
 {
     _timeout = timeout;
 }
 
 // find returns true if the target string is found
-bool ICACHE_FLASH_ATTR Stream::find(const char *target) {
+bool Stream::find(const char *target) {
     return findUntil(target, (char*) "");
 }
 
 // reads data from the stream until the target string of given length is found
 // returns true if target string is found, false if timed out
-bool ICACHE_FLASH_ATTR Stream::find(const char *target, size_t length) {
+bool Stream::find(const char *target, size_t length) {
     return findUntil(target, length, NULL, 0);
 }
 
 // as find but search ends if the terminator string is found
-bool ICACHE_FLASH_ATTR Stream::findUntil(const char *target, const char *terminator) {
+bool Stream::findUntil(const char *target, const char *terminator) {
     return findUntil(target, strlen(target), terminator, strlen(terminator));
 }
 
 // reads data from the stream until the target string of the given length is found
 // search terminated if the terminator string is found
 // returns true if target string is found, false if terminated or timed out
-bool ICACHE_FLASH_ATTR Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen) {
+bool Stream::findUntil(const char *target, size_t targetLen, const char *terminator, size_t termLen) {
     size_t index = 0;  // maximum target string length is 64k bytes!
     size_t termIndex = 0;
     int c;
@@ -128,13 +125,13 @@ bool ICACHE_FLASH_ATTR Stream::findUntil(const char *target, size_t targetLen, c
 // returns the first valid (long) integer value from the current position.
 // initial characters that are not digits (or the minus sign) are skipped
 // function is terminated by the first character that is not a digit.
-long ICACHE_FLASH_ATTR Stream::parseInt() {
+long Stream::parseInt() {
     return parseInt(NO_SKIP_CHAR); // terminate on first non-digit character (or timeout)
 }
 
 // as above but a given skipChar is ignored
 // this allows format characters (typically commas) in values to be ignored
-long ICACHE_FLASH_ATTR Stream::parseInt(char skipChar) {
+long Stream::parseInt(char skipChar) {
     boolean isNegative = false;
     long value = 0;
     int c;
@@ -161,13 +158,13 @@ long ICACHE_FLASH_ATTR Stream::parseInt(char skipChar) {
 }
 
 // as parseInt but returns a floating point value
-float ICACHE_FLASH_ATTR Stream::parseFloat() {
+float Stream::parseFloat() {
     return parseFloat(NO_SKIP_CHAR);
 }
 
 // as above but the given skipChar is ignored
 // this allows format characters (typically commas) in values to be ignored
-float ICACHE_FLASH_ATTR Stream::parseFloat(char skipChar) {
+float Stream::parseFloat(char skipChar) {
     boolean isNegative = false;
     boolean isFraction = false;
     long value = 0;
@@ -208,7 +205,7 @@ float ICACHE_FLASH_ATTR Stream::parseFloat(char skipChar) {
 // returns the number of characters placed in the buffer
 // the buffer is NOT null terminated.
 //
-size_t ICACHE_FLASH_ATTR Stream::readBytes(char *buffer, size_t length) {
+size_t Stream::readBytes(char *buffer, size_t length) {
     size_t count = 0;
     while(count < length) {
         int c = timedRead();
@@ -224,7 +221,7 @@ size_t ICACHE_FLASH_ATTR Stream::readBytes(char *buffer, size_t length) {
 // terminates if length characters have been read, timeout, or if the terminator character  detected
 // returns the number of characters placed in the buffer (0 means no valid data found)
 
-size_t ICACHE_FLASH_ATTR Stream::readBytesUntil(char terminator, char *buffer, size_t length) {
+size_t Stream::readBytesUntil(char terminator, char *buffer, size_t length) {
     if(length < 1)
         return 0;
     size_t index = 0;
@@ -238,7 +235,7 @@ size_t ICACHE_FLASH_ATTR Stream::readBytesUntil(char terminator, char *buffer, s
     return index; // return number of characters, not including null terminator
 }
 
-String ICACHE_FLASH_ATTR Stream::readString() {
+String Stream::readString() {
     String ret;
     int c = timedRead();
     while(c >= 0) {
@@ -248,7 +245,7 @@ String ICACHE_FLASH_ATTR Stream::readString() {
     return ret;
 }
 
-String ICACHE_FLASH_ATTR Stream::readStringUntil(char terminator) {
+String Stream::readStringUntil(char terminator) {
     String ret;
     int c = timedRead();
     while(c >= 0 && c != terminator) {