[Qemu-devel] [PATCH 6/7] cutils: Normalize qemu_strto[u]ll() signature

["Andreas Färber" <afaerber@suse.de>]

Instead of using int64_t for qemu_strtoll() and uiint64_t for
qemu_strtoull(), use long long and unsigned long long as their name
implies.

The only affected callers are our test cases.

This prepares for following checkpatch's recommendation of using it more,
by making it easier to switch from POSIX to QEMU versions.
Remaining difference is const-ness.

Signed-off-by: Andreas Färber <afaerber@suse.de>
---
 include/qemu-common.h |  4 +--
 tests/test-cutils.c   | 76 +++++++++++++++++++++++++--------------------------
 util/cutils.c         |  4 +--
 3 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/include/qemu-common.h b/include/qemu-common.h
index 01d29dd..2575152 100644
--- a/include/qemu-common.h
+++ b/include/qemu-common.h
@@ -208,9 +208,9 @@ int qemu_strtol(const char *nptr, const char **endptr, int base,
 int qemu_strtoul(const char *nptr, const char **endptr, int base,
                  unsigned long *result);
 int qemu_strtoll(const char *nptr, const char **endptr, int base,
-                 int64_t *result);
+                 long long *result);
 int qemu_strtoull(const char *nptr, const char **endptr, int base,
-                  uint64_t *result);
+                  unsigned long long *result);
 
 int parse_uint(const char *s, unsigned long long *value, char **endptr,
                int base);
