Delivered-To: mlmmj-tyndur-devel
Received: from sv1.famkaufmann.info [176.9.73.67]
	by a9b8c5461646 with IMAP (fetchmail-6.3.26)
	for <mlmmj@localhost> (single-drop); Thu, 04 Mar 2021 19:49:19 +0000 (GMT)
Received: from localhost ([172.29.0.7])
	by sv1.famkaufmann.info with LMTP
	id 8GmQH6I5QWBDSwAALHnFKQ
	(envelope-from <mayernico256@gmail.com>)
	for <mlmmj-tyndur-devel>; Thu, 04 Mar 2021 19:48:50 +0000
Delivered-To: tyndur-devel@tyndur.org
X-Spam: yes
X-Spam-Score: 6.1 / 150
X-Spam-Status: Yes, score=6.100 required=150.000
	tests=[ARC_NA=0.000, ASN=0.000, BAD_REP_POLICIES=0.100
	BROKEN_CONTENT_TYPE=1.500, DKIM_TRACE=0.000, DMARC_POLICY_ALLOW=0.000
	DWL_DNSWL_NONE=0.000, FREEMAIL_ENVFROM=0.000, FREEMAIL_FROM=0.000
	FROM_EQ_ENVFROM=0.000, FROM_HAS_DN=0.000, MID_CONTAINS_FROM=1.000
	MIME_TRACE=0.000, PREVIOUSLY_DELIVERED=0.000, RBL_SEM_IPV6=1.000
	RCPT_COUNT_ONE=0.000, RCVD_COUNT_THREE=0.000, RCVD_IN_DNSWL_NONE=0.000
	RCVD_TLS_ALL=0.000, RCVD_VIA_SMTP_AUTH=0.000
	RECEIVED_SPAMHAUS_PBL=0.000, R_DKIM_ALLOW=0.000
	R_MISSING_CHARSET=2.500, R_SPF_ALLOW=0.000, TO_DN_NONE=0.000
	TO_MATCH_ENVRCPT_ALL=0.000]
Received: from mail-ed1-x533.google.com (mail-ed1-x533.google.com [2a00:1450:4864:20::533])
	by sv1.famkaufmann.info (OpenSMTPD) with ESMTPS id ccd99e78 (TLSv1.3:TLS_AES_256_GCM_SHA384:256:NO)
	for <tyndur-devel@tyndur.org>;
	Thu, 4 Mar 2021 19:48:50 +0000 (UTC)
Received: by mail-ed1-x533.google.com with SMTP id m9so7985480edd.5
        for <tyndur-devel@tyndur.org>; Thu, 04 Mar 2021 11:48:50 -0800 (PST)
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=gmail.com; s=20161025;
        h=from:to:subject:date:message-id:mime-version
         :content-transfer-encoding;
        bh=L8FMxKda+5PQMhCYF1TYjXgfabLIe2WCHMXM0VrYP7Y=;
        b=mAX58CZWy0fUzozXoUtOWZ7dg/XrDkTS4agP238AFg4eS2bQFFMmxqGpAOKcG2hjH8
         JOa4uKgorAvWSttgsIEtJFkONAJ50uLNolHt6dpMEuSI5YzOU97YSoGwkoCrxsvX8+HL
         uwdggY9XF/8FQYL1tKcsdMS8kt6/wxkyooR6XydjWl5/3+7KFYxWhXDc2TEPCvwfCxun
         9ir7ru4hvgS12CJEmc+vNYlA8jfPwRHGX+0DGo2y3dKrUpOizYxVYGt2aSikDJlG4YY4
         BI5YY+xPXsV8eP69JtAvtIg3gzxelRC+UIcaBUZ+1Bl3xoEBWcIjZFgYoPr+Tf9XKGYe
         7eQA==
