Can now parse HTTP responses.

luprex/core/cpp/util.cpp

@@ -33,6 +33,15 @@ bool valid_int64(string_view value) {
     return true;
 }
 
+bool valid_hex64(string_view value) {
+    int64_t result;
+    const char *last = value.data() + value.size();
+    auto r = std::from_chars(value.data(), last, result, 16);
+    if (r.ec != std::errc()) return false;
+    if (r.ptr != last) return false;
+    return true;
+}
+
 bool valid_double(string_view value) {
     double result;
     const char *last = value.data() + value.size();
@@ -51,6 +60,15 @@ int64_t to_int64(string_view value, int64_t errval) {
     return result;
 }
 
+uint64_t to_hex64(string_view value, uint64_t errval) {
+    uint64_t result;
+    const char *last = value.data() + value.size();
+    auto r = std::from_chars(value.data(), last, result, 16);
+    if (r.ec != std::errc()) return errval;
+    if (r.ptr != last) return errval;
+    return result;
+}
+
 double to_double(string_view value, double errval) {
     double result;
     const char *last = value.data() + value.size();
@@ -192,6 +210,65 @@ string_view read_to_space(string_view &source) {
     return result;
 }
 
+string_view read_nbytes(string_view &source, int nbytes) {
+    if (nbytes < 0) nbytes = 0;
+    if (nbytes > int(source.size())) nbytes = source.size();
+    string_view result = source.substr(0, nbytes);
+    source = source.substr(nbytes);
+    return result;
+}
+
+bool valid_utf8(string_view s)
+{
+    const unsigned char *bytes = (const unsigned char *)s.data();
+    const unsigned char *tail = bytes + s.size();
+    unsigned int codepoint;
+    int seqlen;
+
+    while (bytes < tail) {
+        if ((bytes[0] & 0x80) == 0x00) {
+            // U+0000 to U+007F
+            codepoint = (bytes[0] & 0x7F);
+            seqlen = 1;
+        } else if ((bytes[0] & 0xE0) == 0xC0) {
+            // U+0080 to U+07FF
+            codepoint = (bytes[0] & 0x1F);
+            seqlen = 2;
+        } else if ((bytes[0] & 0xF0) == 0xE0) {
+            // U+0800 to U+FFFF
+            codepoint = (bytes[0] & 0x0F);
+            seqlen = 3;
+        } else if ((bytes[0] & 0xF8) == 0xF0) {
+            // U+10000 to U+10FFFF
+            codepoint = (bytes[0] & 0x07);
+            seqlen = 4;
+        } else {
+            return false;
+        }
+
+        if (bytes + seqlen > tail) {
+            return false;
+        }
+
+        for (int i = 1; i < seqlen; ++i) {
+            if ((bytes[i] & 0xC0) != 0x80) return false;
+            codepoint = (codepoint << 6) | (bytes[i] & 0x3F);
+        }
+
+        if ((codepoint > 0x10FFFF) ||
+            ((codepoint >= 0xD800) && (codepoint <= 0xDFFF)) ||
+            ((codepoint <= 0x007F) && (seqlen != 1)) ||
+            ((codepoint >= 0x0080) && (codepoint <= 0x07FF) && (seqlen != 2)) ||
+            ((codepoint >= 0x0800) && (codepoint <= 0xFFFF) && (seqlen != 3)) ||
+            ((codepoint >= 0x10000) && (codepoint <= 0x1FFFFF) && (seqlen != 4))) {
+            return false;
+        }
+
+        bytes += seqlen;
+    }
+    return true;
+}
+
 } // namespace sv
 
 
@@ -450,6 +527,7 @@ eng::string XYZ::debug_string() const {
     return oss.str();
 }
 
+
 } // namespace util
 
 std::ostream &operator<<(std::ostream &oss, const util::hex64 &v) {