fix static analyse style

diff --git a/src/kds_s2000w_client.c b/src/kds_s2000w_client.c
index 12b37861b9299621e12996d101c15c7895c542c1..6d0b415783421ae70578f284f11ce13f674cc327 100644 (file)
--- a/src/kds_s2000w_client.c
+++ b/src/kds_s2000w_client.c
@@ -57,7 +57,7 @@ void _kds_s2000w_client_set_verbose()
        curl_easy_setopt(curl, CURLOPT_VERBOSE, 1L);
 }
 
-size_t _kds_s2000w_client_write_callback(char* ptr, size_t size, size_t nmemb, void* data)
+size_t _kds_s2000w_client_write_callback(const char* ptr, size_t size, size_t nmemb, void* data)
 {
        response* resp = (response*) data;
 

diff --git a/src/kds_s2000w_config.c b/src/kds_s2000w_config.c
index f27f72677a51207cb6d483ab006d2ed58e6e0b21..9042ba3f56a3abc48a667c941449df4b676746ba 100644 (file)
--- a/src/kds_s2000w_config.c
+++ b/src/kds_s2000w_config.c
@@ -30,7 +30,7 @@ program_config* _kds_s2000w_config_init()
 
 char* _kds_s2000w_config_copy_config_string(cfg_t* cfg, const char* key)
 {
-       char* value_str = cfg_getstr(cfg, key);
+       const char* value_str = cfg_getstr(cfg, key);
        size_t length = strlen(value_str) + 1;
        char* new_str = malloc(sizeof(char) * length);
        if (new_str == NULL)
@@ -74,7 +74,7 @@ program_config* kds_s2000w_config_load(char* config_string)
        if (config_string == NULL)
                return config;
 
-       if (strlen(config_string) <= 0)
+       if (strlen(config_string) == 0)
                return config;
 
        cfg_opt_t opts[] = {

diff --git a/src/kds_s2000w_debug.c b/src/kds_s2000w_debug.c
index d723902c1e0fede52fcd4188cf51238b3684114d..e4cbad010039f17ddc0634e91f5b43c992db0d2f 100644 (file)
--- a/src/kds_s2000w_debug.c
+++ b/src/kds_s2000w_debug.c
@@ -30,7 +30,7 @@ const char* _kds_s2000w_debug_string(uint8_t level)
 }
 
 uint8_t kds_s2000w_debug_get_log_level() {
-       char* log_level = getenv("KDS_S2000W_NET_DEBUG");
+       const char* log_level = getenv("KDS_S2000W_NET_DEBUG");
 
        if (log_level == NULL)
                return log_level_default;

diff --git a/src/kds_s2000w_handler.c b/src/kds_s2000w_handler.c
index 429e513fe4e6df9c2021d5ec940358d68a68ca5b..302c700e8e74870ace673c5ecde1c4b09d18bdb2 100644 (file)
--- a/src/kds_s2000w_handler.c
+++ b/src/kds_s2000w_handler.c
@@ -13,11 +13,11 @@
 #define DEVICE_NAME "kds_s2000w_net"
 #define ATTEMPT 30
 
-uint32_t _kds_s2000w_handler_find_first_data_byte(imagedata* image)
+uint32_t _kds_s2000w_handler_find_first_data_byte(const imagedata* image)
 {
        kds_s2000w_debug_printf(ALL, "sane_kds_s2000w_net_find_first_data_byte");
 
-       char* data = (char*) image->data;
+       const char* data = (const char*) image->data;
        uint8_t header_spaces = 3;
 
        if (strncmp(data, "P4", 2) == 0)
@@ -62,6 +62,18 @@ void _kds_s2000w_handler_load_config(handler* h)
        config = NULL;
 }
 
+uint32_t _kds_s2000w_handler_is_color(const handler* h)
+{
+       json_object* config = json_object_object_get(h->current_scanner_config, "Configuration");
+       json_object* color_mode = json_object_object_get(config, "ColorMode");
+       const char* color_value = json_object_get_string(color_mode);
+
+       if (strcmp(color_value, "Color") == 0)
+               return 1;
+
+       return 0;
+}
+
 handler* kds_s2000w_handler_init()
 {
        kds_s2000w_debug_printf(ALL, "init handler");
@@ -258,14 +270,14 @@ void kds_s2000w_handler_recreate_session(handler* h)
        resp = NULL;
 }
 
-void kds_s2000w_handler_start_scan(handler* h)
+void kds_s2000w_handler_start_scan(const handler* h)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_handler_start_scan");
 
        kds_s2000w_client_start_scan(h->sessionid);
 }
 
-void kds_s2000w_handler_stop_scan(handler* h)
+void kds_s2000w_handler_stop_scan(const handler* h)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_handler_stop_scan");
 
@@ -284,19 +296,7 @@ void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params)
        params->pixels_per_line = 0;
        params->lines = 0;
        params->depth = 8;
-
-       json_object* config = json_object_object_get(h->current_scanner_config, "Configuration");
-       json_object* metadata = json_object_object_get(config, "ColorMode");
-       const char* color_value = json_object_get_string(metadata);
-
-       if (strcmp(color_value, "Color") == 0)
-               params->format = 1;
-
-       if (strcmp(color_value, "Gray") == 0)
-               params->format = 0;
-
-       if (strcmp(color_value, "BW") == 0)
-               params->format = 0;
+       params->format = _kds_s2000w_handler_is_color(h);
 
        if (h->image->data == NULL)
                return;
@@ -345,7 +345,6 @@ void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params)
        
        h->read_info->read_size = _kds_s2000w_handler_find_first_data_byte(h->image);
 
