simulator: Fix problem on Windows with 32-bit 1L

On Windows, 1L is a 32-bit value, it's 64-bit on other platforms.
This was causing a number of funny crashes exposed by the test suite.

Signed-off-by: Christophe de Dinechin <christophe@dinechin.org>

Author: c3d

src/decimal.cc

@@ -702,7 +702,7 @@ ularge decimal::as_unsigned(bool magnitude) const
 
     // If we overflow in the computation, return a "maxint"
     if (exp >= 19)
-        return ~0UL;
+        return ~0ULL;
 
     ularge xp  = exp;
     ularge pow = 1;
@@ -737,8 +737,8 @@ large decimal::as_integer() const
 // ----------------------------------------------------------------------------
 {
     large result = (large) as_unsigned(true);
-    if (result == ~0L)
-        result = 0x7FFFFFFFFFFFFFFFL;
+    if (result == ~0LL)
+        result = 0x7FFFFFFFFFFFFFFFLL;
     if (type() == ID_neg_decimal)
         result = -result;
     return result;
@@ -751,7 +751,7 @@ int32_t decimal::as_int32() const
 // ----------------------------------------------------------------------------
 {
     large result = (large) as_unsigned(true);
-    if (result == ~0L || result >= 0x80000000L)
+    if (result == ~0LL || result >= 0x80000000LL)
         result = 0x7FFFFFFF;
     if (type() == ID_neg_decimal)
         result = -result;
@@ -786,7 +786,7 @@ decimal_p decimal::from_bignum(bignum_p valuep)
     decimal_g digits;
     large     exp    = 0;
     bignum_g  value  = valuep;
-    bignum_g  div    = bignum::make(1000000000000UL);
+    bignum_g  div    = bignum::make(1000000000000ULL);
     bignum_g  kigit;
 
     while (!value->is_zero())
@@ -816,7 +816,7 @@ decimal_p decimal::from_random_seed(bignum_p valuep)
     decimal_g digits;
     large     exp    = 0;
     bignum_g  value  = valuep;
-    bignum_g  div    = bignum::make(1000000000000UL);
+    bignum_g  div    = bignum::make(1000000000000ULL);
     bignum_g  kigit;
 
     while (!value->is_zero())

src/plot.cc

@@ -281,7 +281,7 @@ object::result draw_plot(object::id                  kind,
     if (xyplot)
     {
         uint        shift = 1;
-        algebraic_g div   = integer::make(1UL << shift);
+        algebraic_g div   = integer::make(1ULL << shift);
         algebraic_g dx    = (ppar.xmax - ppar.xmin) / div;
         algebraic_g dy    = (ppar.ymax - ppar.ymin) / div;
         size        w     = 2*display_width();
@@ -315,7 +315,7 @@ object::result draw_plot(object::id                  kind,
                         algebraic::compare(dy, step) < 0)
                         break;
                     shift++;
-                    div = integer::make(1UL << shift);
+                    div = integer::make(1ULL << shift);
                     dx = (ppar.xmax - ppar.xmin) / div;
                     dy = (ppar.ymax - ppar.ymin) / div;
                     x = ppar.xmin + dx;

src/polynomial.cc

@@ -1031,7 +1031,7 @@ size_t polynomial::variable(utf8 name, size_t len) const
         if (size_t(p - first) >= length)
             break;
     }
-    return ~0UL;
+    return ~0ULL;
 }
 
 
@@ -1041,7 +1041,7 @@ size_t polynomial::variable(symbol_p sym) const
 // ----------------------------------------------------------------------------
 {
     if (!sym)
-        return ~0UL;
+        return ~0ULL;
     size_t len  = 0;
     utf8   name = sym->value(&len);
     return variable(name, len);

src/renderer.h

@@ -69,7 +69,7 @@ struct renderer
     bool   put(unicode code);
     bool   put(utf8 s)                  { return put(cstring(s)); }
     bool   put(utf8 s, size_t len)      { return put(cstring(s), len); }
-    bool   put(object::id fmt, utf8 s, size_t len = ~0UL);
+    bool   put(object::id fmt, utf8 s, size_t len = ~0ULL);
 
     bool   editing() const              { return edit; }
     bool   graphing() const             { return graph; }

src/runtime.h

@@ -351,7 +351,7 @@ struct runtime
     bool     cache(bool level0, object_p key, object_p value);
     void     uncache(object_p key, size_t sz);
     void     uncache(object_p key)      { uncache(key, 1); }
-    void     uncache()                  { uncache(nullptr, ~0UL); }
+    void     uncache()                  { uncache(nullptr, ~0ULL); }
     size_t   gc_cleared() const         { return GCCleared; }
 
 

src/utf8.h

@@ -225,7 +225,7 @@ inline size_t utf8_size(unicode cp)
 }
 
 
-inline size_t utf8_size(utf8 text, size_t max = ~0UL)
+inline size_t utf8_size(utf8 text, size_t max = ~0ULL)
 // ----------------------------------------------------------------------------
 //   Return the number of bytes required for a UTF-8 encoding of text
 // ----------------------------------------------------------------------------