switch from tabs to spaces

It was fun while it lasted, but I do believe that spaces are strictly
superior, and clang-format struggles with tabs while using advanced
configuration options.

1 files changed, 169 insertions, 169 deletions

diff --git a/src/sqlite.c b/src/sqlite.c
index 5cb764a..11a9ce8 100644
--- a/src/sqlite.c
+++ b/src/sqlite.c
@@ -17,279 +17,279 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define sqlite_errno(var, fn)                                 \
-	do {                                                  \
-		log_err("%s: %s\n", fn, sqlite3_errstr(var)); \
-		var = -var;                                   \
-	} while (0)
+#define sqlite_errno(var, fn)                         \
+    do {                                              \
+        log_err("%s: %s\n", fn, sqlite3_errstr(var)); \
+        var = -var;                                   \
+    } while (0)
 
-#define sqlite_errno_if(expr, fn)                                \
-	do {                                                     \
-		int CONCAT(ret, __LINE__) = expr;                \
-		if (CONCAT(ret, __LINE__))                       \
-			sqlite_errno(CONCAT(ret, __LINE__), fn); \
-	} while (0)
+#define sqlite_errno_if(expr, fn)                    \
+    do {                                             \
+        int CONCAT(ret, __LINE__) = expr;            \
+        if (CONCAT(ret, __LINE__))                   \
+            sqlite_errno(CONCAT(ret, __LINE__), fn); \
+    } while (0)
 
 int sqlite_init(void) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_initialize();
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_initialize");
-		return ret;
-	}
+    ret = sqlite3_initialize();
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_initialize");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 void sqlite_destroy(void) {
-	sqlite_errno_if(sqlite3_shutdown(), "sqlite3_shutdown");
+    sqlite_errno_if(sqlite3_shutdown(), "sqlite3_shutdown");
 }
 
 static int sqlite_open(const char* path, sqlite3** db, int flags) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_open_v2(path, db, flags, NULL);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_open_v2");
-		return ret;
-	}
+    ret = sqlite3_open_v2(path, db, flags, NULL);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_open_v2");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 int sqlite_open_rw(const char* path, sqlite3** db) {
-	static const int flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
-	return sqlite_open(path, db, flags);
+    static const int flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_READWRITE;
+    return sqlite_open(path, db, flags);
 }
 
 int sqlite_open_ro(const char* path, sqlite3** db) {
-	static const int flags = SQLITE_OPEN_READONLY;
-	return sqlite_open(path, db, flags);
+    static const int flags = SQLITE_OPEN_READONLY;
+    return sqlite_open(path, db, flags);
 }
 
 void sqlite_close(sqlite3* db) {
-	sqlite_errno_if(sqlite3_close(db), "sqlite3_close");
+    sqlite_errno_if(sqlite3_close(db), "sqlite3_close");
 }
 
 int sqlite_exec(sqlite3* db, const char* stmt, sqlite3_callback callback, void* arg) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_exec(db, stmt, callback, arg, NULL);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_exec");
-		return ret;
-	}
+    ret = sqlite3_exec(db, stmt, callback, arg, NULL);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_exec");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 int sqlite_exec_log_result(UNUSED void* arg,
                            int numof_columns,
                            char** values,
                            char** column_names) {
-	log("Row:\n");
-	for (int i = 0; i < numof_columns; ++i) {
-		log("\t%s: %s\n", column_names[i], values[i]);
-	}
-	return 0;
+    log("Row:\n");
+    for (int i = 0; i < numof_columns; ++i) {
+        log("\t%s: %s\n", column_names[i], values[i]);
+    }
+    return 0;
 }
 
 int sqlite_prepare(sqlite3* db, const char* stmt, sqlite3_stmt** result) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_prepare_v2(db, stmt, -1, result, NULL);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_prepare_v2");
-		return ret;
-	}
+    ret = sqlite3_prepare_v2(db, stmt, -1, result, NULL);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_prepare_v2");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 void sqlite_reset(sqlite3_stmt* stmt) {
-	sqlite_errno_if(sqlite3_reset(stmt), "sqlite3_reset");
-	sqlite_errno_if(sqlite3_clear_bindings(stmt), "sqlite3_clear_bindings");
+    sqlite_errno_if(sqlite3_reset(stmt), "sqlite3_reset");
+    sqlite_errno_if(sqlite3_clear_bindings(stmt), "sqlite3_clear_bindings");
 }
 
 void sqlite_finalize(sqlite3_stmt* stmt) {
-	sqlite_errno_if(sqlite3_finalize(stmt), "sqlite3_finalize");
+    sqlite_errno_if(sqlite3_finalize(stmt), "sqlite3_finalize");
 }
 
 int sqlite_step(sqlite3_stmt* stmt) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_step(stmt);
