Better implementation of integer parser for OPL parser

Works with all legal integers now.

Fixes #336

Author: joto

include/osmium/io/detail/opl_parser_functions.hpp

@@ -206,42 +206,38 @@ namespace osmium {
                 *data = s;
             }
 
-            enum {
-                max_int_len = std::numeric_limits<int64_t>::digits10 + 1
-            };
-
             template <typename T>
             inline T opl_parse_int(const char** s) {
-                if (**s == '\0') {
-                    throw opl_error{"expected integer", *s};
-                }
                 const bool negative = (**s == '-');
                 if (negative) {
                     ++*s;
                 }
 
-                int64_t value = 0;
+                if (**s < '0' || **s > '9') {
+                    throw opl_error{"expected integer", *s};
+                }
 
-                int n = max_int_len;
+                int64_t value = 0;
                 while (**s >= '0' && **s <= '9') {
-                    if (--n == 0) {
-                        throw opl_error{"integer too long", *s};
+                    if (value <= -922337203685477580) {
+                        if ((value < -922337203685477580) || (**s > '8')) {
+                            throw opl_error("integer too long", *s);
+                        }
                     }
                     value *= 10;
-                    value += **s - '0';
+                    value -= **s - '0';
                     ++*s;
                 }
 
-                if (n == max_int_len) {
-                    throw opl_error{"expected integer", *s};
-                }
-
                 if (negative) {
-                    value = -value;
                     if (value < std::numeric_limits<T>::min()) {
                         throw opl_error{"integer too long", *s};
                     }
                 } else {
+                    if (value == std::numeric_limits<int64_t>::min()) {
+                        throw opl_error{"integer too long", *s};
+                    }
+                    value = -value;
                     if (value > std::numeric_limits<T>::max()) {
                         throw opl_error{"integer too long", *s};
                     }

test/t/io/test_opl_parser.cpp

@@ -262,6 +262,10 @@ TEST_CASE("Parse OPL: integer") {
     REQUIRE(test_parse_int("-1234567890123x") == -1234567890123);
     REQUIRE(test_parse_int("999999999999999999x") == 999999999999999999);
     REQUIRE(test_parse_int("-999999999999999999x") == -999999999999999999);
+    REQUIRE(test_parse_int("1000000000000000000x") == 1000000000000000000);
+    REQUIRE(test_parse_int("9223372036854775807x") == 9223372036854775807);
+    REQUIRE(test_parse_int("-9223372036854775807x") == -9223372036854775807);
+    REQUIRE(test_parse_int("-9223372036854775808x") == -9223372036854775807 - 1);
 
     REQUIRE_THROWS_WITH(test_parse_int(""),
                         "OPL error: expected integer");
@@ -275,7 +279,25 @@ TEST_CASE("Parse OPL: integer") {
     REQUIRE_THROWS_WITH(test_parse_int("x"),
                         "OPL error: expected integer");
 
-    REQUIRE_THROWS_WITH(test_parse_int("99999999999999999999999x"),
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775808x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775809x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("9223372036854775810x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-9223372036854775809x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-9223372036854775810x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("999999999999999999999x"),
+                        "OPL error: integer too long");
+
+    REQUIRE_THROWS_WITH(test_parse_int("-999999999999999999999x"),
                         "OPL error: integer too long");
 }