Add support for __int128 (though not with libffi).

diff --git a/Analyze.cpp b/Analyze.cpp
index 922dfb1cd3d56d88c56ff74a6ccc23dbfb81eacd..466144d1fac5fbcafbc9875a7a41f901ce87df57 100644 (file)
--- a/Analyze.cpp
+++ b/Analyze.cpp
@@ -381,6 +381,9 @@ static void CYParseType(CXType type, CYTypedIdentifier *typed) {
         case CXType_LongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 3); break;
         case CXType_ULongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 3); break;
 
         case CXType_LongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeSigned, 3); break;
         case CXType_ULongLong: typed->specifier_ = $ CYTypeIntegral(CYTypeUnsigned, 3); break;
 

+        case CXType_Int128: typed->specifier_ = $ CYTypeInt128(CYTypeSigned); break;
+        case CXType_UInt128: typed->specifier_ = $ CYTypeInt128(CYTypeUnsigned); break;
+

         case CXType_BlockPointer: {
             CXType pointee(clang_getPointeeType(type));
             _assert(!clang_isFunctionTypeVariadic(pointee));
         case CXType_BlockPointer: {
             CXType pointee(clang_getPointeeType(type));
             _assert(!clang_isFunctionTypeVariadic(pointee));

diff --git a/Decode.cpp b/Decode.cpp
index 823e6b4b35a0d55642a16df86bec47f0939bec68..819c675b29d07c4febf0fb5cc04d147da7aac4c0 100644 (file)
--- a/Decode.cpp
+++ b/Decode.cpp
@@ -56,6 +56,13 @@ CYTypedIdentifier *Primitive<signed int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeSigned, 1));
 }
 
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeSigned, 1));
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+CYTypedIdentifier *Primitive<signed __int128>::Decode(CYPool &pool) const {
+    return $ CYTypedIdentifier($ CYTypeInt128(CYTypeSigned));
+}
+#endif
+

 template <>
 CYTypedIdentifier *Primitive<signed long int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeSigned, 2));
 template <>
 CYTypedIdentifier *Primitive<signed long int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeSigned, 2));


@@ -81,6 +88,13 @@ CYTypedIdentifier *Primitive<unsigned int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeUnsigned, 1));
 }
 
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeUnsigned, 1));
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+CYTypedIdentifier *Primitive<unsigned __int128>::Decode(CYPool &pool) const {
+    return $ CYTypedIdentifier($ CYTypeInt128(CYTypeUnsigned));
+}
+#endif
+

 template <>
 CYTypedIdentifier *Primitive<unsigned long int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeUnsigned, 2));
 template <>
 CYTypedIdentifier *Primitive<unsigned long int>::Decode(CYPool &pool) const {
     return $ CYTypedIdentifier($ CYTypeIntegral(CYTypeUnsigned, 2));

diff --git a/Execute.cpp b/Execute.cpp
index cc47fd695b299e36f38ece2daffad05257dd7fbc..36c400a1f1a0acf3b7ee0a777182b2767c202c8e 100644 (file)
--- a/Execute.cpp
+++ b/Execute.cpp
@@ -336,6 +336,11 @@ CYCastJSValue_(unsigned long int)
 CYCastJSValue_(signed long long int)
 CYCastJSValue_(unsigned long long int)
 
 CYCastJSValue_(signed long long int)
 CYCastJSValue_(unsigned long long int)
 

+#ifdef __SIZEOF_INT128__
+CYCastJSValue_(signed __int128)
+CYCastJSValue_(unsigned __int128)
+#endif
+

 JSValueRef CYJSUndefined(JSContextRef context) {
     return JSValueMakeUndefined(context);
 }
 JSValueRef CYJSUndefined(JSContextRef context) {
     return JSValueMakeUndefined(context);
 }


@@ -698,6 +703,11 @@ CYPoolFFI_(unsigned long int)
 CYPoolFFI_(unsigned long long int)
 CYPoolFFI_(unsigned short int)
 
 CYPoolFFI_(unsigned long long int)
 CYPoolFFI_(unsigned short int)
 

+#ifdef __SIZEOF_INT128__
+CYPoolFFI_(signed __int128)
+CYPoolFFI_(unsigned __int128)
+#endif
+

 void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
     _assert(false);
 }
 void Void::PoolFFI(CYPool *pool, JSContextRef context, ffi_type *ffi, void *data, JSValueRef value) const {
     _assert(false);
 }