+    ret = sqlite3_step(stmt);
 
-	switch (ret) {
-		case SQLITE_ROW:
-			return 1;
-		case SQLITE_DONE:
-			return 0;
+    switch (ret) {
+        case SQLITE_ROW:
+            return 1;
+        case SQLITE_DONE:
+            return 0;
 
-		default:
-			sqlite_errno(ret, "sqlite3_step");
-			return ret;
-	}
+        default:
+            sqlite_errno(ret, "sqlite3_step");
+            return ret;
+    }
 }
 
 int sqlite_column_int(sqlite3_stmt* stmt, int index) {
-	return sqlite3_column_int(stmt, index);
+    return sqlite3_column_int(stmt, index);
 }
 
 int sqlite_column_text(sqlite3_stmt* stmt, int index, char** _result) {
-	int ret = 0;
+    int ret = 0;
 
-	const unsigned char* value = sqlite3_column_text(stmt, index);
-	if (!value) {
-		ret = sqlite3_errcode(sqlite3_db_handle(stmt));
-		if (ret) {
-			sqlite_errno(ret, "sqlite3_column_text");
-			return ret;
-		}
+    const unsigned char* value = sqlite3_column_text(stmt, index);
+    if (!value) {
+        ret = sqlite3_errcode(sqlite3_db_handle(stmt));
+        if (ret) {
+            sqlite_errno(ret, "sqlite3_column_text");
+            return ret;
+        }
 
-		*_result = NULL;
-		return 0;
-	}
+        *_result = NULL;
+        return 0;
+    }
 
-	ret = sqlite3_column_bytes(stmt, index);
-	size_t nb = (size_t)ret;
+    ret = sqlite3_column_bytes(stmt, index);
+    size_t nb = (size_t)ret;
 
-	char* result = calloc(nb + 1, 1);
-	if (!result) {
-		log_errno("calloc");
-		return -1;
-	}
-	memcpy(result, value, nb);
+    char* result = calloc(nb + 1, 1);
+    if (!result) {
+        log_errno("calloc");
+        return -1;
+    }
+    memcpy(result, value, nb);
 
-	*_result = result;
-	return 0;
+    *_result = result;
+    return 0;
 }
 
 int sqlite_column_blob(sqlite3_stmt* stmt, int index, unsigned char** _result) {
-	int ret = 0;
+    int ret = 0;
 
-	const unsigned char* value = sqlite3_column_blob(stmt, index);
-	if (!value) {
-		ret = sqlite3_errcode(sqlite3_db_handle(stmt));
-		if (ret) {
-			sqlite_errno(ret, "sqlite3_column_text");
-			return ret;
-		}
+    const unsigned char* value = sqlite3_column_blob(stmt, index);
+    if (!value) {
+        ret = sqlite3_errcode(sqlite3_db_handle(stmt));
+        if (ret) {
+            sqlite_errno(ret, "sqlite3_column_text");
+            return ret;
+        }
 
-		*_result = NULL;
-		return 0;
-	}
+        *_result = NULL;
+        return 0;
+    }
 
-	ret = sqlite3_column_bytes(stmt, index);
-	size_t nb = (size_t)ret;
+    ret = sqlite3_column_bytes(stmt, index);
+    size_t nb = (size_t)ret;
 
-	unsigned char* result = malloc(nb);
-	if (!result) {
-		log_errno("malloc");
-		return -1;
-	}
-	memcpy(result, value, nb);
+    unsigned char* result = malloc(nb);
+    if (!result) {
+        log_errno("malloc");
+        return -1;
+    }
+    memcpy(result, value, nb);
 
-	*_result = result;
-	return 0;
+    *_result = result;
+    return 0;
 }
 
 int sqlite_bind_int(sqlite3_stmt* stmt, int index, int value) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_bind_int(stmt, index, value);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_bind_int");
