Add constants for unsigned values (#111)

This commit adds constants for unsigned values. Currently we can use `-`
to mean "unsigned", but I think having a specific name makes Fiddle more
user friendly. This commit continues to support `-`, but introduces
negative constants with "unsigned" names

I think this will help to eliminate [this
code](https://github.com/ruby/ruby/blob/3a56bf0bcc66e14ffe5ec89efc32ecfceed180f4/lib/mjit/c_type.rb#L31-L38)

Co-authored-by: Sutou Kouhei <kou@clear-code.com>

ext/fiddle/closure.c

@@ -92,7 +92,7 @@ with_gvl_callback(void *ptr)
 	  case TYPE_INT:
 	    rb_ary_push(params, INT2NUM(*(int *)x->args[i]));
 	    break;
-	  case -TYPE_INT:
+	  case TYPE_UINT:
 	    rb_ary_push(params, UINT2NUM(*(unsigned int *)x->args[i]));
 	    break;
 	  case TYPE_VOIDP:
@@ -103,19 +103,19 @@ with_gvl_callback(void *ptr)
 	  case TYPE_LONG:
 	    rb_ary_push(params, LONG2NUM(*(long *)x->args[i]));
 	    break;
-	  case -TYPE_LONG:
+	  case TYPE_ULONG:
 	    rb_ary_push(params, ULONG2NUM(*(unsigned long *)x->args[i]));
 	    break;
 	  case TYPE_CHAR:
 	    rb_ary_push(params, INT2NUM(*(signed char *)x->args[i]));
 	    break;
-	  case -TYPE_CHAR:
+	  case TYPE_UCHAR:
 	    rb_ary_push(params, UINT2NUM(*(unsigned char *)x->args[i]));
 	    break;
 	  case TYPE_SHORT:
 	    rb_ary_push(params, INT2NUM(*(signed short *)x->args[i]));
 	    break;
-	  case -TYPE_SHORT:
+	  case TYPE_USHORT:
 	    rb_ary_push(params, UINT2NUM(*(unsigned short *)x->args[i]));
 	    break;
 	  case TYPE_DOUBLE:
@@ -128,7 +128,7 @@ with_gvl_callback(void *ptr)
 	  case TYPE_LONG_LONG:
 	    rb_ary_push(params, LL2NUM(*(LONG_LONG *)x->args[i]));
 	    break;
-	  case -TYPE_LONG_LONG:
+	  case TYPE_ULONG_LONG:
 	    rb_ary_push(params, ULL2NUM(*(unsigned LONG_LONG *)x->args[i]));
 	    break;
 #endif
@@ -151,17 +151,17 @@ with_gvl_callback(void *ptr)
       case TYPE_LONG:
 	*(long *)x->resp = NUM2LONG(ret);
 	break;
-      case -TYPE_LONG:
+      case TYPE_ULONG:
 	*(unsigned long *)x->resp = NUM2ULONG(ret);
 	break;
       case TYPE_CHAR:
       case TYPE_SHORT:
       case TYPE_INT:
 	*(ffi_sarg *)x->resp = NUM2INT(ret);
 	break;
-      case -TYPE_CHAR:
-      case -TYPE_SHORT:
-      case -TYPE_INT:
+      case TYPE_UCHAR:
+      case TYPE_USHORT:
+      case TYPE_UINT:
 	*(ffi_arg *)x->resp = NUM2UINT(ret);
 	break;
       case TYPE_VOIDP:
@@ -177,7 +177,7 @@ with_gvl_callback(void *ptr)
       case TYPE_LONG_LONG:
 	*(LONG_LONG *)x->resp = NUM2LL(ret);
 	break;
-      case -TYPE_LONG_LONG:
+      case TYPE_ULONG_LONG:
 	*(unsigned LONG_LONG *)x->resp = NUM2ULL(ret);
 	break;
 #endif

ext/fiddle/conversions.c

@@ -211,32 +211,32 @@ rb_fiddle_value_to_generic(int type, VALUE *src, fiddle_generic *dst)
       case TYPE_CHAR:
 	dst->schar = (signed char)NUM2INT(*src);
 	break;
-      case -TYPE_CHAR:
+      case TYPE_UCHAR:
 	dst->uchar = (unsigned char)NUM2UINT(*src);
 	break;
       case TYPE_SHORT:
 	dst->sshort = (unsigned short)NUM2INT(*src);
 	break;
-      case -TYPE_SHORT:
+      case TYPE_USHORT:
 	dst->sshort = (signed short)NUM2UINT(*src);
 	break;
       case TYPE_INT:
 	dst->sint = NUM2INT(*src);
 	break;
-      case -TYPE_INT:
+      case TYPE_UINT:
 	dst->uint = NUM2UINT(*src);
 	break;
       case TYPE_LONG:
 	dst->slong = NUM2LONG(*src);
 	break;
-      case -TYPE_LONG:
+      case TYPE_ULONG:
 	dst->ulong = NUM2ULONG(*src);
 	break;
 #if HAVE_LONG_LONG
       case TYPE_LONG_LONG:
 	dst->slong_long = NUM2LL(*src);
 	break;
-      case -TYPE_LONG_LONG:
+      case TYPE_ULONG_LONG:
 	dst->ulong_long = NUM2ULL(*src);
 	break;
 #endif
@@ -283,24 +283,24 @@ rb_fiddle_generic_to_value(VALUE rettype, fiddle_generic retval)
           PTR2NUM((void *)retval.pointer));
       case TYPE_CHAR:
 	return INT2NUM((signed char)retval.fffi_sarg);
-      case -TYPE_CHAR:
+      case TYPE_UCHAR:
 	return INT2NUM((unsigned char)retval.fffi_arg);
       case TYPE_SHORT:
 	return INT2NUM((signed short)retval.fffi_sarg);
-      case -TYPE_SHORT:
+      case TYPE_USHORT:
 	return INT2NUM((unsigned short)retval.fffi_arg);
       case TYPE_INT:
 	return INT2NUM((signed int)retval.fffi_sarg);
-      case -TYPE_INT:
+      case TYPE_UINT:
 	return UINT2NUM((unsigned int)retval.fffi_arg);
       case TYPE_LONG:
 	return LONG2NUM(retval.slong);
-      case -TYPE_LONG:
+      case TYPE_ULONG:
 	return ULONG2NUM(retval.ulong);
 #if HAVE_LONG_LONG
       case TYPE_LONG_LONG:
 	return LL2NUM(retval.slong_long);
-      case -TYPE_LONG_LONG:
+      case TYPE_ULONG_LONG:
 	return ULL2NUM(retval.ulong_long);
 #endif
       case TYPE_FLOAT:

ext/fiddle/fiddle.c

@@ -182,30 +182,60 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "TYPE_CHAR",      INT2NUM(TYPE_CHAR));
 
