fix compile warnings (#1042)

src/layer.cpp

@@ -20,10 +20,14 @@
 #include <algorithm>
 #include "cpu.h"
 
+#ifdef __clang__
 #pragma clang diagnostic push
 #pragma clang diagnostic ignored "-Woverloaded-virtual"
+#endif
 #include "layer_declaration.h"
+#ifdef __clang__
 #pragma clang diagnostic pop
+#endif
 
 namespace ncnn {
 

src/paramdict.cpp

@@ -106,7 +106,7 @@ int ParamDict::load_param(FILE* fp)
             int nscan = fscanf(fp, "%d", &len);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict read array length fail\n");
+                fprintf(stderr, "ParamDict read array length failed\n");
                 return -1;
             }
 
@@ -118,7 +118,7 @@ int ParamDict::load_param(FILE* fp)
                 nscan = fscanf(fp, ",%15[^,\n ]", vstr);
                 if (nscan != 1)
                 {
-                    fprintf(stderr, "ParamDict read array element fail\n");
+                    fprintf(stderr, "ParamDict read array element failed\n");
                     return -1;
                 }
 
@@ -136,7 +136,7 @@ int ParamDict::load_param(FILE* fp)
                 }
                 if (nscan != 1)
                 {
-                    fprintf(stderr, "ParamDict parse array element fail\n");
+                    fprintf(stderr, "ParamDict parse array element failed\n");
                     return -1;
                 }
             }
@@ -147,7 +147,7 @@ int ParamDict::load_param(FILE* fp)
             int nscan = fscanf(fp, "%15s", vstr);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict read value fail\n");
+                fprintf(stderr, "ParamDict read value failed\n");
                 return -1;
             }
 
@@ -159,7 +159,7 @@ int ParamDict::load_param(FILE* fp)
                 nscan = sscanf(vstr, "%d", &params[id].i);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict parse value fail\n");
+                fprintf(stderr, "ParamDict parse value failed\n");
                 return -1;
             }
         }
@@ -218,7 +218,7 @@ int ParamDict::load_param_mem(const char*& mem)
             int nscan = mem_sscanf(mem, "%d", &len);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict read array length fail\n");
+                fprintf(stderr, "ParamDict read array length failed\n");
                 return -1;
             }
 
@@ -230,7 +230,7 @@ int ParamDict::load_param_mem(const char*& mem)
                 nscan = mem_sscanf(mem, ",%15[^,\n ]", vstr);
                 if (nscan != 1)
                 {
-                    fprintf(stderr, "ParamDict read array element fail\n");
+                    fprintf(stderr, "ParamDict read array element failed\n");
                     return -1;
                 }
 
@@ -248,7 +248,7 @@ int ParamDict::load_param_mem(const char*& mem)
                 }
                 if (nscan != 1)
                 {
-                    fprintf(stderr, "ParamDict parse array element fail\n");
+                    fprintf(stderr, "ParamDict parse array element failed\n");
                     return -1;
                 }
             }
@@ -259,7 +259,7 @@ int ParamDict::load_param_mem(const char*& mem)
             int nscan = mem_sscanf(mem, "%15s", vstr);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict read value fail\n");
+                fprintf(stderr, "ParamDict read value failed\n");
                 return -1;
             }
 
@@ -271,7 +271,7 @@ int ParamDict::load_param_mem(const char*& mem)
                 nscan = sscanf(vstr, "%d", &params[id].i);
             if (nscan != 1)
             {
-                fprintf(stderr, "ParamDict parse value fail\n");
+                fprintf(stderr, "ParamDict parse value failed\n");
                 return -1;
             }
         }
@@ -300,7 +300,13 @@ int ParamDict::load_param_bin(FILE* fp)
 //     binary -233(EOP)
 
     int id = 0;
-    fread(&id, sizeof(int), 1, fp);
+    int nread;
+    nread = fread(&id, sizeof(int), 1, fp);
+    if (nread != 1)
+    {
+        fprintf(stderr, "ParamDict read magic failed %d\n", nread);
+        return -1;
+    }
 
     while (id != -233)
     {
@@ -313,21 +319,41 @@ int ParamDict::load_param_bin(FILE* fp)
         if (is_array)
         {
             int len = 0;
-            fread(&len, sizeof(int), 1, fp);
+            nread = fread(&len, sizeof(int), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "ParamDict read array length failed %d\n", nread);
+                return -1;
+            }
 
             params[id].v.create(len);
 
             float* ptr = params[id].v;
-            fread(ptr, sizeof(float), len, fp);
+            nread = fread(ptr, sizeof(float), len, fp);
+            if (nread != len)
+            {
+                fprintf(stderr, "ParamDict read array element failed %d\n", nread);
+                return -1;
+            }
         }
         else
         {
-            fread(&params[id].f, sizeof(float), 1, fp);
+            nread = fread(&params[id].f, sizeof(float), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "ParamDict read value failed %d\n", nread);
+                return -1;
+            }
         }
 
         params[id].loaded = 1;
 