@@ -813,6 +823,11 @@ CYFromFFI_(unsigned long int)
 CYFromFFI_(unsigned long long int)
 CYFromFFI_(unsigned short int)
 
 CYFromFFI_(unsigned long long int)
 CYFromFFI_(unsigned short int)
 

+#ifdef __SIZEOF_INT128__
+CYFromFFI_(signed __int128)
+CYFromFFI_(unsigned __int128)
+#endif
+

 JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
     return CYJSUndefined(context);
 }
 JSValueRef Void::FromFFI(JSContextRef context, ffi_type *ffi, void *data, bool initialize, JSObjectRef owner) const {
     return CYJSUndefined(context);
 }


@@ -2337,6 +2352,11 @@ extern "C" void CYSetupContext(JSGlobalContextRef context) {
     CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive<unsigned long>()), kJSPropertyAttributeDontEnum);
     CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive<unsigned long long>()), kJSPropertyAttributeDontEnum);
 
     CYSetProperty(context, cache, CYJSString("ulong"), CYMakeType(context, sig::Primitive<unsigned long>()), kJSPropertyAttributeDontEnum);
     CYSetProperty(context, cache, CYJSString("ulonglong"), CYMakeType(context, sig::Primitive<unsigned long long>()), kJSPropertyAttributeDontEnum);
 

+#ifdef __SIZEOF_INT128__
+    CYSetProperty(context, cache, CYJSString("int128"), CYMakeType(context, sig::Primitive<__int128>()), kJSPropertyAttributeDontEnum);
+    CYSetProperty(context, cache, CYJSString("uint128"), CYMakeType(context, sig::Primitive<unsigned __int128>()), kJSPropertyAttributeDontEnum);
+#endif
+

     CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum);
     CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum);
 
     CYSetProperty(context, cache, CYJSString("float"), CYMakeType(context, sig::Primitive<float>()), kJSPropertyAttributeDontEnum);
     CYSetProperty(context, cache, CYJSString("double"), CYMakeType(context, sig::Primitive<double>()), kJSPropertyAttributeDontEnum);
 

diff --git a/Output.cpp b/Output.cpp
index 06b60b22bbfa20eef73774a299a04e77f6379b9a..ae441be9b51f5d9e867f3bc187a9219802fdb145 100644 (file)
--- a/Output.cpp
+++ b/Output.cpp
@@ -1071,6 +1071,16 @@ void CYTypeError::Output(CYOutput &out) const {
     out << "@error";
 }
 
     out << "@error";
 }
 

+void CYTypeInt128::Output(CYOutput &out) const {
+    switch (signing_) {
+        case CYTypeNeutral: break;
+        case CYTypeSigned: out << "signed" << ' '; break;
+        case CYTypeUnsigned: out << "unsigned" << ' '; break;
+    }
+
+    out << "__int128";
+}
+

 void CYTypeIntegral::Output(CYOutput &out) const {
     if (signing_ == CYTypeUnsigned)
         out << "unsigned" << ' ';
 void CYTypeIntegral::Output(CYOutput &out) const {
     if (signing_ == CYTypeUnsigned)
         out << "unsigned" << ' ';

diff --git a/Parser.ypp.in b/Parser.ypp.in
index 11d8d298d8b63b779d08db133399c4b839329fe7..c2f48cef30cbda4371a395e79e6a6d14877df18e 100644 (file)
--- a/Parser.ypp.in
+++ b/Parser.ypp.in
@@ -73,6 +73,7 @@
 %union { CYParenthetical *parenthetical_; }
 %union { CYProperty *property_; }
 %union { CYPropertyName *propertyName_; }
 %union { CYParenthetical *parenthetical_; }
 %union { CYProperty *property_; }
 %union { CYPropertyName *propertyName_; }

+%union { CYTypeSigning signing_; }

 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }
 %union { CYSpan *span_; }
 %union { CYStatement *statement_; }
 %union { CYString *string_; }


@@ -424,6 +425,7 @@ type; })
 %token _goto_ "goto"
 %token _implements_ "implements"
 %token _int_ "int"
 %token _goto_ "goto"
 %token _implements_ "implements"
 %token _int_ "int"