diff --git a/tests/test-cutils.c b/tests/test-cutils.c
index 0046c61..f00150e 100644
--- a/tests/test-cutils.c
+++ b/tests/test-cutils.c
@@ -794,7 +794,7 @@ static void test_qemu_strtoll_correct(void)
     const char *str = "12345 foo";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -808,7 +808,7 @@ static void test_qemu_strtoll_null(void)
 {
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(NULL, &endptr, 0, &res);
@@ -822,7 +822,7 @@ static void test_qemu_strtoll_empty(void)
     const char *str = "";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -835,7 +835,7 @@ static void test_qemu_strtoll_whitespace(void)
     const char *str = "  \t  ";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -848,7 +848,7 @@ static void test_qemu_strtoll_invalid(void)
     const char *str = "   xxxx  \t abc";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -861,7 +861,7 @@ static void test_qemu_strtoll_trailing(void)
     const char *str = "123xxx";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -876,7 +876,7 @@ static void test_qemu_strtoll_octal(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 8, &res);
@@ -899,7 +899,7 @@ static void test_qemu_strtoll_decimal(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 10, &res);
@@ -923,7 +923,7 @@ static void test_qemu_strtoll_hex(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 16, &res);
@@ -947,7 +947,7 @@ static void test_qemu_strtoll_max(void)
     const char *str = g_strdup_printf("%lld", LLONG_MAX);
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -962,7 +962,7 @@ static void test_qemu_strtoll_overflow(void)
     const char *str = "99999999999999999999999999999999999999999999";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -977,7 +977,7 @@ static void test_qemu_strtoll_underflow(void)
     const char *str = "-99999999999999999999999999999999999999999999";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err  = qemu_strtoll(str, &endptr, 0, &res);
@@ -992,7 +992,7 @@ static void test_qemu_strtoll_negative(void)
     const char *str = "  \t -321";
     char f = 'X';
     const char *endptr = &f;
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, &endptr, 0, &res);
@@ -1005,7 +1005,7 @@ static void test_qemu_strtoll_negative(void)
 static void test_qemu_strtoll_full_correct(void)
 {
     const char *str = "123";
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, NULL, 0, &res);
@@ -1016,7 +1016,7 @@ static void test_qemu_strtoll_full_correct(void)
 
 static void test_qemu_strtoll_full_null(void)
 {
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(NULL, NULL, 0, &res);
@@ -1027,7 +1027,7 @@ static void test_qemu_strtoll_full_null(void)
 static void test_qemu_strtoll_full_empty(void)
 {
     const char *str = "";
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, NULL, 0, &res);
@@ -1038,7 +1038,7 @@ static void test_qemu_strtoll_full_empty(void)
 static void test_qemu_strtoll_full_negative(void)
 {
     const char *str = " \t -321";
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, NULL, 0, &res);
@@ -1050,7 +1050,7 @@ static void test_qemu_strtoll_full_negative(void)
 static void test_qemu_strtoll_full_trailing(void)
 {
     const char *str = "123xxx";
-    int64_t res = 999;
+    long long res = 999;
     int err;
 
     err = qemu_strtoll(str, NULL, 0, &res);
@@ -1062,7 +1062,7 @@ static void test_qemu_strtoll_full_max(void)
 {
 
     const char *str = g_strdup_printf("%lld", LLONG_MAX);
-    int64_t res;
+    long long res;
     int err;
 
     err = qemu_strtoll(str, NULL, 0, &res);
@@ -1076,7 +1076,7 @@ static void test_qemu_strtoull_correct(void)
     const char *str = "12345 foo";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1090,7 +1090,7 @@ static void test_qemu_strtoull_null(void)
 {
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(NULL, &endptr, 0, &res);
@@ -1104,7 +1104,7 @@ static void test_qemu_strtoull_empty(void)
     const char *str = "";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1117,7 +1117,7 @@ static void test_qemu_strtoull_whitespace(void)
     const char *str = "  \t  ";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1130,7 +1130,7 @@ static void test_qemu_strtoull_invalid(void)
     const char *str = "   xxxx  \t abc";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1143,7 +1143,7 @@ static void test_qemu_strtoull_trailing(void)
     const char *str = "123xxx";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1158,7 +1158,7 @@ static void test_qemu_strtoull_octal(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 8, &res);
@@ -1181,7 +1181,7 @@ static void test_qemu_strtoull_decimal(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 10, &res);
@@ -1205,7 +1205,7 @@ static void test_qemu_strtoull_hex(void)
     const char *str = "0123";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 16, &res);
@@ -1229,7 +1229,7 @@ static void test_qemu_strtoull_max(void)
     const char *str = g_strdup_printf("%llu", ULLONG_MAX);
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1244,7 +1244,7 @@ static void test_qemu_strtoull_overflow(void)
     const char *str = "99999999999999999999999999999999999999999999";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1259,7 +1259,7 @@ static void test_qemu_strtoull_underflow(void)
     const char *str = "-99999999999999999999999999999999999999999999";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err  = qemu_strtoull(str, &endptr, 0, &res);
@@ -1274,7 +1274,7 @@ static void test_qemu_strtoull_negative(void)
     const char *str = "  \t -321";
     char f = 'X';
     const char *endptr = &f;
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, &endptr, 0, &res);
@@ -1287,7 +1287,7 @@ static void test_qemu_strtoull_negative(void)
 static void test_qemu_strtoull_full_correct(void)
 {
     const char *str = "18446744073709551614";
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, NULL, 0, &res);
@@ -1298,7 +1298,7 @@ static void test_qemu_strtoull_full_correct(void)
 
 static void test_qemu_strtoull_full_null(void)
 {
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(NULL, NULL, 0, &res);
@@ -1309,7 +1309,7 @@ static void test_qemu_strtoull_full_null(void)
 static void test_qemu_strtoull_full_empty(void)
 {
     const char *str = "";
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, NULL, 0, &res);
@@ -1320,7 +1320,7 @@ static void test_qemu_strtoull_full_empty(void)
 static void test_qemu_strtoull_full_negative(void)
 {
     const char *str = " \t -321";
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, NULL, 0, &res);
@@ -1332,7 +1332,7 @@ static void test_qemu_strtoull_full_negative(void)
 static void test_qemu_strtoull_full_trailing(void)
 {
     const char *str = "18446744073709551614xxxxxx";
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, NULL, 0, &res);
@@ -1343,7 +1343,7 @@ static void test_qemu_strtoull_full_trailing(void)
 static void test_qemu_strtoull_full_max(void)
 {
     const char *str = g_strdup_printf("%lld", ULLONG_MAX);
-    uint64_t res = 999;
+    unsigned long long res = 999;
     int err;
 
     err = qemu_strtoull(str, NULL, 0, &res);
diff --git a/util/cutils.c b/util/cutils.c
index ae35198..9e865df 100644
--- a/util/cutils.c
+++ b/util/cutils.c
@@ -459,7 +459,7 @@ int qemu_strtoul(const char *nptr, const char **endptr, int base,
  * See qemu_strtol() documentation for more info.
  */
 int qemu_strtoll(const char *nptr, const char **endptr, int base,
-                 int64_t *result)
+                 long long *result)
 {
     char *p;
     int err = 0;
@@ -482,7 +482,7 @@ int qemu_strtoll(const char *nptr, const char **endptr, int base,
  * See qemu_strtol() documentation for more info.
  */
 int qemu_strtoull(const char *nptr, const char **endptr, int base,
-                  uint64_t *result)
+                  unsigned long long *result)
 {
     char *p;
     int err = 0;
-- 
2.1.4