X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed;
        d=1e100.net; s=20161025;
        h=x-gm-message-state:from:to:subject:date:message-id:mime-version
         :content-transfer-encoding;
        bh=L8FMxKda+5PQMhCYF1TYjXgfabLIe2WCHMXM0VrYP7Y=;
        b=RzITejFlTUi/PBquia9RLtzPSZ8RMQJt1jpPOOzpBfXZifutptTDIVe8bEzY22zo+7
         Hmm+8k1JM/Mz5J0xlixpcaxE1pYRatL0xTVaWffBT1sPG/78cAyxIQun3J5ewLDkhya6
         sycmDIll5QG1v6zjZ50CsSbG8CsCxL5XD7YrYVAfe0agNUQZVsjE2+Ynyy0IeCg9dVP8
         180Di3veM4owri9YXnFAvMxHg0fMyUWA7y/yDVpH+mOIgQUtCf2TD4PpWG3UreBoRfU+
         BI6WXAKFFW2rcxs2A3OaeRHXtCkVFIpP0oJseVqWGitsdCP78J84vPhEvgZdFkwESyhp
         HN6Q==
X-Gm-Message-State: AOAM531PMBjn5KlSBuMEtDvFePa7U2dI6l80gF0AWjnHt1BhZHR/uWIP
	oKp41PxvCHXtzF6t30oUPeWyF11f9Dk=
X-Google-Smtp-Source: ABdhPJz0jcvKojtJlFZEzLqBI6hLxBn1VmZxa99loj3XVL4R8x9IWfORV2qUWOD3bi60wuuzjwI5pg==
X-Received: by 2002:aa7:d44a:: with SMTP id q10mr6184028edr.278.1614887329642;
        Thu, 04 Mar 2021 11:48:49 -0800 (PST)
Received: from localhost.localdomain (p5dec4a7d.dip0.t-ipconnect.de. [93.236.74.125])
        by smtp.gmail.com with ESMTPSA id kj3sm124394ejc.117.2021.03.04.11.48.47
        for <tyndur-devel@tyndur.org>
        (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256);
        Thu, 04 Mar 2021 11:48:48 -0800 (PST)
From: Nico Mayer <mayernico256@gmail.com>
X-Google-Original-From: Nico Mayer <mayerNico256@gmail.com>
To: tyndur-devel@tyndur.org
Subject: [PATCH v2 1/2] libc: Zentralisieren der strtoxxx-Funktionen
Date: Thu,  4 Mar 2021 20:48:38 +0100
Message-Id: <20210304194839.64983-1-mayerNico256@gmail.com>
X-Mailer: git-send-email 2.29.2
Errors-To: toni@tyndur.org
Precedence: list
Reply-To: tyndur-Patches <tyndur-devel@tyndur.org>
List-Id: tyndur-Patches <tyndur-devel.tyndur.org>
List-Unsubscribe: <mailto:tyndur-devel+unsubscribe@tyndur.org>
List-Post: <mailto:tyndur-devel@tyndur.org>
List-Help: <mailto:tyndur-devel+help@tyndur.org>
List-Subscribe: <mailto:tyndur-devel+subscribe@tyndur.org>
List-Owner: <mailto:toni@tyndur.org>
MIME-Version: 1.0
Content-Transfer-Encoding: 8bit

From: Nico Mayer <mayerNico@outlook.de>

* Bisher gibt es ein gewisses Durcheinander, was die strtoxxx-Funktionen
  anbelangt. Die Funktionen strtol und strtoll werden in der Datei
  strtol.c implementiert. Die Funktionen strtoul und strtoull werden
  wiederum direkt in string.c implementiert. Dieser Commit zentralisiert
  die Implementierung der verschiedenen strtoxxx-Funktionen. Alle
  strtoxxx-Funktionen jetzt werden durch die Datei strtol.c implementiert.

Signed-off-by: Nico Mayer <mayerNico@outlook.de>
---
 src/lib/stdlibc/strtol.c | 128 ++++++++++++++++++++++++++++-----------
 src/lib/string.c         | 104 -------------------------------
 2 files changed, 93 insertions(+), 139 deletions(-)

