src/compiler: Added fixint variants to compiler

Signed-off-by: Lucas Bajolet <r4pass@hotmail.com>

diff --git a/src/compiler/abstract_compiler.nit b/src/compiler/abstract_compiler.nit
index 78d2c31..b58d4a3 100644 (file)
--- a/src/compiler/abstract_compiler.nit
+++ b/src/compiler/abstract_compiler.nit
@@ -654,6 +654,7 @@ abstract class AbstractCompiler
                self.header.add_decl("#include <sys/types.h>\n")
                self.header.add_decl("#include <unistd.h>\n")
                self.header.add_decl("#include <stdint.h>\n")
+               self.header.add_decl("#include <inttypes.h>\n")
                self.header.add_decl("#include \"gc_chooser.h\"")
                self.header.add_decl("#ifdef ANDROID")
                self.header.add_decl("  #include <android/log.h>")
@@ -1506,6 +1507,46 @@ abstract class AbstractCompilerVisitor
                return res
        end
 
+       # Generate an int8 value
+       fun int8_instance(value: Int8): RuntimeVariable
+       do
+               var t = mmodule.int8_type
+               var res = new RuntimeVariable("((int8_t){value.to_s})", t, t)
+               return res
+       end
+
+       # Generate an int16 value
+       fun int16_instance(value: Int16): RuntimeVariable
+       do
+               var t = mmodule.int16_type
+               var res = new RuntimeVariable("((int16_t){value.to_s})", t, t)
+               return res
+       end
+
+       # Generate a uint16 value
+       fun uint16_instance(value: UInt16): RuntimeVariable
+       do
+               var t = mmodule.uint16_type
+               var res = new RuntimeVariable("((uint16_t){value.to_s})", t, t)
+               return res
+       end
+
+       # Generate an int32 value
+       fun int32_instance(value: Int32): RuntimeVariable
+       do
+               var t = mmodule.int32_type
+               var res = new RuntimeVariable("((int32_t){value.to_s})", t, t)
+               return res
+       end
+
+       # Generate a uint32 value
+       fun uint32_instance(value: UInt32): RuntimeVariable
+       do
+               var t = mmodule.uint32_type
+               var res = new RuntimeVariable("((uint32_t){value.to_s})", t, t)
+               return res
+       end
+
        # Generate a char value
        fun char_instance(value: Char): RuntimeVariable
        do
@@ -1905,8 +1946,18 @@ redef class MClassType
                        return "uint32_t"
                else if mclass.name == "Float" then
                        return "double"
+               else if mclass.name == "Int8" then
+                       return "int8_t"
                else if mclass.name == "Byte" then
                        return "unsigned char"
+               else if mclass.name == "Int16" then
+                       return "int16_t"
+               else if mclass.name == "UInt16" then
+                       return "uint16_t"
+               else if mclass.name == "Int32" then
+                       return "int32_t"
+               else if mclass.name == "UInt32" then
+                       return "uint32_t"
                else if mclass.name == "NativeString" then
                        return "char*"
                else if mclass.name == "NativeArray" then
@@ -1937,8 +1988,18 @@ redef class MClassType
                        return "c"
                else if mclass.name == "Float" then
                        return "d"
+               else if mclass.name == "Int8" then
+                       return "i8"
                else if mclass.name == "Byte" then
                        return "b"
+               else if mclass.name == "Int16" then
+                       return "i16"
+               else if mclass.name == "UInt16" then
+                       return "u16"
+               else if mclass.name == "Int32" then
+                       return "i32"
+               else if mclass.name == "UInt32" then
+                       return "u32"
                else if mclass.name == "NativeString" then
                        return "str"
                else if mclass.name == "NativeArray" then
@@ -2160,6 +2221,21 @@ redef class AMethPropdef
                        else if pname == ">=" then
                                v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
                                return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
                        else if pname == "to_f" then
                                v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
                                return true
@@ -2259,6 +2335,21 @@ redef class AMethPropdef
                        else if pname == "to_f" then
                                v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
                                return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
                        else if pname == "ascii" then
                                v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
                                return true
@@ -2334,6 +2425,21 @@ redef class AMethPropdef
                        else if pname == "to_b" then
                                v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
                                return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
                        end
                else if cname == "NativeString" then
                        if pname == "[]" then
@@ -2358,6 +2464,456 @@ redef class AMethPropdef
                else if cname == "NativeArray" then
                        v.native_array_def(pname, ret, arguments)
                        return true