-        fread(&id, sizeof(int), 1, fp);
+        nread = fread(&id, sizeof(int), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "ParamDict read EOP failed %d\n", nread);
+            return -1;
+        }
     }
 
     return 0;

tools/mxnet/mxnet2ncnn.cpp

@@ -297,7 +297,12 @@ static bool read_mxnet_json(const char* jsonpath, std::vector<MXNetNode>& nodes)
     char line[1024];
 
     //{
-    (void)fgets(line, 1024, fp);
+    char* s = fgets(line, 1024, fp);
+    if (!s)
+    {
+        fprintf(stderr, "fgets %s failed\n", jsonpath);
+        return false;
+    }
 
     MXNetNode n;
 
@@ -522,23 +527,44 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
         return false;
     }
 
+    int nread;
     uint64_t header;
     uint64_t reserved;
-    fread(&header, 1, sizeof(uint64_t), fp);
-    fread(&reserved, 1, sizeof(uint64_t), fp);
+    nread = fread(&header, sizeof(uint64_t), 1, fp);
+    if (nread != 1)
+    {
+        fprintf(stderr, "read header failed %d\n", nread);
+        return false;
+    }
+    nread = fread(&reserved, sizeof(uint64_t), 1, fp);
+    if (nread != 1)
+    {
+        fprintf(stderr, "read reserved failed %d\n", nread);
+        return false;
+    }
 
     // NDArray vec
 
     // each data
     uint64_t data_count;
