Completely rewrote signed/unsigned int/long parsing code, based on Chapter 12

Author: dplassgit

examples/convert_by_assignment.c

@@ -0,0 +1,96 @@
+/* Test that we correctly perform conversions "as if by assignment", including:
+ * - function arguments
+ * - return statements
+ * - actual assignment expressions
+ * - initializers for automatic variables
+ */
+
+#ifdef SUPPRESS_WARNINGS
+#ifdef __clang__
+#pragma clang diagnostic ignored "-Wconstant-conversion"
+#else
+#pragma GCC diagnostic ignored "-Woverflow"
+#endif
+#endif
+
+int check_int(int converted, int expected) {
+    return (converted == expected);
+}
+
+int check_long(long converted, long expected) {
+    return (converted == expected);
+}
+
+int check_ulong(unsigned long converted, unsigned long expected) {
+    return (converted == expected);
+}
+
+long return_extended_uint(unsigned int u) {
+    return u;
+}
+
+unsigned long return_extended_int(int i) {
+    return i;
+}
+
+int return_truncated_ulong(unsigned long ul) {
+    return ul;
+}
+
+int extend_on_assignment(unsigned int ui, long expected) {
+    long result = ui; // implicit conversion causes zero-extension
+    return result == expected;
+}
+
+int main(void) {
+    // function arguments
+
+    /* truncate 2^63 + 5 to 5 */
+    if (!check_int(9223372036854775813ul, 5)) {
+        return 1;
+    }
+
+    /* zero-extend 2^31+10, preserve its value */
+    if (!check_long(2147483658u, 2147483658l)) {
+        return 2;
+    }
+
+    /* sign-extend -1 to ULONG_MAX */
+    if (!check_ulong(-1, 18446744073709551615UL)) {
+        return 3;
+    }
+
+    // return values
+
+    /* zero-extend 2^31+10, preserve its value */
+    if (return_extended_uint(2147483658u) != 2147483658l) {
+        return 4;
+    }
+
+    /* sign-extend -1 to ULONG_MAX */
+    if (return_extended_int(-1) != 18446744073709551615UL) {
+        return 5;
+    }
+
+    /* truncate 2^50 + 2^31 + 100 to int, -2^31 + 100
+     * then sign-extend, preserving its value
+     */
+    long l = return_truncated_ulong(1125902054326372ul);
+    if (l != -2147483548l) {
+        return 6;
+    }
+
+    // assignment expressions
+    if (!extend_on_assignment(2147483658u, 2147483658l)){
+        return 7;
+    }
+
+    // local initializers
+    int i = 4294967196u; // unsigned int 2^32 - 100, will be converted to -100
+    if (i != -100) {
+        return 8;
+    }
+
+
+    return 0;
+}

examples/truncate.c

@@ -0,0 +1,74 @@
+/* Test truncating wider to narrow types */
+int ulong_to_int(unsigned long ul, int expected) {
+    int result = (int) ul;
+    return (result == expected);
+}
+
+int ulong_to_uint(unsigned long ul, unsigned expected) {
+    return ((unsigned int) ul == expected);
+}
+
+int long_to_uint(long l, unsigned int expected) {
+    return (unsigned int) l == expected;
+}
+
+int main(void) {
+    /* truncate long */
+
+    /* 100 is in the range of unsigned int,
+     * so truncating it to an unsigned int
+     * will preserve its value
+     */
+    if (!long_to_uint(100l, 100u)) {
+        return 1;
+    }
+
+    /* -9223372036854774574 (i.e. -2^63 + 1234) is outside the range of unsigned int,
+     * so add 2^32 to bring it within range */
+    if (!long_to_uint(-9223372036854774574l, 1234u)) {
+        return 2;
+    }
+
+    /* truncate unsigned long */
+
+    /* 100 can be cast to an int or unsigned int without changing its value */
+    if (!ulong_to_int(100ul, 100)) {
+        return 3;
+    }
+
+    if (!ulong_to_uint(100ul, 100u)) {
+        return 4;
+    }
+
+    /* 4294967200 (i.e. 2^32 - 96) can be cast to an unsigned int without changing its value,
+     * but must be reduced modulo 2^32 to cast to a signed int
+     */
+    if (!ulong_to_uint(4294967200ul, 4294967200u)) {
+        return 5;
+    }
+
+    if (!ulong_to_int(4294967200ul, -96)) {
+        return 6;
+    }
+
+    /* 1152921506754330624 (i.e. 2^60 + 2^31) must be reduced modulo 2^32
+     * to represent as a signed or unsigned int
+     */
+
+    if (!ulong_to_uint(1152921506754330624ul, 2147483648u)) { // reduce to 2^31
+        return 7;
+    }
+
+    if (!ulong_to_int(1152921506754330624ul, -2147483648)){ // reduce to -2^31
+        return 8;
+    }
+
+    /* truncate unsigned long constant that can't
+     * be expressed in 32 bits, to test rewrite rule
+     */
+    unsigned int ui = (unsigned int)17179869189ul; // 2^34 + 5
+    if (ui != 5)
+        return 9;
+
+    return 0;
+}

src/com/plasstech/lang/c/parser/Constant.java

@@ -14,12 +14,12 @@ public static Constant<Long> of(long value) {
     return new Constant<Long>(value, Type.LONG);
   }
 
-  public static Constant<UnsignedInteger> ofUnsignedInt(int value) {
-    return new Constant<UnsignedInteger>(UnsignedInteger.fromIntBits(value), Type.UNSIGNED_INT);
+  public static Constant<UnsignedInteger> ofUnsignedInt(String value) {
+    return new Constant<UnsignedInteger>(UnsignedInteger.valueOf(value), Type.UNSIGNED_INT);
   }
 
-  public static Constant<UnsignedLong> ofUnsignedLong(long value) {
-    return new Constant<UnsignedLong>(UnsignedLong.fromLongBits(value), Type.UNSIGNED_LONG);
+  public static Constant<UnsignedLong> ofUnsignedLong(String value) {
+    return new Constant<UnsignedLong>(UnsignedLong.valueOf(value), Type.UNSIGNED_LONG);
   }
 
   @Override