+%token ___int128_ "__int128"

 %token _interface_ "interface"
 %token _let_ "let"
 %token _let__ "!let"
 %token _interface_ "interface"
 %token _let_ "let"
 %token _let__ "!let"


@@ -677,6 +679,7 @@ type; })
 %type <typedIdentifier_> TypeSignifier
 %type <typedIdentifier_> TypeSignifierNone
 %type <typedIdentifier_> TypeSignifierOpt
 %type <typedIdentifier_> TypeSignifier
 %type <typedIdentifier_> TypeSignifierNone
 %type <typedIdentifier_> TypeSignifierOpt

+%type <signing_> TypeSigning

 %type <modifier_> ParameterTail
 %type <modifier_> TypeQualifierLeft
 %type <modifier_> TypeQualifierLeftOpt
 %type <modifier_> ParameterTail
 %type <modifier_> TypeQualifierLeft
 %type <modifier_> TypeQualifierLeftOpt


@@ -1014,6 +1017,7 @@ IdentifierNoOf
     : IdentifierTypeNoOf
     | "char" { $$ = CYNew CYIdentifier("char"); }
     | "int" { $$ = CYNew CYIdentifier("int"); }
     : IdentifierTypeNoOf
     | "char" { $$ = CYNew CYIdentifier("char"); }
     | "int" { $$ = CYNew CYIdentifier("int"); }

+    | "__int128" { $$ = CYNew CYIdentifier("__int128"); }

     | "long" { $$ = CYNew CYIdentifier("long"); }
     | "__restrict" { $$ = CYNew CYIdentifier("__restrict"); }
     | "restrict" { $$ = CYNew CYIdentifier("restrict"); }
     | "long" { $$ = CYNew CYIdentifier("long"); }
     | "__restrict" { $$ = CYNew CYIdentifier("__restrict"); }
     | "restrict" { $$ = CYNew CYIdentifier("restrict"); }


@@ -2105,12 +2109,17 @@ StructFieldListOpt
     | { $$ = NULL; }
     ;
 
     | { $$ = NULL; }
     ;
 

+TypeSigning
+    : { $$ = CYTypeNeutral; }
+    | "signed" { $$ = CYTypeSigned; }
+    | "unsigned" { $$ = CYTypeUnsigned; }
+    ;
+

 PrimitiveType
     : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); }
     | IntegerType[pass] { $$ = $pass; }
 PrimitiveType
     : IdentifierType[name] { $$ = CYNew CYTypeVariable($name); }
     | IntegerType[pass] { $$ = $pass; }

-    | "char" { $$ = CYNew CYTypeCharacter(CYTypeNeutral); }
-    | "signed" "char" { $$ = CYNew CYTypeCharacter(CYTypeSigned); }
-    | "unsigned" "char" { $$ = CYNew CYTypeCharacter(CYTypeUnsigned); }
+    | TypeSigning[signing] "char" { $$ = CYNew CYTypeCharacter($signing); }
+    | TypeSigning[signing] "__int128" { $$ = CYNew CYTypeInt128($signing); }

     | "struct" IdentifierType[name] { $$ = CYNew CYTypeReference($name); }
     ;
 
     | "struct" IdentifierType[name] { $$ = CYNew CYTypeReference($name); }
     ;
 