+    /* Document-const: TYPE_UCHAR
+     *
+     * C type - unsigned char
+     */
+    rb_define_const(mFiddle, "TYPE_UCHAR",      INT2NUM(TYPE_UCHAR));
+
     /* Document-const: TYPE_SHORT
      *
      * C type - short
      */
     rb_define_const(mFiddle, "TYPE_SHORT",     INT2NUM(TYPE_SHORT));
 
+    /* Document-const: TYPE_USHORT
+     *
+     * C type - unsigned short
+     */
+    rb_define_const(mFiddle, "TYPE_USHORT",     INT2NUM(TYPE_USHORT));
+
     /* Document-const: TYPE_INT
      *
      * C type - int
      */
     rb_define_const(mFiddle, "TYPE_INT",       INT2NUM(TYPE_INT));
 
+    /* Document-const: TYPE_UINT
+     *
+     * C type - unsigned int
+     */
+    rb_define_const(mFiddle, "TYPE_UINT",       INT2NUM(TYPE_UINT));
+
     /* Document-const: TYPE_LONG
      *
      * C type - long
      */
     rb_define_const(mFiddle, "TYPE_LONG",      INT2NUM(TYPE_LONG));
 
+    /* Document-const: TYPE_ULONG
+     *
+     * C type - long
+     */
+    rb_define_const(mFiddle, "TYPE_ULONG",      INT2NUM(TYPE_ULONG));
+
 #if HAVE_LONG_LONG
     /* Document-const: TYPE_LONG_LONG
      *
      * C type - long long
      */
     rb_define_const(mFiddle, "TYPE_LONG_LONG", INT2NUM(TYPE_LONG_LONG));
+
+    /* Document-const: TYPE_ULONG_LONG
+     *
+     * C type - long long
+     */
+    rb_define_const(mFiddle, "TYPE_ULONG_LONG", INT2NUM(TYPE_ULONG_LONG));
 #endif
 
 #ifdef TYPE_INT8_T
@@ -214,6 +244,12 @@ Init_fiddle(void)
      * C type - int8_t
      */
     rb_define_const(mFiddle, "TYPE_INT8_T",    INT2NUM(TYPE_INT8_T));
+
+    /* Document-const: TYPE_UINT8_T
+     *
+     * C type - uint8_t
+     */
+    rb_define_const(mFiddle, "TYPE_UINT8_T",    INT2NUM(TYPE_UINT8_T));
 #endif
 
 #ifdef TYPE_INT16_T
@@ -222,6 +258,12 @@ Init_fiddle(void)
      * C type - int16_t
      */
     rb_define_const(mFiddle, "TYPE_INT16_T",   INT2NUM(TYPE_INT16_T));
