fix some more warnings

ardera · ardera · commit a4a188132a43 · 2024-09-16T17:11:26.000Z
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -168,7 +168,7 @@ target_include_directories(flutterpi_module PUBLIC
 )
 
 target_compile_options(flutterpi_module PUBLIC
-  $<$<CONFIG:Debug>:-O0 -Wall -Wextra -Wno-sign-compare -Wswitch-enum -Wformat -Wdouble-promotion -Werror -ggdb -U_FORTIFY_SOURCE -DDEBUG>
+  $<$<CONFIG:Debug>:-O0 -Wall -Wextra -Wno-sign-compare -Wswitch-enum -Wformat -Wformat-pedantic -Wdouble-promotion -Werror -ggdb -U_FORTIFY_SOURCE -DDEBUG>
   $<$<CONFIG:RelWithDebInfo>:-O3 -Wall -Wextra -Wno-sign-compare -ggdb -DNDEBUG>
   $<$<CONFIG:Release>:-O3 -Wall -Wextra -Wno-sign-compare -DNDEBUG>
 )
diff --git a/CMakePresets.json b/CMakePresets.json
@@ -13,7 +13,9 @@
                 "ENABLE_OPENGL": true,
                 "BUILD_GSTREAMER_AUDIO_PLAYER_PLUGIN": true,
                 "BUILD_SENTRY_PLUGIN": true,
-                "ENABLE_TESTS": true
+                "ENABLE_TESTS": true,
+                "CMAKE_C_COMPILER": "clang-20",
+                "CMAKE_CXX_COMPILER": "clang++-20"
             }
         },
         {
@@ -41,4 +43,4 @@
             }
         }
     ]
