Get type of integers without ending l or ll

Author: kornilova203

bindgen/defines/DefineFinder.cpp

@@ -3,6 +3,8 @@
 #include <clang/Basic/IdentifierTable.h>
 #include <clang/Lex/LiteralSupport.h>
 #include <clang/Lex/MacroInfo.h>
+#include <llvm/ADT/APInt.h>
+#include <llvm/ADT/APSInt.h>
 
 DefineFinder::DefineFinder(IR &ir, const clang::CompilerInstance &compiler,
                            clang::Preprocessor &pp)
@@ -76,18 +78,27 @@ void DefineFinder::MacroUndefined(const clang::Token &MacroNameTok,
 }
 
 void DefineFinder::addNumericConstantDefine(const std::string &macroName,
-                                            const std::string &literal,
+                                            std::string literal,
                                             const clang::Token *finalToken) {
     clang::NumericLiteralParser parser(literal, finalToken->getLocation(), pp);
     std::string type;
     if (parser.isIntegerLiteral()) {
+        std::replace(literal.begin(), literal.end(), 'l', 'L');
         if (parser.isLongLong) {
-            return;
-        }
-        if (parser.isLong) {
+            /* literal has `LL` ending but `long long` is represented as
+             * `Long` in Scala Native */
+            literal = literal.substr(0, literal.length() - 1); // remove last L
+            type = "native.CLongLong";
+        } else if (parser.isLong) {
+            /* literal already has `L` ending */
             type = "native.CLong";
         } else {
-            type = "native.CInt";
+            /* literal may not have `l` or `ll` ending but still be of long type
+             * NumericLiteralParser does not recognize that 10000000000
+             * is a long value.
+             * Therefore we need to check that value fits into certain number
+             * of bits. */
+            getTypeOfIntLiteralWithoutEnding(parser, literal, type);
         }
     } else {
         if (parser.isFloat) {
@@ -99,3 +110,45 @@ void DefineFinder::addNumericConstantDefine(const std::string &macroName,
         ir.addLiteralDefine(macroName, literal, type);
     }
 }
+
+/**
+ * Check if literal without `l` or `ll` ending fits into int or long variable.
+ *
+ * Set `literal` and `type` parameters.
+ */
+void DefineFinder::getTypeOfIntLiteralWithoutEnding(
+    clang::NumericLiteralParser parser, std::string &literal,
+    std::string &type) {
+
+    bool isSigned = llvm::APSInt(literal).isSigned();
+
+    llvm::APInt intSignedVal(4 * 8, 0, false);
+    llvm::APInt intUnsignedVal(4 * 8 - 1, 0, false);
+    /* it does not matter if APInt instance is signed or not
+     * because when calling GetIntegerValue it will check if unsigned value may
+     * fit into the full width defined in APInt */
+    if ((!isSigned && !parser.GetIntegerValue(intUnsignedVal)) ||
+        (isSigned && !parser.GetIntegerValue(intSignedVal))) {
+        type = "native.CInt";
+    } else {
+        llvm::APInt longSignedVal(8 * 8, 0, false);
+        llvm::APInt longUnsignedVal(8 * 8 - 1, 0, false);
+        if ((!isSigned && !parser.GetIntegerValue(longUnsignedVal)) ||
+            (isSigned && !parser.GetIntegerValue(longSignedVal))) {
+            type = "native.CLong";
+            literal = literal + "L";
+        } else {
+            llvm::errs() << "Waring: integer value does not fit into 8 bytes: "
+                         << literal << "\n";
+            llvm::errs().flush();
+            /**
+             * `long long` value has mostly the same size as `long`.
+             * Moreover in Scala Native the type is represented as `Long`:
+             * @code
+             * type CLongLong = Long
+             * @endcode
+             * Therefore the case of `long long` is not considered here.
+             */
+        }
+    }
+}

bindgen/defines/DefineFinder.h

@@ -3,6 +3,7 @@
 
 #include "../ir/IR.h"
 #include <clang/Frontend/CompilerInstance.h>
+#include <clang/Lex/LiteralSupport.h>
 #include <clang/Lex/PPCallbacks.h>
 #include <clang/Lex/Preprocessor.h>
 
@@ -15,7 +16,7 @@ class DefineFinder : public clang::PPCallbacks {
                       const clang::MacroDirective *MD) override;
 
     void MacroUndefined(const clang::Token &MacroNameTok,
-                        const clang::MacroDefinition &MD) override;
+                        const clang::MacroDefinition &MD);
 
   private:
     IR &ir;
@@ -25,8 +26,12 @@ class DefineFinder : public clang::PPCallbacks {
     const clang::Token *getFinalIdentifier(const clang::Token &token) const;
 
     void addNumericConstantDefine(const std::string &macroName,
-                                  const std::string &literal,
+                                  std::string literal,
                                   const clang::Token *finalToken);
+
+    void getTypeOfIntLiteralWithoutEnding(clang::NumericLiteralParser parser,
+                                          std::string &literal,
+                                          std::string &type);
 };
 
 #endif // SCALA_NATIVE_BINDGEN_DEFINEFINDER_H

tests/samples/Define.h

@@ -1,9 +1,21 @@
 #define STRING "Hello, World!"
 
-#define INT 42
-// #define LONG 10000000000 // this will fail
+#define LONG 1000000000000l
+#define LONG_WITHOUT_ENDING 1000000000000
+#define LONG_LONG 1000000000000ll
+
+/* maximum unsigned long does not fit into long type
+ * therefore warning will be printed and definition will be ignored. */
+#define MAXIMUM_UNSIGNED_LONG 18446744073709551615
+#define MAXIMUM_SIGNED_LONG 9223372036854775807 // OK
+
+/* negative values are currently ignored because there are 2 tokens in the
+ * representation */
+// #define MINIMUM_SIGNED_LONG -9223372036854775808
+
 #define FLOAT 5.6
 
+#define INT 42
 #define NEW_INT INT // unsupported
 
 extern int a;

tests/samples/Define.scala

@@ -5,7 +5,10 @@ import scala.scalanative.native._
 
 object DefineDefines {
   val STRING: native.CString = c"Hello, World!"
-  val INT = 42
-  val FLOAT = 5.6
+  val LONG: native.CLong = 1000000000000L
+  val LONG_WITHOUT_ENDING: native.CLong = 1000000000000L
+  val LONG_LONG: native.CLongLong = 1000000000000L
+  val MAXIMUM_SIGNED_LONG: native.CLong = 9223372036854775807L
+  val INT: native.CInt = 42
   val SHOULD_BE_DEFINED: native.CString = c"Because INT is not equal to 0"
 }