+
+    /* Document-const: TYPE_UINT16_T
+     *
+     * C type - uint16_t
+     */
+    rb_define_const(mFiddle, "TYPE_UINT16_T",   INT2NUM(TYPE_UINT16_T));
 #endif
 
 #ifdef TYPE_INT32_T
@@ -230,6 +272,12 @@ Init_fiddle(void)
      * C type - int32_t
      */
     rb_define_const(mFiddle, "TYPE_INT32_T",   INT2NUM(TYPE_INT32_T));
+
+    /* Document-const: TYPE_UINT32_T
+     *
+     * C type - uint32_t
+     */
+    rb_define_const(mFiddle, "TYPE_UINT32_T",   INT2NUM(TYPE_UINT32_T));
 #endif
 
 #ifdef TYPE_INT64_T
@@ -238,6 +286,12 @@ Init_fiddle(void)
      * C type - int64_t
      */
     rb_define_const(mFiddle, "TYPE_INT64_T",   INT2NUM(TYPE_INT64_T));
+
+    /* Document-const: TYPE_UINT64_T
+     *
+     * C type - uint64_t
+     */
+    rb_define_const(mFiddle, "TYPE_UINT64_T",   INT2NUM(TYPE_UINT64_T));
 #endif
 
     /* Document-const: TYPE_FLOAT
@@ -422,30 +476,60 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_CHAR",  INT2NUM(sizeof(char)));
 
+    /* Document-const: SIZEOF_UCHAR
+     *
+     * size of a unsigned char
+     */
+    rb_define_const(mFiddle, "SIZEOF_UCHAR",  INT2NUM(sizeof(unsigned char)));
+
     /* Document-const: SIZEOF_SHORT
      *
      * size of a short
      */
     rb_define_const(mFiddle, "SIZEOF_SHORT", INT2NUM(sizeof(short)));
 
+    /* Document-const: SIZEOF_USHORT
+     *
+     * size of a unsigned short
+     */
+    rb_define_const(mFiddle, "SIZEOF_USHORT", INT2NUM(sizeof(unsigned short)));
+
     /* Document-const: SIZEOF_INT
      *
      * size of an int
      */
     rb_define_const(mFiddle, "SIZEOF_INT",   INT2NUM(sizeof(int)));
 
+    /* Document-const: SIZEOF_UINT
+     *
+     * size of an unsigned int
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT",   INT2NUM(sizeof(unsigned int)));
+
     /* Document-const: SIZEOF_LONG
      *
      * size of a long
      */
     rb_define_const(mFiddle, "SIZEOF_LONG",  INT2NUM(sizeof(long)));
 
+    /* Document-const: SIZEOF_ULONG
+     *
+     * size of a unsigned long
+     */
+    rb_define_const(mFiddle, "SIZEOF_ULONG",  INT2NUM(sizeof(unsigned long)));
+
 #if HAVE_LONG_LONG
     /* Document-const: SIZEOF_LONG_LONG
      *
      * size of a long long
      */
     rb_define_const(mFiddle, "SIZEOF_LONG_LONG",  INT2NUM(sizeof(LONG_LONG)));
+
+    /* Document-const: SIZEOF_ULONG_LONG
+     *
+     * size of a unsigned long long
+     */
+    rb_define_const(mFiddle, "SIZEOF_ULONG_LONG",  INT2NUM(sizeof(unsigned LONG_LONG)));
 #endif
 
     /* Document-const: SIZEOF_INT8_T
@@ -454,24 +538,48 @@ Init_fiddle(void)
      */
     rb_define_const(mFiddle, "SIZEOF_INT8_T",  INT2NUM(sizeof(int8_t)));
 
+    /* Document-const: SIZEOF_UINT8_T
+     *
+     * size of a uint8_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT8_T",  INT2NUM(sizeof(uint8_t)));
+
     /* Document-const: SIZEOF_INT16_T
      *
      * size of a int16_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT16_T", INT2NUM(sizeof(int16_t)));
 
+    /* Document-const: SIZEOF_UINT16_T
+     *
+     * size of a uint16_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT16_T", INT2NUM(sizeof(uint16_t)));
+
     /* Document-const: SIZEOF_INT32_T
      *
      * size of a int32_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT32_T", INT2NUM(sizeof(int32_t)));
 
+    /* Document-const: SIZEOF_UINT32_T
+     *
+     * size of a uint32_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT32_T", INT2NUM(sizeof(uint32_t)));
+
     /* Document-const: SIZEOF_INT64_T
      *
      * size of a int64_t
      */
     rb_define_const(mFiddle, "SIZEOF_INT64_T", INT2NUM(sizeof(int64_t)));
 
+    /* Document-const: SIZEOF_UINT64_T
+     *
+     * size of a uint64_t
+     */
+    rb_define_const(mFiddle, "SIZEOF_UINT64_T", INT2NUM(sizeof(uint64_t)));
+
     /* Document-const: SIZEOF_FLOAT
      *
      * size of a float