Replaced all %lld (except one)

Author: marcobambini

src/cloudsync.c

@@ -1739,7 +1739,7 @@ int cloudsync_finalize_alter (cloudsync_context *data, cloudsync_table_context *
 
     // update key to be later used in cloudsync_dbversion_rebuild
     char buf[256];
-    snprintf(buf, sizeof(buf), "%lld", data->db_version);
+    snprintf(buf, sizeof(buf), "%" PRId64, data->db_version);
     dbutils_settings_set_key_value(db, NULL, "pre_alter_dbversion", buf);
 
 finalize:
@@ -2310,7 +2310,7 @@ int cloudsync_payload_apply (cloudsync_context *data, const char *payload, int b
             if (rc != DBRES_DONE) {
                 // don't "break;", the error can be due to a RLS policy.
                 // in case of error we try to apply the following changes
-                // printf("cloudsync_payload_apply error on db_version %lld/%lld: (%d) %s\n", decoded_context.db_version, decoded_context.seq, rc, database_errmsg(db));
+                // printf("cloudsync_payload_apply error on db_version %PRId64/%PRId64: (%d) %s\n", decoded_context.db_version, decoded_context.seq, rc, database_errmsg(db));
             }
         }
 
@@ -2341,11 +2341,11 @@ int cloudsync_payload_apply (cloudsync_context *data, const char *payload, int b
     if (rc == DBRES_OK) {
         char buf[256];
         if (decoded_context.db_version >= dbversion) {
-            snprintf(buf, sizeof(buf), "%lld", decoded_context.db_version);
+            snprintf(buf, sizeof(buf), "%" PRId64, decoded_context.db_version);
             dbutils_settings_set_key_value(db, NULL, CLOUDSYNC_KEY_CHECK_DBVERSION, buf);
 
             if (decoded_context.seq != seq) {
-                snprintf(buf, sizeof(buf), "%lld", decoded_context.seq);
+                snprintf(buf, sizeof(buf), "%" PRId64, decoded_context.seq);
                 dbutils_settings_set_key_value(db, NULL, CLOUDSYNC_KEY_CHECK_SEQ, buf);
             }
         }
@@ -2428,11 +2428,11 @@ int cloudsync_payload_save (cloudsync_context *data, const char *payload_path, i
     char buf[256];
     db_t *db = data->db;
     if (new_db_version != db_version) {
-        snprintf(buf, sizeof(buf), "%lld", new_db_version);
+        snprintf(buf, sizeof(buf), "%" PRId64, new_db_version);
         dbutils_settings_set_key_value(db, NULL, CLOUDSYNC_KEY_SEND_DBVERSION, buf);
     }
     if (new_seq != seq) {
-        snprintf(buf, sizeof(buf), "%lld", new_seq);
+        snprintf(buf, sizeof(buf), "%" PRId64, new_seq);
         dbutils_settings_set_key_value(db, NULL, CLOUDSYNC_KEY_SEND_SEQ, buf);
     }
 

src/database_sqlite.c

@@ -11,6 +11,7 @@
 #include "utils.h"
 #include "sql.h"
 
+#include <inttypes.h>
 #include <string.h>
 #include <stdlib.h>
 
@@ -547,7 +548,7 @@ bool database_check_schema_hash (db_t *db, uint64_t hash) {
     // the idea is to allow changes on stale peers and to be able to apply these changes on peers with newer schema,
     // but it requires alter table operation on augmented tables only add new columns and never drop columns for backward compatibility
     char sql[1024];
-    snprintf(sql, sizeof(sql), "SELECT 1 FROM cloudsync_schema_versions WHERE hash = (%lld)", hash);
+    snprintf(sql, sizeof(sql), "SELECT 1 FROM cloudsync_schema_versions WHERE hash = (%" PRId64 ")", hash);
 
     int64_t value = 0;
     database_select_int(db, sql, &value);
@@ -570,9 +571,9 @@ int database_update_schema_hash (db_t *db, uint64_t *hash) {
 
     char sql[1024];
     snprintf(sql, sizeof(sql), "INSERT INTO cloudsync_schema_versions (hash, seq) "
-                               "VALUES (%lld, COALESCE((SELECT MAX(seq) FROM cloudsync_schema_versions), 0) + 1) "
+                               "VALUES (%" PRId64 ", COALESCE((SELECT MAX(seq) FROM cloudsync_schema_versions), 0) + 1) "
                                "ON CONFLICT(hash) DO UPDATE SET "
-                               "seq = (SELECT COALESCE(MAX(seq), 0) + 1 FROM cloudsync_schema_versions);", (long long)h);
+                               "seq = (SELECT COALESCE(MAX(seq), 0) + 1 FROM cloudsync_schema_versions);", h);
     rc = database_exec(db, sql);
     if (rc == SQLITE_OK && hash) *hash = h;
     return rc;

src/dbutils.c

@@ -6,6 +6,8 @@
 //
 
 #include <stdlib.h>
+#include <inttypes.h>
+
 #include "sql.h"
 #include "utils.h"
 #include "dbutils.h"
@@ -71,7 +73,7 @@ int dbutils_value_compare (dbvalue_t *lvalue, dbvalue_t *rvalue) {
 void dbutils_debug_value (dbvalue_t *value) {
     switch (database_value_type(value)) {
         case DBTYPE_INTEGER:
-            printf("\t\tINTEGER: %lld\n", database_value_int(value));
+            printf("\t\tINTEGER: %" PRId64 "\n", database_value_int(value));
             break;
         case DBTYPE_FLOAT:
             printf("\t\tFLOAT: %f\n", database_value_double(value));

src/network.c

@@ -682,8 +682,7 @@ void cloudsync_network_set_apikey (sqlite3_context *context, int argc, sqlite3_v
 void cloudsync_network_has_unsent_changes (sqlite3_context *context, int argc, sqlite3_value **argv) {
     sqlite3 *db = sqlite3_context_db_handle(context);
 
-    // TODO: why hex(site_id) here if only one int column is returned?
-    char *sql = "SELECT max(db_version), hex(site_id) FROM cloudsync_changes WHERE site_id == (SELECT site_id FROM cloudsync_site_id WHERE rowid=0)";
+    char *sql = "SELECT max(db_version) FROM cloudsync_changes WHERE site_id == (SELECT site_id FROM cloudsync_site_id WHERE rowid=0)";
     int64_t last_local_change = 0;
     int rc = database_select_int(db, sql, &last_local_change);
     if (rc != DBRES_OK) {
@@ -759,11 +758,11 @@ int cloudsync_network_send_changes_internal (sqlite3_context *context, int argc,
     char buf[256];
     sqlite3 *db = sqlite3_context_db_handle(context);
     if (new_db_version != db_version) {
-        snprintf(buf, sizeof(buf), "%lld", new_db_version);
+        snprintf(buf, sizeof(buf), "%" PRId64, new_db_version);
         dbutils_settings_set_key_value(db, data, CLOUDSYNC_KEY_SEND_DBVERSION, buf);
     }
     if (new_seq != seq) {
-        snprintf(buf, sizeof(buf), "%lld", new_seq);
+        snprintf(buf, sizeof(buf), "%" PRId64, new_seq);
         dbutils_settings_set_key_value(db, data, CLOUDSYNC_KEY_SEND_SEQ, buf);
     }
 
@@ -793,7 +792,7 @@ int cloudsync_network_check_internal(sqlite3_context *context, int *pnrows) {
     // http://uuid.g5.sqlite.cloud/v1/cloudsync/{dbname}/{site_id}/{db_version}/{seq}/check
     // the data->check_endpoint stops after {site_id}, just need to append /{db_version}/{seq}/check
     char endpoint[2024];
-    snprintf(endpoint, sizeof(endpoint), "%s/%lld/%d/%s", data->check_endpoint, (long long)db_version, seq, CLOUDSYNC_ENDPOINT_CHECK);
+    snprintf(endpoint, sizeof(endpoint), "%s/%" PRId64 "/%d/%s", data->check_endpoint, db_version, seq, CLOUDSYNC_ENDPOINT_CHECK);
 
     NETWORK_RESULT result = network_receive_buffer(data, endpoint, data->authentication, true, true, NULL, CLOUDSYNC_HEADER_SQLITECLOUD);
     int rc = SQLITE_OK;

src/pk.c

@@ -7,6 +7,7 @@
 
 #include "pk.h"
 #include "utils.h"
+#include <inttypes.h>
 
 /*
  
@@ -110,7 +111,7 @@ int pk_decode_bind_callback (void *xdata, int index, int type, int64_t ival, dou
 int pk_decode_print_callback (void *xdata, int index, int type, int64_t ival, double dval, char *pval) {
     switch (type) {
         case DBTYPE_INTEGER:
-            printf("%d\tINTEGER:\t%lld\n", index, (long long)ival);
+            printf("%d\tINTEGER:\t%" PRId64 "\n", index, ival);
             break;
 
         case DBTYPE_FLOAT:
@@ -126,7 +127,7 @@ int pk_decode_print_callback (void *xdata, int index, int type, int64_t ival, do
             break;
 
         case DBTYPE_BLOB:
-            printf("%d\tBLOB:\t%lld bytes\n", index, (long long)ival);
+            printf("%d\tBLOB:\t%" PRId64 " bytes\n", index, ival);
             break;
     }
 

src/utils.c

@@ -586,7 +586,7 @@ void memdebug_finalize (void) {
 void *memdebug_alloc (uint64_t size) {
     void *ptr = dbmem_alloc(size);
     if (!ptr) {
-        BUILD_ERROR("Unable to allocated a block of %lld bytes", size);
+        BUILD_ERROR("Unable to allocated a block of %" PRIu64" bytes", size);
         BUILD_STACK(n, stack);
         memdebug_report(current_error, stack, n, NULL);
         return NULL;
@@ -617,7 +617,7 @@ void *memdebug_realloc (void *ptr, uint64_t new_size) {
     void *back_ptr = ptr;
     void *new_ptr = dbmem_realloc(ptr, new_size);
     if (!new_ptr) {
-        BUILD_ERROR("Unable to reallocate a block of %lld bytes.", new_size);
+        BUILD_ERROR("Unable to reallocate a block of %" PRIu64 " bytes.", new_size);
         BUILD_STACK(n, stack);
         memdebug_report(current_error, stack, n, slot);
         return NULL;

test/unit.c

@@ -10,6 +10,7 @@
 #include <string.h>
 #include <stdlib.h>
 #include <stdbool.h>
+#include <inttypes.h>
 #include <fcntl.h>
 #include "sqlite3.h"
 
@@ -1108,12 +1109,12 @@ bool do_test_functions (sqlite3 *db, bool print_results) {
     int64_t db_version = 0;
     rc = database_select_int(db, "SELECT cloudsync_db_version();", &db_version);
     if (rc != DBRES_OK) goto abort_test_functions;
-    if (print_results) printf("DB Version: %lld\n", db_version);
+    if (print_results) printf("DB Version: %" PRId64 "\n", db_version);
 
     int64_t db_version_next = 0;
     rc = database_select_int(db, "SELECT cloudsync_db_version_next();", &db_version);
     if (rc != DBRES_OK) goto abort_test_functions;
-    if (print_results) printf("DB Version Next: %lld\n", db_version_next);
+    if (print_results) printf("DB Version Next: %" PRId64 "\n", db_version_next);
 
     rc = sqlite3_exec(db, "CREATE TABLE tbl1 (col1 TEXT PRIMARY KEY NOT NULL, col2);", NULL, NULL, NULL);
     if (rc != SQLITE_OK) goto abort_test_functions;
@@ -1472,7 +1473,7 @@ bool do_test_pk_single_value (sqlite3 *db, int type, int64_t ivalue, double dval
 
     pklist[0].type = type;
     if (type == SQLITE_INTEGER) {
-        snprintf(sql, sizeof(sql), "SELECT cloudsync_pk_encode(%lld);", ivalue);
+        snprintf(sql, sizeof(sql), "SELECT cloudsync_pk_encode(%" PRId64 ");", ivalue);
         pklist[0].ivalue = ivalue;
     } else if (type == SQLITE_FLOAT) {
         snprintf(sql, sizeof(sql), "SELECT cloudsync_pk_encode(%f);", dvalue);
@@ -6289,10 +6290,10 @@ int main (int argc, const char * argv[]) {
 
     cloudsync_memory_finalize();
 
-    sqlite3_int64 memory_used = sqlite3_memory_used();
+    int64_t memory_used = (int64_t)sqlite3_memory_used();
     result += test_report("Memory Leaks Check:", memory_used == 0);
     if (memory_used > 0) {
-        printf("\tleaked: %lld B\n", memory_used);
+        printf("\tleaked: %" PRId64 " B\n", memory_used);
         result++;
     }