+               else if cname == "Int8" then
+                       if pname == "output" then
+                               v.add("printf(\"%\"PRIi8 \"\\n\", {arguments.first});")
+                               return true
+                       else if pname == "object_id" then
+                               v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
+                               return true
+                       else if pname == "+" then
+                               v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "-" then
+                               v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary -" then
+                               v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary +" then
+                               v.ret(arguments[0])
+                               return true
+                       else if pname == "*" then
+                               v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "/" then
+                               v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "%" then
+                               v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<<" then
+                               v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">>" then
+                               v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "==" then
+                               v.ret(v.equal_test(arguments[0], arguments[1]))
+                               return true
+                       else if pname == "!=" then
+                               var res = v.equal_test(arguments[0], arguments[1])
+                               v.ret(v.new_expr("!{res}", ret.as(not null)))
+                               return true
+                       else if pname == "<" then
+                               v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">" then
+                               v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<=" then
+                               v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">=" then
+                               v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i" then
+                               v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_b" then
+                               v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_f" then
+                               v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "ascii" then
+                               v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "&" then
+                               v.ret(v.new_expr("{arguments[0]} & {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "|" then
+                               v.ret(v.new_expr("{arguments[0]} | {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "^" then
+                               v.ret(v.new_expr("{arguments[0]} ^ {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary ~" then
+                               v.ret(v.new_expr("~{arguments[0]}", ret.as(not null)))
+                               return true
+                       end
+               else if cname == "Int16" then
+                       if pname == "output" then
+                               v.add("printf(\"%\"PRIi16 \"\\n\", {arguments.first});")
+                               return true
+                       else if pname == "object_id" then
+                               v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
+                               return true
+                       else if pname == "+" then
+                               v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "-" then
+                               v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary -" then
+                               v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary +" then
+                               v.ret(arguments[0])
+                               return true
+                       else if pname == "*" then
+                               v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "/" then
+                               v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "%" then
+                               v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<<" then
+                               v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">>" then
+                               v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "==" then
+                               v.ret(v.equal_test(arguments[0], arguments[1]))
+                               return true
+                       else if pname == "!=" then
+                               var res = v.equal_test(arguments[0], arguments[1])
+                               v.ret(v.new_expr("!{res}", ret.as(not null)))
+                               return true
+                       else if pname == "<" then
+                               v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">" then
+                               v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<=" then
+                               v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">=" then
+                               v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i" then
+                               v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_b" then
+                               v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_f" then
+                               v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "&" then
+                               v.ret(v.new_expr("{arguments[0]} & {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "|" then
+                               v.ret(v.new_expr("{arguments[0]} | {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "^" then
+                               v.ret(v.new_expr("{arguments[0]} ^ {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary ~" then
+                               v.ret(v.new_expr("~{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "ascii" then
+                               v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
+                               return true
+                       end
+               else if cname == "UInt16" then
+                       if pname == "output" then
+                               v.add("printf(\"%\"PRIu16 \"\\n\", {arguments.first});")
+                               return true
+                       else if pname == "object_id" then
+                               v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
+                               return true
+                       else if pname == "+" then
+                               v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "-" then
+                               v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary -" then
+                               v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary +" then
+                               v.ret(arguments[0])
+                               return true
+                       else if pname == "*" then
+                               v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "/" then
+                               v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "%" then
+                               v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<<" then
+                               v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">>" then
+                               v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "==" then
+                               v.ret(v.equal_test(arguments[0], arguments[1]))
+                               return true
+                       else if pname == "!=" then
+                               var res = v.equal_test(arguments[0], arguments[1])
+                               v.ret(v.new_expr("!{res}", ret.as(not null)))
+                               return true
+                       else if pname == "<" then
+                               v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">" then
+                               v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<=" then
+                               v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">=" then
+                               v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i" then
+                               v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_b" then
+                               v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_f" then
+                               v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "&" then
+                               v.ret(v.new_expr("{arguments[0]} & {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "|" then
+                               v.ret(v.new_expr("{arguments[0]} | {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "^" then
+                               v.ret(v.new_expr("{arguments[0]} ^ {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary ~" then
+                               v.ret(v.new_expr("~{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "ascii" then
+                               v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
+                               return true
+                       end
+               else if cname == "Int32" then
+                       if pname == "output" then
+                               v.add("printf(\"%\"PRIi32 \"\\n\", {arguments.first});")
+                               return true
+                       else if pname == "object_id" then
+                               v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
+                               return true
+                       else if pname == "+" then
+                               v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "-" then
+                               v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary -" then
+                               v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary +" then
+                               v.ret(arguments[0])
+                               return true
+                       else if pname == "*" then
+                               v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "/" then
+                               v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "%" then
+                               v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<<" then
+                               v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">>" then
+                               v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "==" then
+                               v.ret(v.equal_test(arguments[0], arguments[1]))
+                               return true
+                       else if pname == "!=" then
+                               var res = v.equal_test(arguments[0], arguments[1])
+                               v.ret(v.new_expr("!{res}", ret.as(not null)))
+                               return true
+                       else if pname == "<" then
+                               v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">" then
+                               v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<=" then
+                               v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">=" then
+                               v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i" then
+                               v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_b" then
+                               v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u32" then
+                               v.ret(v.new_expr("(uint32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_f" then
+                               v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "&" then
+                               v.ret(v.new_expr("{arguments[0]} & {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "|" then
+                               v.ret(v.new_expr("{arguments[0]} | {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "^" then
+                               v.ret(v.new_expr("{arguments[0]} ^ {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary ~" then
+                               v.ret(v.new_expr("~{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "ascii" then
+                               v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
+                               return true
+                       end
+               else if cname == "UInt32" then
+                       if pname == "output" then
+                               v.add("printf(\"%\"PRIu32 \"\\n\", {arguments.first});")
+                               return true
+                       else if pname == "object_id" then
+                               v.ret(v.new_expr("(long){arguments.first}", ret.as(not null)))
+                               return true
+                       else if pname == "+" then
+                               v.ret(v.new_expr("{arguments[0]} + {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "-" then
+                               v.ret(v.new_expr("{arguments[0]} - {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary -" then
+                               v.ret(v.new_expr("-{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary +" then
+                               v.ret(arguments[0])
+                               return true
+                       else if pname == "*" then
+                               v.ret(v.new_expr("{arguments[0]} * {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "/" then
+                               v.ret(v.new_expr("{arguments[0]} / {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "%" then
+                               v.ret(v.new_expr("{arguments[0]} % {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<<" then
+                               v.ret(v.new_expr("{arguments[0]} << {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">>" then
+                               v.ret(v.new_expr("{arguments[0]} >> {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "==" then
+                               v.ret(v.equal_test(arguments[0], arguments[1]))
+                               return true
+                       else if pname == "!=" then
+                               var res = v.equal_test(arguments[0], arguments[1])
+                               v.ret(v.new_expr("!{res}", ret.as(not null)))
+                               return true
+                       else if pname == "<" then
+                               v.ret(v.new_expr("{arguments[0]} < {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">" then
+                               v.ret(v.new_expr("{arguments[0]} > {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "<=" then
+                               v.ret(v.new_expr("{arguments[0]} <= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == ">=" then
+                               v.ret(v.new_expr("{arguments[0]} >= {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i" then
+                               v.ret(v.new_expr("(long){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_b" then
+                               v.ret(v.new_expr("(unsigned char){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i8" then
+                               v.ret(v.new_expr("(int8_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i16" then
+                               v.ret(v.new_expr("(int16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_u16" then
+                               v.ret(v.new_expr("(uint16_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_i32" then
+                               v.ret(v.new_expr("(int32_t){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "to_f" then
+                               v.ret(v.new_expr("(double){arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "&" then
+                               v.ret(v.new_expr("{arguments[0]} & {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "|" then
+                               v.ret(v.new_expr("{arguments[0]} | {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "^" then
+                               v.ret(v.new_expr("{arguments[0]} ^ {arguments[1]}", ret.as(not null)))
+                               return true
+                       else if pname == "unary ~" then
+                               v.ret(v.new_expr("~{arguments[0]}", ret.as(not null)))
+                               return true
+                       else if pname == "ascii" then
+                               v.ret(v.new_expr("{arguments[0]}", ret.as(not null)))
+                               return true
+                       end
                end
                if pname == "exit" then
                        v.add("exit({arguments[1]});")
@@ -2910,6 +3466,11 @@ redef class AIntegerExpr
        redef fun expr(v) do
                if value isa Int then return v.int_instance(value.as(Int))
                if value isa Byte then return v.byte_instance(value.as(Byte))
+               if value isa Int8 then return v.int8_instance(value.as(Int8))
+               if value isa Int16 then return v.int16_instance(value.as(Int16))
+               if value isa UInt16 then return v.uint16_instance(value.as(UInt16))
+               if value isa Int32 then return v.int32_instance(value.as(Int32))
+               if value isa UInt32 then return v.uint32_instance(value.as(UInt32))
                # Should never happen
                abort
        end

diff --git a/src/compiler/separate_compiler.nit b/src/compiler/separate_compiler.nit
index 9fd1606..ff5f3ba 100644 (file)
--- a/src/compiler/separate_compiler.nit
+++ b/src/compiler/separate_compiler.nit
@@ -252,7 +252,8 @@ class SeparateCompiler
        do
                # Collect all bas box class
                # FIXME: this is not completely fine with a separate compilation scheme
-               for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString", "Pointer"] do
+               for classname in ["Int", "Bool", "Byte", "Char", "Float", "NativeString",
+                                "Pointer", "Int8", "Int16", "UInt16", "Int32", "UInt32"] do
                        var classes = self.mainmodule.model.get_mclasses_by_name(classname)
                        if classes == null then continue
                        assert classes.length == 1 else print classes.join(", ")

diff --git a/src/ffi/java.nit b/src/ffi/java.nit
index dd32712..eca32ac 100644 (file)
--- a/src/ffi/java.nit
+++ b/src/ffi/java.nit
@@ -483,6 +483,11 @@ redef class MClassType
                if mclass.name == "Int" then return "long"
                if mclass.name == "Float" then return "double"
                if mclass.name == "Byte" then return "byte"
+               if mclass.name == "Int8" then return "byte"
+               if mclass.name == "Int16" then return "short"
+               if mclass.name == "UInt16" then return "short"
+               if mclass.name == "Int32" then return "int"
+               if mclass.name == "UInt32" then return "int"
                return super
        end
 
@@ -495,6 +500,11 @@ redef class MClassType
                if mclass.name == "Int" then return "jlong"
                if mclass.name == "Float" then return "jdouble"
                if mclass.name == "Byte" then return "jbyte"
+               if mclass.name == "Int8" then return "jbyte"
+               if mclass.name == "Int16" then return "jshort"
+               if mclass.name == "UInt16" then return "jshort"
+               if mclass.name == "Int32" then return "jint"
+               if mclass.name == "UInt32" then return "jint"
                return super
        end
 
@@ -555,6 +565,11 @@ redef class MClassType
                if mclass.name == "Int" then return "J"
                if mclass.name == "Float" then return "D"
                if mclass.name == "Byte" then return "B"
+               if mclass.name == "Int8" then return "B"
+               if mclass.name == "Int16" then return "S"
+               if mclass.name == "UInt16" then return "S"
+               if mclass.name == "Int32" then return "I"
+               if mclass.name == "UInt32" then return "I"
                return super
        end
 
@@ -568,6 +583,11 @@ redef class MClassType
                if mclass.name == "Int" then return "Long"
                if mclass.name == "Float" then return "Double"
                if mclass.name == "Byte" then return "Byte"
+               if mclass.name == "Int8" then return "Byte"
+               if mclass.name == "Int16" then return "Short"
+               if mclass.name == "UInt16" then return "Short"
+               if mclass.name == "Int32" then return "Int"
+               if mclass.name == "UInt32" then return "Int"
                return super
        end
 end

diff --git a/src/model/model.nit b/src/model/model.nit
index 70c635e..7812cb2 100644 (file)
--- a/src/model/model.nit
+++ b/src/model/model.nit
@@ -209,6 +209,21 @@ redef class MModule
        # The primitive type `Byte`
        var byte_type: MClassType = self.get_primitive_class("Byte").mclass_type is lazy
 
+       # The primitive type `Int8`
+       var int8_type: MClassType = self.get_primitive_class("Int8").mclass_type is lazy
+
+       # The primitive type `Int16`
+       var int16_type: MClassType = self.get_primitive_class("Int16").mclass_type is lazy
+
+       # The primitive type `UInt16`
+       var uint16_type: MClassType = self.get_primitive_class("UInt16").mclass_type is lazy
+
+       # The primitive type `Int32`
+       var int32_type: MClassType = self.get_primitive_class("Int32").mclass_type is lazy
+
+       # The primitive type `UInt32`
+       var uint32_type: MClassType = self.get_primitive_class("UInt32").mclass_type is lazy
+
        # The primitive type `Char`
        var char_type: MClassType = self.get_primitive_class("Char").mclass_type is lazy
 

diff --git a/src/modelize/modelize_property.nit b/src/modelize/modelize_property.nit
index af3ae39..97312f2 100644 (file)
--- a/src/modelize/modelize_property.nit
+++ b/src/modelize/modelize_property.nit
@@ -1341,6 +1341,16 @@ redef class AAttrPropdef
                                                cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int")
                                        else if nexpr.value isa Byte then
                                                cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Byte")
+                                       else if nexpr.value isa Int8 then
+                                               cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int8")
+                                       else if nexpr.value isa Int16 then
+                                               cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int16")
+                                       else if nexpr.value isa UInt16 then
+                                               cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt16")
+                                       else if nexpr.value isa Int32 then
+                                               cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "Int32")
+                                       else if nexpr.value isa UInt32 then
+                                               cla = modelbuilder.try_get_mclass_by_name(nexpr, mmodule, "UInt32")
                                        else
                                                # Should not happen, and should be updated as new types are added
                                                abort

diff --git a/src/nitni/nitni_base.nit b/src/nitni/nitni_base.nit
index a64c3df..a43e1d7 100644 (file)
--- a/src/nitni/nitni_base.nit
+++ b/src/nitni/nitni_base.nit
@@ -94,6 +94,11 @@ redef class MClassType
                if name == "Float" then return "double"
                if name == "Int" then return "long"
                if name == "Byte" then return "unsigned char"
+               if name == "Int8" then return "int8_t"
+               if name == "Int16" then return "int16_t"
+               if name == "UInt16" then return "uint16_t"
+               if name == "Int32" then return "int32_t"
+               if name == "UInt32" then return "uint32_t"
                if name == "NativeString" then return "char*"
                if mclass.kind == extern_kind then
                        var ctype = mclass.ctype
@@ -110,6 +115,11 @@ redef class MClassType
                if name == "Float" then return "double"
                if name == "Int" then return "long"
                if name == "Byte" then return "unsigned char"
+               if name == "Int8" then return "int8_t"
+               if name == "Int16" then return "int16_t"
+               if name == "UInt16" then return "uint16_t"
+               if name == "Int32" then return "int32_t"
+               if name == "UInt32" then return "uint32_t"
                if name == "NativeString" then return "char*"
                if mclass.kind == extern_kind then return "void*"
                return super
@@ -121,7 +131,8 @@ redef class MClassType
        redef fun mangled_cname do return mclass.name
 
        redef fun is_cprimitive do return mclass.kind == extern_kind or
-                       (once ["Bool", "Char", "Float", "Int", "NativeString", "Byte"]).has(mclass.name)
+                       (once ["Bool", "Char", "Float", "Int", "NativeString",
+                              "Byte", "Int8", "Int16", "UInt16", "Int32", "UInt32"]).has(mclass.name)
 end
 
 redef class MNullableType

diff --git a/src/rapid_type_analysis.nit b/src/rapid_type_analysis.nit
index 87e808c..9ef5320 100644 (file)
--- a/src/rapid_type_analysis.nit
+++ b/src/rapid_type_analysis.nit
@@ -213,11 +213,16 @@ class RapidTypeAnalysis
 
                # Force primitive types
                force_alive("Bool")
-               force_alive("Int")
                force_alive("Float")
                force_alive("Char")
                force_alive("Pointer")
                force_alive("Byte")
+               force_alive("Int")
+               force_alive("Int8")
+               force_alive("Int16")
+               force_alive("UInt16")
+               force_alive("Int32")
+               force_alive("UInt32")
 
                while not todo.is_empty do
                        var mmethoddef = todo.shift

diff --git a/src/semantize/typing.nit b/src/semantize/typing.nit
index b5f5d0c..935e1fc 100644 (file)
--- a/src/semantize/typing.nit
+++ b/src/semantize/typing.nit
@@ -1389,6 +1389,16 @@ redef class AIntegerExpr
                        mclass = v.get_mclass(self, "Byte")
                else if value isa Int then
                        mclass = v.get_mclass(self, "Int")
+               else if value isa Int8 then
+                       mclass = v.get_mclass(self, "Int8")
+               else if value isa Int16 then
+                       mclass = v.get_mclass(self, "Int16")
+               else if value isa UInt16 then
+                       mclass = v.get_mclass(self, "UInt16")
+               else if value isa Int32 then
+                       mclass = v.get_mclass(self, "Int32")
+               else if value isa UInt32 then
+                       mclass = v.get_mclass(self, "UInt32")
                end
                if mclass == null then return # Forward error
                self.mtype = mclass.mclass_type