Merge pull request #697 from scratchcpp/implement_generic_type_analyzer

Implement a generic type analyzer

Author: adazem009

include/scratchcpp/compiler.h

@@ -53,7 +53,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
         using Args = std::vector<CompilerValue *>;
 
         Compiler(CompilerContext *ctx);
-        Compiler(IEngine *engine, Target *target);
+        Compiler(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {});
         Compiler(const Compiler &) = delete;
 
         IEngine *engine() const;
@@ -164,7 +164,7 @@ class LIBSCRATCHCPP_EXPORT Compiler
 
         const std::unordered_set<std::string> &unsupportedBlocks() const;
 
-        static std::shared_ptr<CompilerContext> createContext(IEngine *engine, Target *target);
+        static std::shared_ptr<CompilerContext> createContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants);
 
     private:
         spimpl::unique_impl_ptr<CompilerPrivate> impl;

include/scratchcpp/compilercontext.h

@@ -2,6 +2,8 @@
 
 #pragma once
 
+#include <unordered_set>
+
 #include "global.h"
 #include "spimpl.h"
 
@@ -16,13 +18,15 @@ class CompilerContextPrivate;
 class LIBSCRATCHCPP_EXPORT CompilerContext
 {
     public:
-        CompilerContext(IEngine *engine, Target *target);
+        CompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants = {});
         CompilerContext(const CompilerContext &) = delete;
         virtual ~CompilerContext() { }
 
         IEngine *engine() const;
         Target *target() const;
 
+        const std::unordered_set<std::string> &unsafeConstants() const;
+
         /*!
          * Optimizes compiled scripts ahead of time.
          * \see Compiler#preoptimize()

src/engine/CMakeLists.txt

@@ -29,10 +29,6 @@ target_sources(scratchcpp
     thread_p.h
     internal/engine.cpp
     internal/engine.h
-    internal/icodebuilder.h
-    internal/icodebuilderfactory.h
-    internal/codebuilderfactory.cpp
-    internal/codebuilderfactory.h
     internal/clock.cpp
     internal/clock.h
     internal/iclock.h
@@ -44,4 +40,4 @@ target_sources(scratchcpp
     internal/randomgenerator.cpp
 )
 
-add_subdirectory(internal/llvm)
+add_subdirectory(internal/codegen)

src/engine/compiler.cpp

@@ -8,8 +8,8 @@
 #include <scratchcpp/inputvalue.h>
 
 #include "compiler_p.h"
-#include "internal/icodebuilderfactory.h"
-#include "internal/icodebuilder.h"
+#include "internal/codegen/icodebuilderfactory.h"
+#include "internal/codegen/icodebuilder.h"
 
 using namespace libscratchcpp;
 
@@ -20,8 +20,8 @@ Compiler::Compiler(CompilerContext *ctx) :
 }
 
 /*! Constructs Compiler using a new context for the given target. */
-Compiler::Compiler(IEngine *engine, Target *target) :
-    impl(spimpl::make_unique_impl<CompilerPrivate>(engine, target))
+Compiler::Compiler(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
+    impl(spimpl::make_unique_impl<CompilerPrivate>(engine, target, unsafeConstants))
 {
 }
 
@@ -751,8 +751,8 @@ const std::unordered_set<std::string> &Compiler::unsupportedBlocks() const
 }
 
 /*! Creates a compiler context for the given target. */
-std::shared_ptr<CompilerContext> Compiler::createContext(IEngine *engine, Target *target)
+std::shared_ptr<CompilerContext> Compiler::createContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants)
 {
     CompilerPrivate::initBuilderFactory();
-    return CompilerPrivate::builderFactory()->createCtx(engine, target);
+    return CompilerPrivate::builderFactory()->createCtx(engine, target, unsafeConstants);
 }

src/engine/compiler_p.cpp

@@ -5,8 +5,8 @@
 
 #include "compiler_p.h"
 
-#include "internal/codebuilderfactory.h"
-#include "internal/icodebuilder.h"
+#include "internal/codegen/codebuilderfactory.h"
+#include "internal/codegen/icodebuilder.h"
 
 using namespace libscratchcpp;
 
@@ -17,8 +17,8 @@ CompilerPrivate::CompilerPrivate(CompilerContext *ctx) :
     initBuilderFactory();
 }
 
-CompilerPrivate::CompilerPrivate(IEngine *engine, Target *target) :
-    ctxPtr(Compiler::createContext(engine, target)),
+CompilerPrivate::CompilerPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
+    ctxPtr(Compiler::createContext(engine, target, unsafeConstants)),
     ctx(ctxPtr.get())
 {
     initBuilderFactory();

src/engine/compiler_p.h

@@ -29,7 +29,7 @@ class LIBSCRATCHCPP_TEST_EXPORT CompilerPrivate
         };
 
         CompilerPrivate(CompilerContext *ctx);
-        CompilerPrivate(IEngine *engine, Target *target);
+        CompilerPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants);
 
         static void initBuilderFactory();
 

src/engine/compilercontext.cpp

@@ -7,8 +7,8 @@
 using namespace libscratchcpp;
 
 /*! Constructs CompilerContext. */
-CompilerContext::CompilerContext(IEngine *engine, Target *target) :
-    impl(spimpl::make_unique_impl<CompilerContextPrivate>(engine, target))
+CompilerContext::CompilerContext(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
+    impl(spimpl::make_unique_impl<CompilerContextPrivate>(engine, target, unsafeConstants))
 {
 }
 
@@ -23,3 +23,9 @@ Target *CompilerContext::target() const
 {
     return impl->target;
 }
+
+/*! Returns the list of unsafe constants (used internally during optimization). */
+const std::unordered_set<std::string> &CompilerContext::unsafeConstants() const
+{
+    return impl->unsafeConstants;
+}

src/engine/compilercontext_p.cpp

@@ -4,8 +4,9 @@
 
 using namespace libscratchcpp;
 
-CompilerContextPrivate::CompilerContextPrivate(IEngine *engine, Target *target) :
+CompilerContextPrivate::CompilerContextPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants) :
     engine(engine),
-    target(target)
+    target(target),
+    unsafeConstants(unsafeConstants)
 {
 }

src/engine/compilercontext_p.h

@@ -2,6 +2,9 @@
 
 #pragma once
 
+#include <unordered_set>
+#include <string>
+
 namespace libscratchcpp
 {
 
@@ -10,10 +13,11 @@ class Target;
 
 struct CompilerContextPrivate
 {
-        CompilerContextPrivate(IEngine *engine, Target *target);
+        CompilerContextPrivate(IEngine *engine, Target *target, const std::unordered_set<std::string> &unsafeConstants);
 
         IEngine *engine = nullptr;
         Target *target = nullptr;
+        const std::unordered_set<std::string> unsafeConstants;
 };
 
 } // namespace libscratchcpp

src/engine/internal/codegen/CMakeLists.txt

@@ -0,0 +1,18 @@
+target_sources(scratchcpp
+  PRIVATE
+    icodebuilder.h
+    icodebuilderfactory.h
+    codebuilderfactory.cpp
+    codebuilderfactory.h
+    instructionbase.h
+    instruction.h
+    instructionlistbase.cpp
+    instructionlistbase.h
+    instructionlist.h
+    codeanalyzer.cpp
+    codeanalyzer.h
+    optimizationutils.cpp
+    optimizationutils.h
+)
+
+add_subdirectory(llvm)