-}
+}
diff --git a/src/compositor_ng.c b/src/compositor_ng.c
@@ -231,7 +231,7 @@ static void fill_platform_view_layer_props(
     size_t n_mutations,
     const struct mat3f *display_to_view_transform,
     const struct mat3f *view_to_display_transform,
-    double device_pixel_ratio
+    float device_pixel_ratio
 ) {
     (void) view_to_display_transform;
 
@@ -262,8 +262,8 @@ static void fill_platform_view_layer_props(
 	 * ```
 	 */
 
-    rect.size.x /= device_pixel_ratio;
-    rect.size.y /= device_pixel_ratio;
+    rect.size.x /= (double) device_pixel_ratio;
+    rect.size.y /= (double) device_pixel_ratio;
 
     // okay, now we have the params.finalBoundingRect().x() in aa_back_transformed.x and
     // params.finalBoundingRect().y() in aa_back_transformed.y.
diff --git a/src/egl_gbm_render_surface.c b/src/egl_gbm_render_surface.c
@@ -655,10 +655,10 @@ static int egl_gbm_render_surface_queue_present(struct render_surface *s, const
 
         LOG_DEBUG(
             "using fourcc %c%c%c%c (%s) with modifier 0x%" PRIx64 "\n",
-            fourcc & 0xFF,
-            (fourcc >> 8) & 0xFF,
-            (fourcc >> 16) & 0xFF,
-            (fourcc >> 24) & 0xFF,
+            (char) (fourcc & 0xFF),
+            (char) ((fourcc >> 8) & 0xFF),
+            (char) ((fourcc >> 16) & 0xFF),
+            (char) ((fourcc >> 24) & 0xFF),
             has_format ? get_pixfmt_info(format)->name : "?",
             modifier
         );
diff --git a/src/flutter-pi.c b/src/flutter-pi.c
@@ -1452,7 +1452,7 @@ static int flutterpi_run(struct flutterpi *flutterpi) {
     window_metrics_event.struct_size = sizeof(FlutterWindowMetricsEvent);
     window_metrics_event.width = (size_t) geometry.view_size.x;
     window_metrics_event.height = (size_t) geometry.view_size.y;
-    window_metrics_event.pixel_ratio = geometry.device_pixel_ratio;
+    window_metrics_event.pixel_ratio = (double) geometry.device_pixel_ratio;
     window_metrics_event.left = 0;
     window_metrics_event.top = 0;
     window_metrics_event.physical_view_inset_top = 0;
diff --git a/src/platformchannel.c b/src/platformchannel.c
@@ -3,12 +3,12 @@
 #include <assert.h>
 #include <ctype.h>
 #include <errno.h>
+#include <float.h>
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
-#include <float.h>
 
 #include <flutter_embedder.h>
 
@@ -957,118 +957,147 @@ int platch_decode_json(char *string, struct json_value *out) {
 }
 
 int platch_decode(const uint8_t *buffer, size_t size, enum platch_codec codec, struct platch_obj *object_out) {
-    struct json_value root_jsvalue;
-    const uint8_t *buffer_cursor = buffer;
-    size_t remaining = size;
     int ok;
 
     if ((size == 0) && (buffer == NULL)) {
         object_out->codec = kNotImplemented;
         return 0;
     }
 
+    const uint8_t *buffer_cursor = buffer;
+    size_t remaining = size;
+
     object_out->codec = codec;
     switch (codec) {
-        case kNotImplemented:
-            ASSERT_EQUALS(size, 0);
-            ASSERT_EQUALS(buffer, NULL);
-            break;
+        case kNotImplemented: {
+            if (size != 0) {
+                return EINVAL;
+            }
+            if (buffer != NULL) {
+                return EINVAL;
+            }
 
-        case kStringCodec:;
-            /// buffer is a non-null-terminated, UTF8-encoded string.
-            /// it's really sad we have to allocate a new memory block for this, but we have to since string codec buffers are not null-terminated.
+            break;
+        }
 
-            char *string;
-            if (!(string = malloc(size + 1)))
+        case kStringCodec: {
+            char *string = malloc(size + 1);
+            if (string == NULL) {
                 return ENOMEM;
-            memcpy(string, buffer, size);
+            }
+
+            strncpy(string, (char *) buffer, size);
             string[size] = '\0';
 
             object_out->string_value = string;
-
             break;
-        case kBinaryCodec:
+        }
+        case kBinaryCodec: {
+            if (size == 0) {
+                return EINVAL;
+            }
+            if (buffer == NULL) {
+                return EINVAL;
+            }
+
             object_out->binarydata = buffer;
             object_out->binarydata_size = size;
-
             break;
-        case kJSONMessageCodec:
-            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &(object_out->json_value));
-            if (ok != 0)
+        }
+        case kJSONMessageCodec: {
+            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &object_out->json_value);
+            if (ok != 0) {
                 return ok;
+            }
 
             break;
-        case kJSONMethodCall:;
-            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &root_jsvalue);
-            if (ok != 0)
-                return ok;
+        }
+        case kJSONMethodCall: {
+            struct json_value root;
 
-            if (root_jsvalue.type != kJsonObject)
-                return EBADMSG;
+            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &root);
+            if (ok != 0) {
+                return ok;
+            }
 
-            for (int i = 0; i < root_jsvalue.size; i++) {
-                if ((streq(root_jsvalue.keys[i], "method")) && (root_jsvalue.values[i].type == kJsonString)) {
-                    object_out->method = root_jsvalue.values[i].string_value;
-                } else if (streq(root_jsvalue.keys[i], "args")) {
-                    object_out->json_arg = root_jsvalue.values[i];
-                } else
-                    return EBADMSG;
+            if (root.type != kJsonObject) {
+                platch_free_json_value(&root, true);
+                return EINVAL;
             }
 
-            platch_free_json_value(&root_jsvalue, true);
+            for (int i = 0; i < root.size; i++) {
+                if ((streq(root.keys[i], "method")) && (root.values[i].type == kJsonString)) {
+                    object_out->method = root.values[i].string_value;
+                } else if (streq(root.keys[i], "args")) {
+                    object_out->json_arg = root.values[i];
+                } else {
+                    return EINVAL;
+                }
+            }
 
+            platch_free_json_value(&root, true);
             break;
+        }
         case kJSONMethodCallResponse: {
-            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &root_jsvalue);
+            struct json_value root;
+
+            ok = platch_decode_value_json((char *) buffer, size, NULL, NULL, &root);
             if (ok != 0) {
                 return ok;
             }
 
-            if (root_jsvalue.type != kJsonArray) {
-                platch_free_json_value(&root_jsvalue, true);
-                return EBADMSG;
+            if (root.type != kJsonArray) {
+                platch_free_json_value(&root, true);
+                return EINVAL;
             }
 
-            if (root_jsvalue.size == 1) {
+            if (root.size == 1) {
                 object_out->success = true;
-                object_out->json_result = root_jsvalue.array[0];
-                platch_free_json_value(&root_jsvalue, true);
-            } else if ((root_jsvalue.size == 3) && (root_jsvalue.array[0].type == kJsonString) &&
-                       ((root_jsvalue.array[1].type == kJsonString) || (root_jsvalue.array[1].type == kJsonNull))) {
+                object_out->json_result = root.array[0];
+            } else if ((root.size == 3) && (root.array[0].type == kJsonString) &&
+                       ((root.array[1].type == kJsonString) || (root.array[1].type == kJsonNull))) {
                 object_out->success = false;
-                object_out->error_code = root_jsvalue.array[0].string_value;
-                object_out->error_msg = root_jsvalue.array[1].string_value;
-                object_out->json_error_details = root_jsvalue.array[2];
-                platch_free_json_value(&root_jsvalue, true);
+                object_out->error_code = root.array[0].string_value;
+                object_out->error_msg = root.array[1].string_value;
+                object_out->json_error_details = root.array[2];
             } else {
-                platch_free_json_value(&root_jsvalue, true);
-                return EBADMSG;
+                platch_free_json_value(&root, true);
+                return EINVAL;
             }
 
+            platch_free_json_value(&root, true);
             break;
         }
-        case kStandardMessageCodec:
+        case kStandardMessageCodec: {
             ok = platch_decode_value_std(&buffer_cursor, &remaining, &object_out->std_value);
-            if (ok != 0)
+            if (ok != 0) {
                 return ok;
+            }
+
             break;
-        case kStandardMethodCall:;
+        }
+        case kStandardMethodCall: {
             struct std_value methodname;
 
             ok = platch_decode_value_std(&buffer_cursor, &remaining, &methodname);
-            if (ok != 0)
+            if (ok != 0) {
                 return ok;
+            }
+
             if (methodname.type != kStdString) {
                 platch_free_value_std(&methodname);
-                return EBADMSG;
+                return EINVAL;
             }
+
             object_out->method = methodname.string_value;
 
             ok = platch_decode_value_std(&buffer_cursor, &remaining, &object_out->std_arg);
-            if (ok != 0)
+            if (ok != 0) {
                 return ok;
+            }
 
             break;
+        }
         case kStandardMethodCallResponse: {
             ok = _read_u8(&buffer_cursor, (uint8_t *) &object_out->success, &remaining);
             if (ok != 0) {
@@ -1077,8 +1106,9 @@ int platch_decode(const uint8_t *buffer, size_t size, enum platch_codec codec, s
 
             if (object_out->success) {
                 ok = platch_decode_value_std(&buffer_cursor, &remaining, &(object_out->std_result));
-                if (ok != 0)
+                if (ok != 0) {
                     return ok;
+                }
             } else {
                 struct std_value error_code, error_msg;
 
@@ -1107,9 +1137,10 @@ int platch_decode(const uint8_t *buffer, size_t size, enum platch_codec codec, s
                     platch_free_value_std(&object_out->std_error_details);
                     platch_free_value_std(&error_code);
                     platch_free_value_std(&error_msg);
-                    return EBADMSG;
+                    return EINVAL;
                 }
             }
+
             break;
         }
         default: return EINVAL;
@@ -1128,28 +1159,58 @@ int platch_encode(struct platch_obj *object, uint8_t **buffer_out, size_t *size_
     *buffer_out = NULL;
 
     switch (object->codec) {
-        case kNotImplemented:
+        case kNotImplemented: {
             *size_out = 0;
             *buffer_out = NULL;
             return 0;
-        case kStringCodec: size = strlen(object->string_value); break;
-        case kBinaryCodec:
+        }
+        case kStringCodec: {
+            *buffer_out = (uint8_t *) strdup(object->string_value);
+            if (buffer_out == NULL) {
+                return ENOMEM;
+            }
+
+            *size_out = strlen(object->string_value);
+            return 0;
+        }
+        case kBinaryCodec: {
             /// FIXME: Copy buffer instead
             *buffer_out = (uint8_t *) object->binarydata;
             *size_out = object->binarydata_size;
             return 0;
-        case kJSONMessageCodec:
+        }
+        case kJSONMessageCodec: {
             size = platch_calc_value_size_json(&(object->json_value));
             size += 1;  // JSONMsgCodec uses sprintf, which null-terminates strings,
                 // so lets allocate one more byte for the last null-terminator.
                 // this is decremented again in the second switch-case, so flutter
                 // doesn't complain about a malformed message.
+
+            buffer = malloc(size);
+            if (buffer == NULL) {
+                return ENOMEM;
+            }
+
+            ok = platch_write_value_to_buffer_json(&(object->json_value), &buffer_cursor);
+            if (ok != 0) {
+                goto free_buffer_and_return_ok;
+            }
+
             break;
-        case kStandardMessageCodec:
+        }
+        case kStandardMessageCodec: {
             ok = platch_calc_value_size_std(&(object->std_value), &size);
-            if (ok != 0)
+            if (ok != 0) {
                 return ok;
-            break;
+            }
+
+            buffer = malloc(size);
+            if (buffer == NULL) {
+                return ENOMEM;
+            }
+
+            buffer_cursor = buffer;
+        }
         case kStandardMethodCall:
             stdmethod.type = kStdString;
             stdmethod.string_value = object->method;
@@ -2254,7 +2315,7 @@ ATTR_PURE bool raw_std_value_equals(const struct raw_std_value *a, const struct
             length = raw_std_value_get_size(a);
             const float *a_floats = raw_std_value_as_float32array(a);
             const float *b_floats = raw_std_value_as_float32array(b);
-            
+
             PRAGMA_DIAGNOSTIC_PUSH
             PRAGMA_DIAGNOSTIC_IGNORED("-Wfloat-equal")
             for (int i = 0; i < length; i++) {
diff --git a/src/plugins/audioplayers/plugin.c b/src/plugins/audioplayers/plugin.c
diff --git a/src/plugins/gstreamer_video_player/frame.c b/src/plugins/gstreamer_video_player/frame.c
diff --git a/test/platformchannel_test.c b/test/platformchannel_test.c

Original file line number	Diff line number	Diff line change
`@@ -168,7 +168,7 @@ target_include_directories(flutterpi_module PUBLIC`
`168`	`168`	`)`
`169`	`169`
`170`	`170`	`target_compile_options(flutterpi_module PUBLIC`
`171`		`- $<$<CONFIG:Debug>:-O0 -Wall -Wextra -Wno-sign-compare -Wswitch-enum -Wformat -Wdouble-promotion -Werror -ggdb -U_FORTIFY_SOURCE -DDEBUG>`
	`171`	`+ $<$<CONFIG:Debug>:-O0 -Wall -Wextra -Wno-sign-compare -Wswitch-enum -Wformat -Wformat-pedantic -Wdouble-promotion -Werror -ggdb -U_FORTIFY_SOURCE -DDEBUG>`
`172`	`172`	`$<$<CONFIG:RelWithDebInfo>:-O3 -Wall -Wextra -Wno-sign-compare -ggdb -DNDEBUG>`
`173`	`173`	`$<$<CONFIG:Release>:-O3 -Wall -Wextra -Wno-sign-compare -DNDEBUG>`
`174`	`174`	`)`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,9 @@`
`13`	`13`	`"ENABLE_OPENGL": true,`
`14`	`14`	`"BUILD_GSTREAMER_AUDIO_PLAYER_PLUGIN": true,`
`15`	`15`	`"BUILD_SENTRY_PLUGIN": true,`
`16`		`- "ENABLE_TESTS": true`
	`16`	`+ "ENABLE_TESTS": true,`
	`17`	`+ "CMAKE_C_COMPILER": "clang-20",`
	`18`	`+ "CMAKE_CXX_COMPILER": "clang++-20"`
`17`	`19`	`}`
`18`	`20`	`},`
`19`	`21`	`{`
`@@ -41,4 +43,4 @@`
`41`	`43`	`}`
`42`	`44`	`}`
`43`	`45`	`]`
`44`		`-}`
	`46`	`+}`