-		return ret;
-	}
+    ret = sqlite3_bind_int(stmt, index, value);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_bind_int");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 int sqlite_bind_text(sqlite3_stmt* stmt, int index, const char* value) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_bind_text(stmt, index, value, -1, SQLITE_STATIC);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_bind_text");
-		return ret;
-	}
+    ret = sqlite3_bind_text(stmt, index, value, -1, SQLITE_STATIC);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_bind_text");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 int sqlite_bind_blob(sqlite3_stmt* stmt, int index, unsigned char* value, size_t nb) {
-	int ret = 0;
+    int ret = 0;
 
-	ret = sqlite3_bind_blob64(stmt, index, value, nb, SQLITE_STATIC);
-	if (ret) {
-		sqlite_errno(ret, "sqlite3_bind_blob64");
-		return ret;
-	}
+    ret = sqlite3_bind_blob64(stmt, index, value, nb, SQLITE_STATIC);
+    if (ret) {
+        sqlite_errno(ret, "sqlite3_bind_blob64");
+        return ret;
+    }
 
-	return ret;
+    return ret;
 }
 
 int sqlite_exec_as_transaction(sqlite3* db, const char* stmt) {
-	static const char* const fmt = "BEGIN; %s COMMIT;";
-	int ret = 0;
+    static const char* const fmt = "BEGIN; %s COMMIT;";
+    int ret = 0;
 
-	ret = snprintf(NULL, 0, fmt, stmt);
-	size_t nb = (size_t)ret + 1;
-	ret = 0;
+    ret = snprintf(NULL, 0, fmt, stmt);
+    size_t nb = (size_t)ret + 1;
+    ret = 0;
 
-	char* full_stmt = malloc(nb);
-	if (!full_stmt) {
-		log_errno("malloc");
-		return -1;
-	}
-	snprintf(full_stmt, nb, fmt, stmt);
+    char* full_stmt = malloc(nb);
+    if (!full_stmt) {
+        log_errno("malloc");
+        return -1;
+    }
+    snprintf(full_stmt, nb, fmt, stmt);
 
-	ret = sqlite_exec(db, stmt, NULL, NULL);
-	goto free;
+    ret = sqlite_exec(db, stmt, NULL, NULL);
+    goto free;
 
 free:
-	free(full_stmt);
+    free(full_stmt);
 
-	return ret;
+    return ret;
 }
 
 int sqlite_get_user_version(sqlite3* db, unsigned int* output) {
-	static const char* const sql = "PRAGMA user_version;";
+    static const char* const sql = "PRAGMA user_version;";
 
-	sqlite3_stmt* stmt = NULL;
-	int result = -1, ret = 0;
+    sqlite3_stmt* stmt = NULL;
+    int result = -1, ret = 0;
 
-	ret = sqlite_prepare(db, sql, &stmt);
-	if (ret < 0)
-		return ret;
-	ret = sqlite_step(stmt);
-	if (ret < 0)
-		goto finalize;
-	if (!ret) {
-		ret = -1;
-		log_err("Failed to read database version\n");
-		goto finalize;
-	}
+    ret = sqlite_prepare(db, sql, &stmt);
+    if (ret < 0)
+        return ret;
+    ret = sqlite_step(stmt);
+    if (ret < 0)
+        goto finalize;
+    if (!ret) {
+        ret = -1;
+        log_err("Failed to read database version\n");
+        goto finalize;
+    }
 
-	result = sqlite_column_int(stmt, 0);
-	if (result < 0) {
-		log_err("Invalid database version: %d\n", result);
-		ret = -1;
-		goto finalize;
-	}
-	*output = (unsigned int)result;
+    result = sqlite_column_int(stmt, 0);
+    if (result < 0) {
+        log_err("Invalid database version: %d\n", result);
+        ret = -1;
+        goto finalize;
+    }
+    *output = (unsigned int)result;
 
-	goto finalize;
+    goto finalize;
 
 finalize:
-	sqlite_finalize(stmt);
+    sqlite_finalize(stmt);
 
-	return ret;
+    return ret;
 }
 
 int sqlite_set_foreign_keys(sqlite3* db) {
-	static const char* const sql = "PRAGMA foreign_keys = ON;";
-	return sqlite_exec(db, sql, NULL, NULL);
+    static const char* const sql = "PRAGMA foreign_keys = ON;";
+    return sqlite_exec(db, sql, NULL, NULL);
 }