Fix warnings (#2881)

rodionkvashnin · igrr · commit 2126146e2004 · 2017-01-31T10:07:59.000+03:00
* Suppressed -Wunused-parameter and -Wunused-function by casting to void unused identifiers.

* Explicit initialization of all fields to suppress -Wmissing-field-initializers.

* Fixed signed/unsigned integer comparison.

* memset initialization of structs.

* More -Wunused-parameter fixes.
diff --git a/cores/esp8266/Esp.cpp b/cores/esp8266/Esp.cpp
@@ -83,6 +83,7 @@ EspClass ESP;
 
 void EspClass::wdtEnable(uint32_t timeout_ms)
 {
+    (void) timeout_ms;
     /// This API can only be called if software watchdog is stopped
     system_soft_wdt_restart();
 }
@@ -432,7 +433,7 @@ uint32_t EspClass::getSketchSize() {
         section_index < image_header.num_segments;
         ++section_index)
     {
-        section_header_t section_header = {0};
+        section_header_t section_header = {0, 0};
         if (spi_flash_read(pos, (uint32_t*) &section_header, sizeof(section_header))) {
             return 0;
         }
diff --git a/cores/esp8266/Schedule.cpp b/cores/esp8266/Schedule.cpp
@@ -16,6 +16,7 @@ static int sCount = 0;
 
 static void init_lists()
 {
+    (void) init_lists;
     if (sCount != 0) {
         return;
     }
diff --git a/cores/esp8266/abi.cpp b/cores/esp8266/abi.cpp
@@ -104,11 +104,13 @@ void __throw_bad_alloc()
 
 void __throw_logic_error(const char* str)
 {
+    (void) str;
     panic();
 }
 
 void __throw_out_of_range(const char* str)
 {
+    (void) str;
     panic();
 }
 }
diff --git a/cores/esp8266/cont_util.c b/cores/esp8266/cont_util.c
@@ -32,7 +32,7 @@ void ICACHE_RAM_ATTR cont_init(cont_t* cont) {
     cont->struct_start = (unsigned*) cont;
     
     // fill stack with magic values to check high water mark
-    for(int pos = 0; pos < sizeof(cont->stack) / 4; pos++)
+    for(int pos = 0; pos < (int)(sizeof(cont->stack) / 4); pos++)
     {
         cont->stack[pos] = CONT_STACKGUARD;
     }
diff --git a/cores/esp8266/core_esp8266_main.cpp b/cores/esp8266/core_esp8266_main.cpp
@@ -52,6 +52,7 @@ const char* core_release =
 } // extern "C"
 
 int atexit(void (*func)()) {
+    (void) func;
     return 0;
 }
 
@@ -125,6 +126,7 @@ static void loop_wrapper() {
 }
 
 static void loop_task(os_event_t *events) {
+    (void) events;
     g_micros_at_task_start = system_get_time();
     cont_run(&g_cont, &loop_wrapper);
     if (cont_check(&g_cont) != 0) {
diff --git a/cores/esp8266/core_esp8266_postmortem.c b/cores/esp8266/core_esp8266_postmortem.c
@@ -46,6 +46,9 @@ static void print_stack(uint32_t start, uint32_t end);
 //static void print_pcs(uint32_t start, uint32_t end);
 
 extern void __custom_crash_callback( struct rst_info * rst_info, uint32_t stack, uint32_t stack_end ) {
+    (void) rst_info;
+    (void) stack;
+    (void) stack_end;
 }
 
 extern void custom_crash_callback( struct rst_info * rst_info, uint32_t stack, uint32_t stack_end ) __attribute__ ((weak, alias("__custom_crash_callback")));
@@ -183,6 +186,7 @@ void abort(){
 }
 
 void __assert_func(const char *file, int line, const char *func, const char *what) {
+    (void) what;
     s_panic_file = file;
     s_panic_line = line;
     s_panic_func = func;
diff --git a/cores/esp8266/core_esp8266_timer.c b/cores/esp8266/core_esp8266_timer.c
@@ -30,6 +30,7 @@
 static volatile timercallback timer1_user_cb = NULL;
 
 void ICACHE_RAM_ATTR timer1_isr_handler(void *para){
+    (void) para;
     if ((T1C & ((1 << TCAR) | (1 << TCIT))) == 0) TEIE &= ~TEIE1;//edge int disable
     T1I = 0;
     if (timer1_user_cb) {
@@ -77,6 +78,7 @@ void ICACHE_RAM_ATTR timer1_disable(){
 static volatile timercallback timer0_user_cb = NULL;
 
 void ICACHE_RAM_ATTR timer0_isr_handler(void* para){
+    (void) para;
     if (timer0_user_cb) {
         // to make ISR compatible to Arduino AVR model where interrupts are disabled
         // we disable them before we call the client ISR
diff --git a/cores/esp8266/core_esp8266_wiring.c b/cores/esp8266/core_esp8266_wiring.c
@@ -36,6 +36,7 @@ static uint32_t micros_overflow_count = 0;
 #define REPEAT 1
 
 void delay_end(void* arg) {
+    (void) arg;
     esp_schedule();
 }
 
@@ -53,6 +54,7 @@ void delay(unsigned long ms) {
 }
 
 void micros_overflow_tick(void* arg) {
+    (void) arg;
     uint32_t m = system_get_time();
     if(m < micros_at_last_overflow_tick)
         ++micros_overflow_count;
diff --git a/cores/esp8266/core_esp8266_wiring_digital.c b/cores/esp8266/core_esp8266_wiring_digital.c
@@ -115,6 +115,7 @@ static interrupt_handler_t interrupt_handlers[16];
 static uint32_t interrupt_reg = 0;
 
 void ICACHE_RAM_ATTR interrupt_handler(void *arg) {
+  (void) arg;
   uint32_t status = GPIE;
   GPIEC = status;//clear them interrupts
   uint32_t levels = GPI;
diff --git a/cores/esp8266/heap.c b/cores/esp8266/heap.c
@@ -10,46 +10,60 @@
 
 void* _malloc_r(struct _reent* unused, size_t size)
 {
+    (void) unused;
     return malloc(size);
 }
 
 void _free_r(struct _reent* unused, void* ptr)
 {
+    (void) unused;
     return free(ptr);
 }
 
 void* _realloc_r(struct _reent* unused, void* ptr, size_t size)
 {
+    (void) unused;
     return realloc(ptr, size);
 }
 
 void* _calloc_r(struct _reent* unused, size_t count, size_t size)
 {
+    (void) unused;
     return calloc(count, size);
 }
 
 void* ICACHE_RAM_ATTR pvPortMalloc(size_t size, const char* file, int line)
 {
+    (void) file;
+    (void) line;
     return malloc(size);
 }
 
 void ICACHE_RAM_ATTR vPortFree(void *ptr, const char* file, int line)
 {
+    (void) file;
+    (void) line;
     free(ptr);
 }
 
 void* ICACHE_RAM_ATTR pvPortCalloc(size_t count, size_t size, const char* file, int line)
 {
+    (void) file;
+    (void) line;
     return calloc(count, size);
 }
 
 void* ICACHE_RAM_ATTR pvPortRealloc(void *ptr, size_t size, const char* file, int line)
 {
+    (void) file;
+    (void) line;
     return realloc(ptr, size);
 }
 
 void* ICACHE_RAM_ATTR pvPortZalloc(size_t size, const char* file, int line)
 {
+    (void) file;
+    (void) line;
     return calloc(1, size);
 }
 
diff --git a/cores/esp8266/libc_replacements.c b/cores/esp8266/libc_replacements.c
@@ -83,6 +83,7 @@ int ICACHE_RAM_ATTR _read_r(struct _reent* unused, int file, char *ptr, int len)
 }
 
 int ICACHE_RAM_ATTR _write_r(struct _reent* r, int file, char *ptr, int len) {
+    (void) r;
     if (file == STDOUT_FILENO) {
         while(len--) {
             ets_putc(*ptr);
@@ -93,6 +94,7 @@ int ICACHE_RAM_ATTR _write_r(struct _reent* r, int file, char *ptr, int len) {
 }
 
 int ICACHE_RAM_ATTR _putc_r(struct _reent* r, int c, FILE* file) {
+    (void) r;
     if (file->_file == STDOUT_FILENO) {
         return ets_putc(c);
     }
diff --git a/cores/esp8266/spiffs/spiffs_hydrogen.c b/cores/esp8266/spiffs/spiffs_hydrogen.c
@@ -22,6 +22,7 @@ static s32_t spiffs_fflush_cache(spiffs *fs, spiffs_file fh);
 
 #if SPIFFS_BUFFER_HELP
 u32_t SPIFFS_buffer_bytes_for_filedescs(spiffs *fs, u32_t num_descs) {
+  (void) fs;
   return num_descs * sizeof(spiffs_fd);
 }
 #if SPIFFS_CACHE
diff --git a/cores/esp8266/spiffs_api.h b/cores/esp8266/spiffs_api.h
@@ -49,13 +49,13 @@ class SPIFFSImpl : public FSImpl
 {
 public:
     SPIFFSImpl(uint32_t start, uint32_t size, uint32_t pageSize, uint32_t blockSize, uint32_t maxOpenFds)
-        : _fs({0})
-    , _start(start)
+        : _start(start)
     , _size(size)
     , _pageSize(pageSize)
     , _blockSize(blockSize)
     , _maxOpenFds(maxOpenFds)
     {
+        memset(&_fs, 0, sizeof(_fs));
     }
 
     FileImplPtr open(const char* path, OpenMode openMode, AccessMode accessMode) override;
@@ -176,7 +176,8 @@ class SPIFFSImpl : public FSImpl
 
     bool _tryMount()
     {
-        spiffs_config config = {0};
+        spiffs_config config;
+        memset(&config, 0, sizeof(config));
 
         config.hal_read_f       = &spiffs_hal_read;
         config.hal_write_f      = &spiffs_hal_write;
@@ -242,6 +243,11 @@ class SPIFFSImpl : public FSImpl
     static void _check_cb(spiffs_check_type type, spiffs_check_report report,
                           uint32_t arg1, uint32_t arg2)
     {
+        (void) type;
+        (void) report;
+        (void) arg1;
+        (void) arg2;
+        
         // TODO: spiffs doesn't pass any context pointer along with _check_cb,
         // so we can't do anything useful here other than perhaps
         // feeding the watchdog
@@ -268,9 +274,9 @@ class SPIFFSFileImpl : public FileImpl
     SPIFFSFileImpl(SPIFFSImpl* fs, spiffs_file fd)
         : _fs(fs)
         , _fd(fd)
-        , _stat({0})
     , _written(false)
     {
+        memset(&_stat, 0, sizeof(_stat));
         _getStat();
     }
 
@@ -376,7 +382,7 @@ class SPIFFSFileImpl : public FileImpl
         auto rc = SPIFFS_fstat(_fs->getFs(), _fd, &_stat);
         if (rc != SPIFFS_OK) {
             DEBUGV("SPIFFS_fstat rc=%d\r\n", rc);
-            _stat = {0};
+            memset(&_stat, 0, sizeof(_stat));
         }
         _written = false;
     }
diff --git a/cores/esp8266/time.c b/cores/esp8266/time.c
@@ -77,6 +77,7 @@ void configTime(int timezone, int daylightOffset_sec, const char* server1, const
 
 int clock_gettime(clockid_t unused, struct timespec *tp)
 {
+    (void) unused;
     tp->tv_sec  = millis() / 1000;
     tp->tv_nsec = micros() * 1000;
     return 0;
@@ -94,6 +95,8 @@ time_t time(time_t * t)
 
 int _gettimeofday_r(struct _reent* unused, struct timeval *tp, void *tzp)
 {
+    (void) unused;
+    (void) tzp;
     if (tp)
     {
         ensureBootTimeIsSet();
diff --git a/cores/esp8266/uart.c b/cores/esp8266/uart.c
@@ -480,6 +480,7 @@ bool uart_rx_enabled(uart_t* uart)
 
 static void uart_ignore_char(char c)
 {
+    (void) c;
 }
 
 static void uart0_write_char(char c)
diff --git a/libraries/ESP8266WebServer/src/Parsing.cpp b/libraries/ESP8266WebServer/src/Parsing.cpp
@@ -361,7 +361,7 @@ uint8_t ESP8266WebServer::_uploadReadByte(WiFiClient& client){
 }
 
 bool ESP8266WebServer::_parseForm(WiFiClient& client, String boundary, uint32_t len){
-
+  (void) len;
 #ifdef DEBUG_ESP_HTTP_SERVER
   DEBUG_OUTPUT.print("Parse Form: Boundary: ");
   DEBUG_OUTPUT.print(boundary);
diff --git a/libraries/ESP8266WebServer/src/detail/RequestHandler.h b/libraries/ESP8266WebServer/src/detail/RequestHandler.h
@@ -4,10 +4,10 @@
 class RequestHandler {
 public:
     virtual ~RequestHandler() { }
-    virtual bool canHandle(HTTPMethod method, String uri) { return false; }
-    virtual bool canUpload(String uri) { return false; }
-    virtual bool handle(ESP8266WebServer& server, HTTPMethod requestMethod, String requestUri) { return false; }
-    virtual void upload(ESP8266WebServer& server, String requestUri, HTTPUpload& upload) {}
+    virtual bool canHandle(HTTPMethod method, String uri) { (void) method; (void) uri; return false; }
+    virtual bool canUpload(String uri) { (void) uri; return false; }
+    virtual bool handle(ESP8266WebServer& server, HTTPMethod requestMethod, String requestUri) { (void) server; (void) requestMethod; (void) requestUri; return false; }
+    virtual void upload(ESP8266WebServer& server, String requestUri, HTTPUpload& upload) { (void) server; (void) requestUri; (void) upload; }
 
     RequestHandler* next() { return _next; }
     void next(RequestHandler* r) { _next = r; }
diff --git a/libraries/ESP8266WebServer/src/detail/RequestHandlersImpl.h b/libraries/ESP8266WebServer/src/detail/RequestHandlersImpl.h
@@ -31,6 +31,7 @@ class FunctionRequestHandler : public RequestHandler {
     }
 
     bool handle(ESP8266WebServer& server, HTTPMethod requestMethod, String requestUri) override {
+        (void) server;
         if (!canHandle(requestMethod, requestUri))
             return false;
 
@@ -39,6 +40,8 @@ class FunctionRequestHandler : public RequestHandler {
     }
 
     void upload(ESP8266WebServer& server, String requestUri, HTTPUpload& upload) override {
+        (void) server;
+        (void) upload;
         if (canUpload(requestUri))
             _ufn();
     }
diff --git a/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp b/libraries/ESP8266WiFi/src/ESP8266WiFiGeneric.cpp
@@ -153,6 +153,7 @@ WiFiEventHandler ESP8266WiFiGenericClass::onStationModeGotIP(std::function<void(
 WiFiEventHandler ESP8266WiFiGenericClass::onStationModeDHCPTimeout(std::function<void(void)> f)
 {
     WiFiEventHandler handler = std::make_shared<WiFiEventHandlerOpaque>(WIFI_EVENT_STAMODE_DHCP_TIMEOUT, [f](System_Event_t* e){
+        (void) e;
         f();
     });
     sCbEventList.push_back(handler);
@@ -452,6 +453,7 @@ int ESP8266WiFiGenericClass::hostByName(const char* aHostname, IPAddress& aResul
  * @param callback_arg
  */
 void wifi_dns_found_callback(const char *name, ip_addr_t *ipaddr, void *callback_arg) {
+    (void) name;
     if(ipaddr) {
         (*reinterpret_cast<IPAddress*>(callback_arg)) = ipaddr->addr;
     }
diff --git a/libraries/ESP8266WiFi/src/WiFiClient.cpp b/libraries/ESP8266WiFi/src/WiFiClient.cpp
@@ -135,6 +135,7 @@ int WiFiClient::connect(IPAddress ip, uint16_t port)
 
 int8_t WiFiClient::_connected(void* pcb, int8_t err)
 {
+    (void) err;
     tcp_pcb* tpcb = reinterpret_cast<tcp_pcb*>(pcb);
     _client = new ClientContext(tpcb, 0, 0);
     _client->ref();
@@ -144,6 +145,7 @@ int8_t WiFiClient::_connected(void* pcb, int8_t err)
 
 void WiFiClient::_err(int8_t err)
 {
+    (void) err;
     DEBUGV(":err %d\r\n", err);
     esp_schedule();
 }
@@ -177,6 +179,7 @@ size_t WiFiClient::write(const uint8_t *buf, size_t size)
 
 size_t WiFiClient::write(Stream& stream, size_t unused)
 {
+    (void) unused;
     return WiFiClient::write(stream);
 }
 
diff --git a/libraries/ESP8266WiFi/src/WiFiClientSecure.cpp b/libraries/ESP8266WiFi/src/WiFiClientSecure.cpp
diff --git a/libraries/ESP8266WiFi/src/WiFiServer.cpp b/libraries/ESP8266WiFi/src/WiFiServer.cpp
diff --git a/libraries/ESP8266WiFi/src/include/ClientContext.h b/libraries/ESP8266WiFi/src/include/ClientContext.h
diff --git a/libraries/ESP8266WiFi/src/include/DataSource.h b/libraries/ESP8266WiFi/src/include/DataSource.h
diff --git a/libraries/ESP8266WiFi/src/include/UdpContext.h b/libraries/ESP8266WiFi/src/include/UdpContext.h
diff --git a/libraries/ESP8266mDNS/ESP8266mDNS.cpp b/libraries/ESP8266mDNS/ESP8266mDNS.cpp
diff --git a/libraries/ESP8266mDNS/ESP8266mDNS.h b/libraries/ESP8266mDNS/ESP8266mDNS.h

Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ EspClass ESP;`
`83`	`83`
`84`	`84`	`void EspClass::wdtEnable(uint32_t timeout_ms)`
`85`	`85`	`{`
	`86`	`+ (void) timeout_ms;`
`86`	`87`	`/// This API can only be called if software watchdog is stopped`
`87`	`88`	`system_soft_wdt_restart();`
`88`	`89`	`}`
`@@ -432,7 +433,7 @@ uint32_t EspClass::getSketchSize() {`
`432`	`433`	`section_index < image_header.num_segments;`
`433`	`434`	`++section_index)`
`434`	`435`	`{`
`435`		`- section_header_t section_header = {0};`
	`436`	`+ section_header_t section_header = {0, 0};`
`436`	`437`	`if (spi_flash_read(pos, (uint32_t*) &section_header, sizeof(section_header))) {`
`437`	`438`	`return 0;`
`438`	`439`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@ static int sCount = 0;`
`16`	`16`
`17`	`17`	`static void init_lists()`
`18`	`18`	`{`
	`19`	`+ (void) init_lists;`
`19`	`20`	`if (sCount != 0) {`
`20`	`21`	`return;`
`21`	`22`	`}`
Original file line number	Diff line number	Diff line change
`@@ -104,11 +104,13 @@ void __throw_bad_alloc()`
`104`	`104`
`105`	`105`	`void __throw_logic_error(const char* str)`
`106`	`106`	`{`
	`107`	`+ (void) str;`
`107`	`108`	`panic();`
`108`	`109`	`}`
`109`	`110`
`110`	`111`	`void __throw_out_of_range(const char* str)`
`111`	`112`	`{`
	`113`	`+ (void) str;`
`112`	`114`	`panic();`
`113`	`115`	`}`
`114`	`116`	`}`
Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ void ICACHE_RAM_ATTR cont_init(cont_t* cont) {`
`32`	`32`	`cont->struct_start = (unsigned*) cont;`
`33`	`33`
`34`	`34`	`// fill stack with magic values to check high water mark`
`35`		`- for(int pos = 0; pos < sizeof(cont->stack) / 4; pos++)`
	`35`	`+ for(int pos = 0; pos < (int)(sizeof(cont->stack) / 4); pos++)`
`36`	`36`	`{`
`37`	`37`	`cont->stack[pos] = CONT_STACKGUARD;`
`38`	`38`	`}`
Original file line number	Diff line number	Diff line change
`@@ -52,6 +52,7 @@ const char* core_release =`
`52`	`52`	`} // extern "C"`
`53`	`53`
`54`	`54`	`int atexit(void (*func)()) {`
	`55`	`+ (void) func;`
`55`	`56`	`return 0;`
`56`	`57`	`}`
`57`	`58`
`@@ -125,6 +126,7 @@ static void loop_wrapper() {`
`125`	`126`	`}`
`126`	`127`
`127`	`128`	`static void loop_task(os_event_t *events) {`
	`129`	`+ (void) events;`
`128`	`130`	`g_micros_at_task_start = system_get_time();`
`129`	`131`	`cont_run(&g_cont, &loop_wrapper);`
`130`	`132`	`if (cont_check(&g_cont) != 0) {`
Original file line number	Diff line number	Diff line change
`@@ -46,6 +46,9 @@ static void print_stack(uint32_t start, uint32_t end);`
`46`	`46`	`//static void print_pcs(uint32_t start, uint32_t end);`
`47`	`47`
`48`	`48`	`extern void __custom_crash_callback( struct rst_info * rst_info, uint32_t stack, uint32_t stack_end ) {`
	`49`	`+ (void) rst_info;`
	`50`	`+ (void) stack;`
	`51`	`+ (void) stack_end;`
`49`	`52`	`}`
`50`	`53`
`51`	`54`	`extern void custom_crash_callback( struct rst_info * rst_info, uint32_t stack, uint32_t stack_end ) __attribute__ ((weak, alias("__custom_crash_callback")));`
`@@ -183,6 +186,7 @@ void abort(){`
`183`	`186`	`}`
`184`	`187`
`185`	`188`	`void __assert_func(const char file, int line, const char func, const char *what) {`
	`189`	`+ (void) what;`
`186`	`190`	`s_panic_file = file;`
`187`	`191`	`s_panic_line = line;`
`188`	`192`	`s_panic_func = func;`
Original file line number	Diff line number	Diff line change
`@@ -36,6 +36,7 @@ static uint32_t micros_overflow_count = 0;`
`36`	`36`	`#define REPEAT 1`
`37`	`37`
`38`	`38`	`void delay_end(void* arg) {`
	`39`	`+ (void) arg;`
`39`	`40`	`esp_schedule();`
`40`	`41`	`}`
`41`	`42`
`@@ -53,6 +54,7 @@ void delay(unsigned long ms) {`
`53`	`54`	`}`
`54`	`55`
`55`	`56`	`void micros_overflow_tick(void* arg) {`
	`57`	`+ (void) arg;`
`56`	`58`	`uint32_t m = system_get_time();`
`57`	`59`	`if(m < micros_at_last_overflow_tick)`
`58`	`60`	`++micros_overflow_count;`
Original file line number	Diff line number	Diff line change
`@@ -10,46 +10,60 @@`
`10`	`10`
`11`	`11`	`void* _malloc_r(struct _reent* unused, size_t size)`
`12`	`12`	`{`
	`13`	`+ (void) unused;`
`13`	`14`	`return malloc(size);`
`14`	`15`	`}`
`15`	`16`
`16`	`17`	`void _free_r(struct _reent* unused, void* ptr)`
`17`	`18`	`{`
	`19`	`+ (void) unused;`
`18`	`20`	`return free(ptr);`
`19`	`21`	`}`
`20`	`22`
`21`	`23`	`void* _realloc_r(struct _reent* unused, void* ptr, size_t size)`
`22`	`24`	`{`
	`25`	`+ (void) unused;`
`23`	`26`	`return realloc(ptr, size);`
`24`	`27`	`}`
`25`	`28`
`26`	`29`	`void* _calloc_r(struct _reent* unused, size_t count, size_t size)`
`27`	`30`	`{`
	`31`	`+ (void) unused;`
`28`	`32`	`return calloc(count, size);`
`29`	`33`	`}`
`30`	`34`
`31`	`35`	`void* ICACHE_RAM_ATTR pvPortMalloc(size_t size, const char* file, int line)`
`32`	`36`	`{`
	`37`	`+ (void) file;`
	`38`	`+ (void) line;`
`33`	`39`	`return malloc(size);`
`34`	`40`	`}`
`35`	`41`
`36`	`42`	`void ICACHE_RAM_ATTR vPortFree(void ptr, const char file, int line)`
`37`	`43`	`{`
	`44`	`+ (void) file;`
	`45`	`+ (void) line;`
`38`	`46`	`free(ptr);`
`39`	`47`	`}`
`40`	`48`
`41`	`49`	`void* ICACHE_RAM_ATTR pvPortCalloc(size_t count, size_t size, const char* file, int line)`
`42`	`50`	`{`
	`51`	`+ (void) file;`
	`52`	`+ (void) line;`
`43`	`53`	`return calloc(count, size);`
`44`	`54`	`}`
`45`	`55`
`46`	`56`	`void* ICACHE_RAM_ATTR pvPortRealloc(void ptr, size_t size, const char file, int line)`
`47`	`57`	`{`
	`58`	`+ (void) file;`
	`59`	`+ (void) line;`
`48`	`60`	`return realloc(ptr, size);`
`49`	`61`	`}`
`50`	`62`
`51`	`63`	`void* ICACHE_RAM_ATTR pvPortZalloc(size_t size, const char* file, int line)`
`52`	`64`	`{`
	`65`	`+ (void) file;`
	`66`	`+ (void) line;`
`53`	`67`	`return calloc(1, size);`
`54`	`68`	`}`
`55`	`69`
Original file line number	Diff line number	Diff line change
`@@ -83,6 +83,7 @@ int ICACHE_RAM_ATTR _read_r(struct _reent* unused, int file, char *ptr, int len)`
`83`	`83`	`}`
`84`	`84`
`85`	`85`	`int ICACHE_RAM_ATTR _write_r(struct _reent* r, int file, char *ptr, int len) {`
	`86`	`+ (void) r;`
`86`	`87`	`if (file == STDOUT_FILENO) {`
`87`	`88`	`while(len--) {`
`88`	`89`	`ets_putc(*ptr);`
`@@ -93,6 +94,7 @@ int ICACHE_RAM_ATTR _write_r(struct _reent* r, int file, char *ptr, int len) {`
`93`	`94`	`}`
`94`	`95`
`95`	`96`	`int ICACHE_RAM_ATTR _putc_r(struct _reent* r, int c, FILE* file) {`
	`97`	`+ (void) r;`
`96`	`98`	`if (file->_file == STDOUT_FILENO) {`
`97`	`99`	`return ets_putc(c);`
`98`	`100`	`}`
Original file line number	Diff line number	Diff line change
`@@ -22,6 +22,7 @@ static s32_t spiffs_fflush_cache(spiffs *fs, spiffs_file fh);`
`22`	`22`
`23`	`23`	`#if SPIFFS_BUFFER_HELP`
`24`	`24`	`u32_t SPIFFS_buffer_bytes_for_filedescs(spiffs *fs, u32_t num_descs) {`
	`25`	`+ (void) fs;`
`25`	`26`	`return num_descs * sizeof(spiffs_fd);`
`26`	`27`	`}`
`27`	`28`	`#if SPIFFS_CACHE`