-       metadata = NULL;
        free(mdata);
        mdata = NULL;
        free(scanner_image->data);

diff --git a/src/kds_s2000w_handler.h b/src/kds_s2000w_handler.h
index 9bdeb2b536b3255bd273cfd43809af4a985d49a1..841787e13d95f54fe47a7ae1c706b68f27b81e08 100644 (file)
--- a/src/kds_s2000w_handler.h
+++ b/src/kds_s2000w_handler.h
@@ -78,8 +78,8 @@ void kds_s2000w_handler_recreate_session(handler* h);
 void kds_s2000w_handler_opts_get_option(handler* handle, uint32_t option, void* value, int32_t* info);
 void kds_s2000w_handler_opts_set_option(handler* handle, uint32_t option, void* value, int32_t* info);
 
-void kds_s2000w_handler_start_scan(handler* h);
-void kds_s2000w_handler_stop_scan(handler* h);
+void kds_s2000w_handler_start_scan(const handler* h);
+void kds_s2000w_handler_stop_scan(const handler* h);
 
 void kds_s2000w_handler_get_current_metadata(handler* h, metadata* params);
 void kds_s2000w_handler_get_current_scan_status(handler* h);

diff --git a/src/kds_s2000w_handler_opts.c b/src/kds_s2000w_handler_opts.c
index 73b093482e3cb8ec832b207888e527f801a92638..8e2244b01e8176bd3ad108328db714ff76e68f22 100644 (file)
--- a/src/kds_s2000w_handler_opts.c
+++ b/src/kds_s2000w_handler_opts.c
@@ -59,7 +59,7 @@ void _kds_s2000w_handler_opts_load_options(handler* h)
        resp = NULL;
 }
 
-void _kds_s2000w_handler_opts_set_scan_source(option_descriptor* descriptor, handler* h, char* value)
+void _kds_s2000w_handler_opts_set_scan_source(const option_descriptor* descriptor, handler* h, const char* value)
 {
        if (strcmp(descriptor->config_name, SCAN_SOURCE) != 0)
                return;
@@ -97,7 +97,7 @@ void _kds_s2000w_handler_opts_set_option_to_default(handler* h)
        resp = NULL;
 }
 