diff --git a/Replace.cpp b/Replace.cpp
index df47604db724c8b5ce5b58f33ecaee71c7fa1f65..29a78a04c21b5c18c96d932d0bcdb0a07102dcd6 100644 (file)
--- a/Replace.cpp
+++ b/Replace.cpp
@@ -1245,6 +1245,10 @@ CYTarget *CYTypeExpression::Replace(CYContext &context) {
     return typed_->Replace(context);
 }
 
     return typed_->Replace(context);
 }
 

+CYTarget *CYTypeInt128::Replace(CYContext &context) {
+    return $V(signing_ == CYTypeUnsigned ? "uint128" : "int128");
+}
+

 CYTarget *CYTypeIntegral::Replace(CYContext &context) {
     bool u(signing_ == CYTypeUnsigned);
     switch (length_) {
 CYTarget *CYTypeIntegral::Replace(CYContext &context) {
     bool u(signing_ == CYTypeUnsigned);
     switch (length_) {

diff --git a/Scanner.lpp.in b/Scanner.lpp.in
index a9282649c10978a2a97ada5eb8f4e2d3a21cecc5..58cfd7d6bacb74cee7626d42ad5e05991068fbe3 100644 (file)
--- a/Scanner.lpp.in
+++ b/Scanner.lpp.in
@@ -482,6 +482,7 @@ XMLName {XMLNameStart}{XMLNamePart}*
 "Infinity"        L /*III*/ F(tk::_Infinity_, hi::Constant);
 "instanceof"      L /*KKK*/ F(tk::_instanceof_, hi::Operator);
 "int"             L /*FII*/ F(tk::_int_, hi::Type);
 "Infinity"        L /*III*/ F(tk::_Infinity_, hi::Constant);
 "instanceof"      L /*KKK*/ F(tk::_instanceof_, hi::Operator);
 "int"             L /*FII*/ F(tk::_int_, hi::Type);

+"__int128"        L /*III*/ F(tk::___int128_, hi::Type);

 "interface"       L /*FSS*/ F(tk::_interface_, hi::Meta);
 "let"             L /*IS?*/ F(tk::_let_, hi::Meta);
 "long"            L /*FII*/ F(tk::_long_, hi::Type);
 "interface"       L /*FSS*/ F(tk::_interface_, hi::Meta);
 "let"             L /*IS?*/ F(tk::_let_, hi::Meta);
 "long"            L /*FII*/ F(tk::_long_, hi::Type);

diff --git a/Syntax.hpp b/Syntax.hpp
index a0e7942708553a529b0b0bc0ba8cde0476d204dc..f16b877f5e8262edc92eefd50c041a1fe1f71427 100644 (file)
--- a/Syntax.hpp
+++ b/Syntax.hpp
@@ -2072,6 +2072,20 @@ struct CYTypeCharacter :
     virtual void Output(CYOutput &out) const;
 };
 
     virtual void Output(CYOutput &out) const;
 };
 

+struct CYTypeInt128 :
+    CYTypeSpecifier
+{
+    CYTypeSigning signing_;
+
+    CYTypeInt128(CYTypeSigning signing) :
+        signing_(signing)
+    {
+    }
+
+    virtual CYTarget *Replace(CYContext &context);
+    virtual void Output(CYOutput &out) const;
+};
+

 struct CYTypeIntegral :
     CYTypeSpecifier
 {
 struct CYTypeIntegral :
     CYTypeSpecifier
 {

diff --git a/sig/ffi_type.cpp b/sig/ffi_type.cpp
index 35700e9e598fd1e9e133540da9003004bf0b7347..ab97f7a1b489f82ae8944e9d382ba311fcac91a4 100644 (file)
--- a/sig/ffi_type.cpp
+++ b/sig/ffi_type.cpp
@@ -24,8 +24,12 @@
 #include "sig/ffi_type.hpp"
 #include "sig/types.hpp"
 
 #include "sig/ffi_type.hpp"
 #include "sig/types.hpp"
 

+#if FFI_LONG_LONG_MAX == 9223372036854775807LL

 #define ffi_type_slonglong ffi_type_sint64
 #define ffi_type_ulonglong ffi_type_uint64
 #define ffi_type_slonglong ffi_type_sint64
 #define ffi_type_ulonglong ffi_type_uint64

+#else
+#error need to configure for long long
+#endif

 
 namespace sig {
 
 
 namespace sig {
 


@@ -59,6 +63,13 @@ ffi_type *Primitive<signed int>::GetFFI(CYPool &pool) const {
     return &ffi_type_sint;
 }
 
     return &ffi_type_sint;
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+ffi_type *Primitive<signed __int128>::GetFFI(CYPool &pool) const {
+    _assert(false);
+}
+#endif
+

 template <>
 ffi_type *Primitive<signed long int>::GetFFI(CYPool &pool) const {
     return &ffi_type_slong;
 template <>
 ffi_type *Primitive<signed long int>::GetFFI(CYPool &pool) const {
     return &ffi_type_slong;


@@ -84,6 +95,13 @@ ffi_type *Primitive<unsigned int>::GetFFI(CYPool &pool) const {
     return &ffi_type_uint;
 }
 
     return &ffi_type_uint;
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+ffi_type *Primitive<unsigned __int128>::GetFFI(CYPool &pool) const {
+    _assert(false);
+}
+#endif
+

 template <>
 ffi_type *Primitive<unsigned long int>::GetFFI(CYPool &pool) const {
     return &ffi_type_ulong;
 template <>
 ffi_type *Primitive<unsigned long int>::GetFFI(CYPool &pool) const {
     return &ffi_type_ulong;

diff --git a/sig/parse.cpp b/sig/parse.cpp
index b78015dbdc17ba96414b9979fcf7602108c712a7..52a974d90d17ce6266e22d63f505cb5fd73f4db1 100644 (file)
--- a/sig/parse.cpp
+++ b/sig/parse.cpp
@@ -180,6 +180,11 @@ Type *Parse_(CYPool &pool, const char **encoding, char eos, bool named, Callback
         case 's': type = new(pool) Primitive<short>(); break;
         case 'v': type = new(pool) Void(); break;
 
         case 's': type = new(pool) Primitive<short>(); break;
         case 'v': type = new(pool) Void(); break;
 

+#ifdef __SIZEOF_INT128__
+        case 't': type = new(pool) Primitive<signed __int128>(); break;
+        case 'T': type = new(pool) Primitive<unsigned __int128>(); break;
+#endif
+

         case '{':
             type = new(pool) Aggregate(false);
             next = '}';
         case '{':
             type = new(pool) Aggregate(false);
             next = '}';


@@ -282,6 +287,13 @@ const char *Primitive<signed int>::Encode(CYPool &pool) const {
     return "i";
 }
 
     return "i";
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+const char *Primitive<signed __int128>::Encode(CYPool &pool) const {
+    return "t";
+}
+#endif
+

 template <>
 const char *Primitive<signed long int>::Encode(CYPool &pool) const {
     return "l";
 template <>
 const char *Primitive<signed long int>::Encode(CYPool &pool) const {
     return "l";


@@ -307,6 +319,13 @@ const char *Primitive<unsigned int>::Encode(CYPool &pool) const {
     return "I";
 }
 
     return "I";
 }
 

+#ifdef __SIZEOF_INT128__
+template <>
+const char *Primitive<unsigned __int128>::Encode(CYPool &pool) const {
+    return "T";
+}
+#endif
+

 template <>
 const char *Primitive<unsigned long int>::Encode(CYPool &pool) const {
     return "L";
 template <>
 const char *Primitive<unsigned long int>::Encode(CYPool &pool) const {
     return "L";