-    fread(&data_count, 1, sizeof(uint64_t), fp);
+    nread = fread(&data_count, sizeof(uint64_t), 1, fp);
+    if (nread != 1)
+    {
+        fprintf(stderr, "read data_count failed %d\n", nread);
+        return false;
+    }
 
 //     fprintf(stderr, "data count = %d\n", (int)data_count);
 
     for (int i = 0; i < (int)data_count; i++)
     {
         uint32_t magic;// 0xF993FAC9
-        fread(&magic, 1, sizeof(uint32_t), fp);
+        nread = fread(&magic, sizeof(uint32_t), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read magic failed %d\n", nread);
+            return false;
+        }
 
         // shape
         uint32_t ndim;
@@ -547,19 +573,44 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
         if (magic == 0xF993FAC9)
         {
             int32_t stype;
-            fread(&stype, 1, sizeof(int32_t), fp);
+            nread = fread(&stype, sizeof(int32_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read stype failed %d\n", nread);
+                return false;
+            }
 
-            fread(&ndim, 1, sizeof(uint32_t), fp);
+            nread = fread(&ndim, sizeof(uint32_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read ndim failed %d\n", nread);
+                return false;
+            }
 
             shape.resize(ndim);
-            fread(&shape[0], 1, ndim * sizeof(int64_t), fp);
+            nread = fread(&shape[0], ndim * sizeof(int64_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read shape failed %d\n", nread);
+                return false;
+            }
         }
         else if (magic == 0xF993FAC8)
         {
-            fread(&ndim, 1, sizeof(uint32_t), fp);
+            nread = fread(&ndim, sizeof(uint32_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read ndim failed %d\n", nread);
+                return false;
+            }
 
             shape.resize(ndim);
-            fread(&shape[0], 1, ndim * sizeof(int64_t), fp);
+            nread = fread(&shape[0], ndim * sizeof(int64_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read shape failed %d\n", nread);
+                return false;
+            }
         }
         else
         {
@@ -569,7 +620,12 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
 
             std::vector<uint32_t> shape32;
             shape32.resize(ndim);
-            fread(&shape32[0], 1, ndim * sizeof(uint32_t), fp);
+            nread = fread(&shape32[0], ndim * sizeof(uint32_t), 1, fp);
+            if (nread != 1)
+            {
+                fprintf(stderr, "read shape failed %d\n", nread);
+                return false;
+            }
 
             for (int j=0; j<(int)ndim; j++)
             {
@@ -580,11 +636,26 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
         // context
         int32_t dev_type;
         int32_t dev_id;
-        fread(&dev_type, 1, sizeof(int32_t), fp);
-        fread(&dev_id, 1, sizeof(int32_t), fp);
+        nread = fread(&dev_type, sizeof(int32_t), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read dev_type failed %d\n", nread);
+            return false;
+        }
+        nread = fread(&dev_id, sizeof(int32_t), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read dev_id failed %d\n", nread);
+            return false;
+        }
 
         int32_t type_flag;
-        fread(&type_flag, 1, sizeof(int32_t), fp);
+        nread = fread(&type_flag, sizeof(int32_t), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read type_flag failed %d\n", nread);
+            return false;
+        }
 
         // data
         size_t len = 0;
@@ -596,7 +667,12 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
         MXNetParam p;
 
         p.data.resize(len);
-        fread(&p.data[0], 1, len * sizeof(float), fp);
+        nread = fread(&p.data[0], len * sizeof(float), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read MXNetParam data failed %d\n", nread);
+            return false;
+        }
 
         params.push_back(p);
 
@@ -605,19 +681,34 @@ static bool read_mxnet_param(const char* parampath, std::vector<MXNetParam>& par
 
     // each name
     uint64_t name_count;
-    fread(&name_count, 1, sizeof(uint64_t), fp);
+    nread = fread(&name_count, sizeof(uint64_t), 1, fp);
+    if (nread != 1)
+    {
+        fprintf(stderr, "read name_count failed %d\n", nread);
+        return false;
+    }
 
 //     fprintf(stderr, "name count = %d\n", (int)name_count);
 
     for (int i = 0; i < (int)name_count; i++)
     {
         uint64_t len;
-        fread(&len, 1, sizeof(uint64_t), fp);
+        nread = fread(&len, sizeof(uint64_t), 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read name length failed %d\n", nread);
+            return false;
+        }
 
         MXNetParam& p = params[i];
 
         p.name.resize(len);
-        fread((char*)p.name.data(), 1, len, fp);
+        nread = fread((char*)p.name.data(), len, 1, fp);
+        if (nread != 1)
+        {
+            fprintf(stderr, "read MXNetParam name failed %d\n", nread);
+            return false;
+        }
 
         // cut leading arg:
         if (memcmp(p.name.c_str(), "arg:", 4) == 0)
@@ -2117,6 +2208,10 @@ int main(int argc, char** argv)
         {
             int num_outputs = n.attr("num_outputs");
             int squeeze_axis = n.attr("squeeze_axis");// TODO
+            if (squeeze_axis)
+            {
+                fprintf(stderr, "Unsupported SliceChannel squeeze_axis !\n");
+            }
 
             fprintf(pp, " -23300=%d", num_outputs);
             for (int j=0; j<num_outputs; j++)

tools/ncnn2mem.cpp

@@ -94,13 +94,24 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
     fprintf(ip, "#define NCNN_INCLUDE_GUARD_%s\n", include_guard_var.c_str());
     fprintf(ip, "namespace %s_id {\n", param_var.c_str());
 
+    int nscan = 0;
     int magic = 0;
-    fscanf(fp, "%d", &magic);
+    nscan = fscanf(fp, "%d", &magic);
+    if (nscan != 1)
+    {
+        fprintf(stderr, "read magic failed %d\n", nscan);
+        return -1;
+    }
     fwrite(&magic, sizeof(int), 1, mp);
 
     int layer_count = 0;
     int blob_count = 0;
-    fscanf(fp, "%d %d", &layer_count, &blob_count);
+    nscan = fscanf(fp, "%d %d", &layer_count, &blob_count);
+    if (nscan != 2)
+    {
+        fprintf(stderr, "read layer_count and blob_count failed %d\n", nscan);
+        return -1;
+    }
     fwrite(&layer_count, sizeof(int), 1, mp);
     fwrite(&blob_count, sizeof(int), 1, mp);
 
@@ -110,8 +121,6 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
     int blob_index = 0;
     for (int i=0; i<layer_count; i++)
     {
-        int nscan = 0;
-
         char layer_type[33];
         char layer_name[257];
         int bottom_count = 0;
@@ -119,7 +128,8 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
         nscan = fscanf(fp, "%32s %256s %d %d", layer_type, layer_name, &bottom_count, &top_count);
         if (nscan != 4)
         {
-            continue;
+            fprintf(stderr, "read layer params failed %d\n", nscan);
+            return -1;
         }
 
         sanitize_name(layer_name);
@@ -139,7 +149,8 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
             nscan = fscanf(fp, "%256s", bottom_name);
             if (nscan != 1)
             {
-                continue;
+                fprintf(stderr, "read bottom_name failed %d\n", nscan);
+                return -1;
             }
 
             sanitize_name(bottom_name);
@@ -156,7 +167,8 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
             nscan = fscanf(fp, "%256s", blob_name);
             if (nscan != 1)
             {
-                continue;
+                fprintf(stderr, "read blob_name failed %d\n", nscan);
+                return -1;
             }
 
             sanitize_name(blob_name);
@@ -182,13 +194,23 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
             if (is_array)
             {
                 int len = 0;
-                fscanf(fp, "%d", &len);
+                nscan = fscanf(fp, "%d", &len);
+                if (nscan != 1)
+                {
+                    fprintf(stderr, "read array length failed %d\n", nscan);
+                    return -1;
+                }
                 fwrite(&len, sizeof(int), 1, mp);
 
                 for (int j = 0; j < len; j++)
                 {
                     char vstr[16];
-                    fscanf(fp, ",%15[^,\n ]", vstr);
+                    nscan = fscanf(fp, ",%15[^,\n ]", vstr);
+                    if (nscan != 1)
+                    {
+                        fprintf(stderr, "read array element failed %d\n", nscan);
+                        return -1;
+                    }
 
                     bool is_float = vstr_is_float(vstr);
 
@@ -209,7 +231,12 @@ static int dump_param(const char* parampath, const char* parambinpath, const cha
             else
             {
                 char vstr[16];
-                fscanf(fp, "%15s", vstr);
+                nscan = fscanf(fp, "%15s", vstr);
+                if (nscan != 1)
+                {
+                    fprintf(stderr, "read value failed %d\n", nscan);
+                    return -1;
+                }
 
                 bool is_float = vstr_is_float(vstr);