diff --git a/src/lib/stdlibc/strtol.c b/src/lib/stdlibc/strtol.c
index 0160ebcf..47f03a36 100644
--- a/src/lib/stdlibc/strtol.c
+++ b/src/lib/stdlibc/strtol.c
@@ -31,76 +31,134 @@
 #include "limits.h"
 #include "types.h"
 
-static long long do_strtoll(const char *str, char **endptr, int base,
-                            long long min_val, long long max_val)
+static unsigned long long do_strtoull(const char *str, char **endptr, int base,
+                            unsigned long long max_val,
+                            unsigned long long min_val)
 {
-    long long retval = 0;
-    int overflow = 0;
-    char sign = 0;
+    unsigned long long result = 0;
+    int neg = 0;
     int digit;
+    int overflow = 0;
 
+    // Leerzeichen am Anfang muessen ignoriert werden
     while (isspace(*str)) {
         str++;
     }
 
-    // Moegliches Vorzeichen auswerten
-    if (*str == '+' || *str == '-') {
-        sign = *str;
+    // Vorzeichen
+    if (*str == '+') {
+        str++;
+    } else if (*str == '-') {
+        neg = 1;
         str++;
     }
 
-    // Moegliches 0, 0x und 0X auswerten
-    if (*str == '0')
-    {
-        if (str[1] == 'x' || str[1] == 'X') {
-            if (base == 0) {
-                base = 16;
+    // Basis feststellen
+    // Bei Basis 16 darf der String mit 0x anfangen
+    // Bei Basis 0 ist automatische Erkennung
+    //   Anfang ist 0x: Basis 16
+    //   Anfang ist 0:  Basis 8
+    //   Ansonsten:     Basis 10
+    switch (base) {
+        case 0:
+            base = 10;
+            if (*str == '0') {
+                str++;
+                if (*str == 'x' || *str == 'X') {
+                    if (isxdigit(str[1])) {
+                        base = 16;
+                        str++;
+                    }
+                } else {
+                    base = 8;
+                }
             }
+            break;
 
-            if (base == 16 && isxdigit(str[2])) {
+        case 16:
+            if ((*str == '0') && (str[1] == 'x' || str[1] == 'X')
+                && isxdigit(str[2]))
+            {
                 str += 2;
             }
-        } else if (base == 0) {
-            base = 8;
-        }
+            break;
     }
 
-    while (*str)
-    {
-        if (isdigit(*str) && *str - '0' < base) {
-            digit = *str - '0';
-        } else if(isalpha(*str) && tolower(*str) - 'a' + 10 < base) {
-            digit = tolower(*str) - 'a' + 10;
-        } else {
-            break;
+    // Ergebnis berechnen
+    result = 0;
+    while (*str) {
+        switch (*str) {
+            case '0' ... '9':
+                if (*str - '0' > base - 1) {
+                    goto out;
+                }
+                digit = *str - '0';
+                break;
+            case 'A' ... 'Z':
+                if (*str - 'A' + 10 > base - 1) {
+                    goto out;
+                }
+                digit = *str - 'A' + 10;
+                break;
+            case 'a' ... 'z':
+                if (*str - 'a' + 10 > base - 1) {
+                    goto out;
+                }
+                digit = *str - 'a' + 10;
+                break;
+
+            default:
+                goto out;
         }
 
-        if (retval > (max_val - digit) / base) {
-            overflow = 1;
+        if (neg) {
+            if (result > (min_val - digit) / base) {
+                errno = ERANGE;
+                overflow = 1;
+            }
+        } else {
+            if (result > (max_val - digit) / base) {
+                errno = ERANGE;
+                overflow = 1;
+            }
         }
-        retval = retval * base + digit;
+
+        result = result * base + digit;
 
         str++;
     }
+out:
 
     if (endptr != NULL) {
-        *(const char**)endptr = str;
+        *endptr = (char*) str;
     }
 
     if (overflow) {
-        errno = ERANGE;
-        return (sign == '-') ? min_val : max_val;
+        return neg ? min_val : max_val;
     }
 
-    return (sign == '-') ? -retval : retval;
+    return neg ? - result : result;
 }
 
+
 long long strtoll(const char *str, char **endptr, int base)
 {
-    return do_strtoll(str, endptr, base, LLONG_MIN, LLONG_MAX);
+    return (long long)do_strtoull(str, endptr, base, LLONG_MAX, LLONG_MIN);
 }
 
 long strtol(const char *str, char **endptr, int base)
 {
-    return do_strtoll(str, endptr, base, LONG_MIN, LONG_MAX);
+    return (long)do_strtoull(str, endptr, base, LONG_MAX, LONG_MIN);
+}
+
+unsigned long long strtoull(const char *str, char **endptr, int base)
+{
+    return (unsigned long long)do_strtoull(str, endptr, base,
+                                           ULLONG_MAX, ULLONG_MAX);
 }
+
+unsigned long strtoul(const char *str, char **endptr, int base)
+{
+    return (unsigned long)do_strtoull(str, endptr, base, ULONG_MAX, ULONG_MAX);
+}
+
diff --git a/src/lib/string.c b/src/lib/string.c
index 98861869..630e4f0e 100644
--- a/src/lib/string.c
+++ b/src/lib/string.c
@@ -67,110 +67,6 @@ void itoa(unsigned int n, char *s, unsigned int base)
 	s[y] = '\0';
 }
 
-unsigned long long int strtoull(const char *nptr, char **endptr, int base)
-{
-    unsigned long long int result = 0;
-    int neg = 0;
-    int digit;
-    bool overflow = false;
-
-    // Leerzeichen am Anfang muessen ignoriert werden
-    while (isspace(*nptr)) {
-        nptr++;
-    }
-
-    // Vorzeichen
-    if (*nptr == '+') {
-        nptr++;
-    } else if (*nptr == '-') {
-        neg = 1;
-        nptr++;
-    }
-
-    // Basis feststellen
-    // Bei Basis 16 darf der String mit 0x anfangen
-    // Bei Basis 0 ist automatische Erkennung
-    //   Anfang ist 0x: Basis 16
-    //   Anfang ist 0:  Basis 8
-    //   Ansonsten:     Basis 10
-    switch (base) {
-        case 0:
-            base = 10;
-            if (*nptr == '0') {
-                nptr++;
-                if (*nptr == 'x' || *nptr == 'X') {
-                    if (isxdigit(nptr[1])) {
-                        base = 16;
-                        nptr++;
-                    }
-                } else {
-                    base = 8;
-                }
-            }
-            break;
-
-        case 16:
-            if ((*nptr == '0') && (nptr[1] == 'x' || nptr[1] == 'X')
-                && isxdigit(nptr[2]))
-            {
-                nptr += 2;
-            }
-            break;
-    }
-
-    // Ergebnis berechnen
-    result = 0;
-    while (*nptr) {
-        switch (*nptr) {
-            case '0' ... '9':
-                if (*nptr - '0' > base - 1) {
-                    goto out;
-                }
-                digit = *nptr - '0';
-                break;
-            case 'A' ... 'Z':
-                if (*nptr - 'A' + 10 > base - 1) {
-                    goto out;
-                }
-                digit = *nptr - 'A' + 10;
-                break;
-            case 'a' ... 'z':
-                if (*nptr - 'a' + 10 > base - 1) {
-                    goto out;
-                }
-                digit = *nptr - 'a' + 10;
-                break;
-
-            default:
-                goto out;
-        }
-
-        if (result > (ULLONG_MAX - digit) / base) {
-            overflow = true;
-        }
-        result = result * base + digit;
-
-        nptr++;
-    }
-out:
-
-    if (endptr != NULL) {
-        *endptr = (char*) nptr;
-    }
-
-    if (overflow) {
-        return ULLONG_MAX;
-    }
-
-    return neg ? - result : result;
-}
-
-unsigned long int strtoul(const char *nptr, char **endptr, int base)
-{
-    return (unsigned long int) strtoull(nptr, endptr, base);
-}
-
-
 int atoi(const char *s)
 {
     return (int) strtoull(s, NULL, 10);
-- 
2.29.2