-json_object* _kds_s2000w_handler_opts_reset(option_descriptor* descriptor, handler* h)
+json_object* _kds_s2000w_handler_opts_reset(const option_descriptor* descriptor, handler* h)
 {
        if (strcmp(descriptor->config_name, RESET) != 0)
                return json_object_object_get(h->current_scanner_config, CONFIGURATION);
@@ -336,51 +336,51 @@ void _kds_s2000w_handler_opts_set_enable_color_drop_out_aggressiveness(json_obje
        color_drop_out_aggressiveness->cap &= ~SANE_CAP_SOFT_SELECT;
 }
 
-void _kds_s2000w_handler_opts_set_offset_x(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_offset_x(const option_descriptor* descriptor, handler* h, const void* value)
 {
        if (strcmp(descriptor->config_name, IMAGE_OFFSET_X) != 0)
                return;
 
-       int32_t* int_value = (int32_t*) value;
+       const int32_t* int_value = (const int32_t*) value;
        uint32_t tenth_inch = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, *int_value);
        h->coord->offset_x = tenth_inch;
 }
 
-void _kds_s2000w_handler_opts_set_offset_y(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_offset_y(const option_descriptor* descriptor, handler* h, const void* value)
 {
        if (strcmp(descriptor->config_name, IMAGE_OFFSET_Y) != 0)
                return;
 
-       int32_t* int_value = (int32_t*) value;
+       const int32_t* int_value = (const int32_t*) value;
        uint32_t tenth_inch = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, *int_value);
        h->coord->offset_y = tenth_inch;
 }
 
-void _kds_s2000w_handler_opts_set_width(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_width(const option_descriptor* descriptor, handler* h, const void* value)
 {
        if (strcmp(descriptor->config_name, IMAGE_WIDTH) != 0)
                return;
 
-       int32_t* int_value = (int32_t*) value;
+       const int32_t* int_value = (const int32_t*) value;
        uint32_t offset_x_pixel = kds_s2000w_pixel_converter_tenth_inch_to_pixel(GUI_DPI, h->coord->offset_x);
        uint32_t width_pixel = *int_value - offset_x_pixel;
        uint32_t tenth_inch_width = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, width_pixel);
        h->coord->width = tenth_inch_width;
 }
 
-void _kds_s2000w_handler_opts_set_height(option_descriptor* descriptor, handler* h, void* value)
+void _kds_s2000w_handler_opts_set_height(const option_descriptor* descriptor, handler* h, const void* value)
 {
        if (strcmp(descriptor->config_name, IMAGE_HEIGHT) != 0)
                return;
 
-       int32_t* int_value = (int32_t*) value;
+       const int32_t* int_value = (const int32_t*) value;
        uint32_t offset_y_pixel = kds_s2000w_pixel_converter_tenth_inch_to_pixel(GUI_DPI, h->coord->offset_y);
        uint32_t height_pixel = *int_value - offset_y_pixel;
        uint32_t tenth_inch_height = kds_s2000w_pixel_converter_pixel_to_tenth_inch(GUI_DPI, height_pixel);
        h->coord->height = tenth_inch_height;
 }
 
-void _kds_s2000w_handler_opts_set_info_option(option_descriptor* descriptor, int32_t* info) {
+void _kds_s2000w_handler_opts_set_info_option(const option_descriptor* descriptor, int32_t* info) {
        if (info == NULL)
                return;
 
@@ -404,7 +404,7 @@ void _kds_s2000w_handler_opts_set_info_option(option_descriptor* descriptor, int
                *info = RELOAD_OPTIONS | RELOAD_PARAMS;
 }
 
-void _kds_s2000w_handler_opts_set_depends_opts(handler* h,
+void _kds_s2000w_handler_opts_set_depends_opts(const handler* h,
        const char* config_name,
        json_object* config)
 {

diff --git a/src/kds_s2000w_image_converter_netpbm.c b/src/kds_s2000w_image_converter_netpbm.c
index 7ed1288fb50a2d4e6407e52471ca46c23b351db4..6518e9b4df1edb761e84b8b3675a03c4bd94bff6 100644 (file)
--- a/src/kds_s2000w_image_converter_netpbm.c
+++ b/src/kds_s2000w_image_converter_netpbm.c
@@ -27,7 +27,7 @@ typedef struct {
 tsize_t _kds_s2000w_image_converter_tiff_read(thandle_t handler, tdata_t data, tsize_t size)
 {
        tiff_reader* reader = (tiff_reader*) handler;
-       char* imagedata = (char*) reader->image->data;
+       const char* imagedata = (const char*) reader->image->data;
        memcpy(data, &imagedata[reader->curr_offset], size);
        reader->curr_offset += size;
 
@@ -78,16 +78,15 @@ int _kds_s2000w_image_converter_tiff_close(thandle_t handler)
 
 toff_t _kds_s2000w_image_converter_tiff_size(thandle_t handler)
 {
-       tiff_reader* reader = (tiff_reader*) handler;
-
+       const tiff_reader* reader = (const tiff_reader*) handler;
        return reader->curr_offset;
 }
 
-uint32_t _kds_s2000w_image_converter_find_char(blobdata* image, uint32_t start, const char cfind)
+uint32_t _kds_s2000w_image_converter_find_char(const blobdata* image, uint32_t start, const char cfind)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_find_char");
 
-       char* image_data = (char*) image->data;
+       const char* image_data = (const char*) image->data;
 
        for (uint32_t i = start; i < image->size; i++) {
                if (image_data[i] == cfind)
@@ -97,7 +96,7 @@ uint32_t _kds_s2000w_image_converter_find_char(blobdata* image, uint32_t start,
        return 0;
 }
 
-uint32_t _kds_s2000w_image_converter_get_number_from_substring(char* data, uint32_t start, uint32_t end)
+uint32_t _kds_s2000w_image_converter_get_number_from_substring(const char* data, uint32_t start, uint32_t end)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_get_number_from_substring");
 
@@ -137,11 +136,11 @@ void _kds_s2000w_image_converter_tiff_metadata(blobdata* image, image_metadata*
        TIFFClose(tiff);
 }
 
-void _kds_s2000w_image_converter_pnm_metadata(blobdata* image, image_metadata* mdata)
+void _kds_s2000w_image_converter_pnm_metadata(const blobdata* image, image_metadata* mdata)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_converter_pnm_metadata");
 
-       char* image_data = (char*) image->data;
+       const char* image_data = (const char*) image->data;
 
        mdata->depth = 8;
        if (strncmp(image_data, "P4", 2) == 0)
@@ -183,7 +182,7 @@ void _kds_s2000w_image_converter_set_pixels(uint8_t data_byte, bit* pixels)
        }
 }
 
-void _kds_s2000w_image_converter_write_bw_pnm(uint8_t* data,
+void _kds_s2000w_image_converter_write_bw_pnm(const uint8_t* data,
        size_t size,
        uint32_t width,
        uint32_t height,
@@ -215,7 +214,7 @@ void _kds_s2000w_image_converter_write_bw_pnm(uint8_t* data,
        pixels = NULL;
 }
 
-void _kds_s2000w_image_converter_write_pnm(uint8_t* data,
+void _kds_s2000w_image_converter_write_pnm(const uint8_t* data,
        size_t size,
        uint32_t width,
        uint32_t height,

diff --git a/src/kds_s2000w_image_type_check.c b/src/kds_s2000w_image_type_check.c
index 4d56e5698ed6b9df15deca0b14f27db06ebb1536..5ed1f732c278ce5b77e6faff8e0564ba0874be3d 100644 (file)
--- a/src/kds_s2000w_image_type_check.c
+++ b/src/kds_s2000w_image_type_check.c
@@ -2,44 +2,42 @@
 #include "kds_s2000w_debug.h"
 #include "kds_s2000w_image_type_check.h"
 
-bool kds_s2000w_image_type_check_is_tiff(blobdata* image)
+bool kds_s2000w_image_type_check_is_tiff(const blobdata* image)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_tiff");
 
        if (image->size < 4)
                return 0;
 
-       char* image_data = (char*) image->data;
-
+       const char* image_data = (const char*) image->data;
        bool result = image_data[0] == (char)0x49;
        result = result && image_data[1] == (char)0x49;
        result = result && image_data[2] == (char)0x2A;
        return result && image_data[3] == (char)0x00;
 }
 
-bool kds_s2000w_image_type_check_is_pnm(blobdata* image)
+bool kds_s2000w_image_type_check_is_pnm(const blobdata* image)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_pnm");
 
        if (image->size < 2)
                return 0;
 
-       char* image_data = (char*) image->data;
+       const char* image_data = (const char*) image->data;
        if (strncmp(image_data, "P6", 2) == 0)
                return 1;
 
        return strncmp(image_data, "P4", 2) == 0;
 }
 
-bool kds_s2000w_image_type_check_is_jpeg(blobdata* image)
+bool kds_s2000w_image_type_check_is_jpeg(const blobdata* image)
 {
        kds_s2000w_debug_printf(ALL, "kds_s2000w_image_type_check_is_jpeg");
 
        if (image->size < 2)
                return 0;
 
-       char* image_data = (char*) image->data;
-
+       const char* image_data = (const char*) image->data;
        uint8_t result = image_data[0] == (char)0xff;
        return result && image_data[1] == (char)0xd8;
 }
\ No newline at end of file

diff --git a/src/kds_s2000w_image_type_check.h b/src/kds_s2000w_image_type_check.h
index ef46cc67a0b0fd3dff9f202d0c4e7dcd45894fa4..8cbee0b4514248aadba9ea4bdc0858f9693f9f4e 100644 (file)
--- a/src/kds_s2000w_image_type_check.h
+++ b/src/kds_s2000w_image_type_check.h
@@ -3,8 +3,8 @@
 #include <stdbool.h>
 #include "kds_s2000w_image_converter.h"
 
-bool kds_s2000w_image_type_check_is_tiff(blobdata* image);
-bool kds_s2000w_image_type_check_is_pnm(blobdata* image);
-bool kds_s2000w_image_type_check_is_jpeg(blobdata* image);
+bool kds_s2000w_image_type_check_is_tiff(const blobdata* image);
+bool kds_s2000w_image_type_check_is_pnm(const blobdata* image);
+bool kds_s2000w_image_type_check_is_jpeg(const blobdata* image);
 
 #endif
\ No newline at end of file

diff --git a/src/kds_s2000w_net.c b/src/kds_s2000w_net.c
index 89c220476a03d58b4d5ab4bfaffcf234f52c5eb0..6c09425556cfa657a9442b8cb8d00419ca9c4351 100644 (file)
--- a/src/kds_s2000w_net.c
+++ b/src/kds_s2000w_net.c
@@ -104,7 +104,7 @@ void sane_kds_s2000w_net_close(SANE_Handle handle)
 {
        kds_s2000w_debug_printf(ALL, "sane_kds_s2000w_net_close");
 
-       handler* h = (handler*) handle;
+       const handler* h = (const handler*) handle;
        if (h == NULL || h->state != OPENED)
                return;
 
@@ -207,7 +207,7 @@ SANE_Status sane_kds_s2000w_net_read(SANE_Handle handle, SANE_Byte* data,
                return SANE_STATUS_EOF;
        }
 
-       char* image_data = (char*) h->image->data;
+       const char* image_data = (const char*) h->image->data;
        memcpy(data, image_data + h->read_info->read_size, *length);
        h->read_info->read_size += *length;
        return SANE_STATUS_GOOD;
@@ -234,7 +234,7 @@ void sane_kds_s2000w_net_cancel(SANE_Handle handle)
                return;
        }
 
-       if (h->current_scan_status->available_images <= 0) {
+       if (h->current_scan_status->available_images == 0) {
                kds_s2000w_debug_printf(DEBUG, "scan completed no availible images");
                kds_s2000w_handler_reset(h);
                kds_s2000w_handler_recreate_session(h);

diff --git a/tests/kds_s2000w_client_mock.c b/tests/kds_s2000w_client_mock.c
index 2ee325c2e2a50eee77884da919f82348183ef6be..d9228524a2117a7b2dcd21e9c2e74486172856d1 100644 (file)
--- a/tests/kds_s2000w_client_mock.c
+++ b/tests/kds_s2000w_client_mock.c
@@ -6,7 +6,7 @@
 
 void mock_response(response* resp)
 {
-       response* mock_resp = mock_type(response*);
+       const response* mock_resp = mock_type(response*);
        if (mock_resp == NULL)
                return;
 
@@ -102,7 +102,7 @@ void __wrap_kds_s2000w_image_converter_to_pnm(blobdata* in, blobdata* out)
 
 char* __wrap_sanei_config_get_paths(void)
 {
-       char* str = "config_dir_list";
+       const char* str = "config_dir_list";
 
        size_t size = strlen(str) + 1;
        char* cpystr = malloc(size);

diff --git a/tests/kds_s2000w_net_tests.c b/tests/kds_s2000w_net_tests.c
index 455d51577ccf10ee4ed429925b1f5dd7f7635753..6866a63e67c4f05328f6a7705254e55e020f1464 100644 (file)
--- a/tests/kds_s2000w_net_tests.c
+++ b/tests/kds_s2000w_net_tests.c
@@ -23,7 +23,7 @@ int setup(void** state)
        response_list[0] = kds_s2000w_client_response_init();
        response_list[0]->code = 200;
        response_list[1] = kds_s2000w_client_response_init();
-       const char* metadata = "{\
+       const char* metadata_json = "{\
                \"Metadata\": {\
                        \"BitDepth\": 8, \
                        \"ImageSize\": 1, \
@@ -33,7 +33,7 @@ int setup(void** state)
        }";
        response_list[1]->size = 106;
        response_list[1]->data = malloc(response_list[1]->size);
-       memcpy(response_list[1]->data, metadata, response_list[1]->size);
+       memcpy(response_list[1]->data, metadata_json, response_list[1]->size);
        response_list[1]->code = 200;
        response_list[2] = kds_s2000w_client_response_init();
        response_list[2]->code = 200;
@@ -496,7 +496,7 @@ void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state)
        const char* test_config = "{\"Configuration\": { \"ColorMode\": \"Color\" } }";
        h->current_scanner_config = json_tokener_parse(test_config);
 
-       int result = sane_kds_s2000w_net_start(h);
+       sane_kds_s2000w_net_start(h);
 
        const char* status2 = "{ \
                \"Status\": { \
@@ -524,7 +524,7 @@ void sane_kds_s2000w_net_start_two_pages_per_feeder_test(void** state)
        expect_function_call(__wrap_kds_s2000w_client_get_image);
        expect_function_call(__wrap_kds_s2000w_client_delete_image);
        expect_function_call(__wrap_kds_s2000w_client_stop_scan);
-       result = sane_kds_s2000w_net_start(h);
+       int32_t result = sane_kds_s2000w_net_start(h);
 
        assert_int_equal(result, SANE_STATUS_GOOD);
        assert_true(h->current_scan_status->complete_scanned);