Completed OKL translation logic for dpc++.

CMakeLists.txt

@@ -19,7 +19,7 @@ if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Build type" FORCE)
 endif()
 
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED ON)
 set(CMAKE_CXX_EXTENSIONS OFF)
 

src/occa/internal/lang/expr/dpcppAccessorNode.cpp

@@ -0,0 +1,65 @@
+#include <occa/internal/lang/expr/dpcppAccessorNode.hpp>
+#include <occa/internal/utils/string.hpp>
+
+namespace occa
+{
+  namespace lang
+  {
+
+    dpcppAccessorNode::dpcppAccessorNode(token_t *token_,
+                                         const vartype_t &shared_type_,
+                                         const std::string &handler_name_)
+        : exprNode{token_}, shared_type{shared_type_}, handler_name{handler_name_}
+    {
+    }
+
+    dpcppAccessorNode::dpcppAccessorNode(const dpcppAccessorNode &node)
+    : exprNode{node.token}, shared_type{node.shared_type}, handler_name{node.handler_name}
+    {}
+
+    exprNode *dpcppAccessorNode::clone() const
+    {
+      return new dpcppAccessorNode(*this);
+    }
+
+    void dpcppAccessorNode::print(printer &pout) const
+    {
+      const arrayVector &var_dims = shared_type.arrays;
+      const std::size_t var_rank = var_dims.size();
+
+      pout << "sycl::accessor<";
+      pout << shared_type.name();
+      pout << ",";
+      pout << occa::toString(var_rank);
+      pout << ",";
+      pout << "sycl::access::mode::read_write,";
+      pout << "sycl::access::target::local>(";
+
+      if (var_rank > 0)
+      {
+        pout << "{" << *(var_dims[0].size);
+
+        if(var_rank > 1)
+          pout << "," << *(var_dims[1].size);
+
+        if(var_rank > 2)
+          pout << "," << *(var_dims[1].size);
+
+        pout<< "},";
+      }
+
+      pout << handler_name;
+      pout << ")";
+    }
+
+    void dpcppAccessorNode::debugPrint(const std::string &prefix) const
+    {
+      printer pout(io::stderr);
+      io::stderr << prefix << "|\n"
+                << prefix << "|---[";
+      pout << (*this);
+      io::stderr << "] (dpcppAccessor)\n";
+    }
+
+  } // namespace lang
+} // namespace occa

src/occa/internal/lang/expr/dpcppAccessorNode.hpp

@@ -0,0 +1,32 @@
+#ifndef OCCA_INTERNAL_LANG_EXPR_DPCPPACCESSORNODE_HEADER
+#define OCCA_INTERNAL_LANG_EXPR_DPCPPACCESSORNODE_HEADER
+
+#include <occa/internal/lang/expr/exprNode.hpp>
+
+namespace occa {
+  namespace lang {
+    class dpcppAccessorNode : public exprNode {
+    public:
+      vartype_t shared_type;
+      std::string handler_name;
+
+      dpcppAccessorNode(token_t *token_,
+                    const vartype_t& shared_type_,
+                    const std::string& handler_name_);
+
+      dpcppAccessorNode(const dpcppAccessorNode& node);
+
+      ~dpcppAccessorNode() = default;
+
+      inline udim_t type() const { return exprNodeType::dpcppAccessor; }
+
+      virtual exprNode* clone() const;
+
+      virtual void print(printer &pout) const;
+
+      virtual void debugPrint(const std::string &prefix) const;
+    };
+  }
+}
+
+#endif

src/occa/internal/lang/expr/exprNode.cpp

@@ -60,7 +60,8 @@ namespace occa {
       const udim_t parentheses       = (((uint64_t) 1) << 35);
       const udim_t tuple             = (((uint64_t) 1) << 36);
       const udim_t cudaCall          = (((uint64_t) 1) << 37);
-      const udim_t lambda	     = (((uint64_t) 1) << 38);
+      const udim_t lambda	           = (((uint64_t) 1) << 38);
+      const udim_t dpcppAccessor     = (((uint64_t) 1) << 39);
     }
 
     exprNode::exprNode(token_t *token_) :

src/occa/internal/lang/expr/exprNode.hpp

@@ -75,7 +75,8 @@ namespace occa {
       extern const udim_t tuple;
       extern const udim_t cudaCall;
       extern const udim_t lambda;
-    }
+      extern const udim_t dpcppAccessor;
+    } // namespace exprNodeType
 
     class exprNode {
     public:

src/occa/internal/lang/expr/exprNodes.hpp

@@ -8,6 +8,7 @@
 #include <occa/internal/lang/expr/constCastNode.hpp>
 #include <occa/internal/lang/expr/cudaCallNode.hpp>
 #include <occa/internal/lang/expr/deleteNode.hpp>
+#include <occa/internal/lang/expr/dpcppAccessorNode.hpp>
 #include <occa/internal/lang/expr/dynamicCastNode.hpp>
 #include <occa/internal/lang/expr/emptyNode.hpp>
 #include <occa/internal/lang/expr/exprNode.hpp>

src/occa/internal/lang/expr/lambdaNode.cpp

@@ -1,39 +1,44 @@
 #include <occa/internal/lang/expr/lambdaNode.hpp>
 
-namespace occa {
-  namespace lang {
+namespace occa
+{
+  namespace lang
+  {
     lambdaNode::lambdaNode(token_t *token_,
-                           lambda_t &value_) :
-      exprNode(token_),
-      value(value_) {}
+                           lambda_t &value_) : exprNode(token_),
+                                               value(value_) {}
 
-    lambdaNode::lambdaNode(const lambdaNode &node) :
-      exprNode(node.token),
-      value(node.value) {}
+    lambdaNode::lambdaNode(const lambdaNode &node) : exprNode(node.token),
+                                                     value(node.value) {}
 
     lambdaNode::~lambdaNode() {}
 
-    udim_t lambdaNode::type() const {
+    udim_t lambdaNode::type() const
+    {
       return exprNodeType::lambda;
     }
 
-    exprNode* lambdaNode::clone() const {
+    exprNode *lambdaNode::clone() const
+    {
       return new lambdaNode(token, value);
     }
 
-    bool lambdaNode::hasAttribute(const std::string &attr) const {
+    bool lambdaNode::hasAttribute(const std::string &attr) const
+    {
       return value.hasAttribute(attr);
     }
 
-    void lambdaNode::print(printer &pout) const {
+    void lambdaNode::print(printer &pout) const
+    {
       // pout << value;
       value.printDeclaration(pout);
     }
 
-    void lambdaNode::debugPrint(const std::string &prefix) const {
+    void lambdaNode::debugPrint(const std::string &prefix) const
+    {
       printer pout(io::stderr);
       io::stderr << prefix << "|\n"
-                << prefix << "|---[";
+                 << prefix << "|---[";
       pout << (*this);
       io::stderr << "] (lambda)\n";
     }

src/occa/internal/lang/expr/lambdaNode.hpp

@@ -2,6 +2,7 @@
 #define OCCA_INTERNAL_LANG_EXPR_LAMBDANODE_HEADER
 
 #include <occa/internal/lang/expr/exprNode.hpp>
+#include <occa/internal/lang/expr/functionNode.hpp>
 
 namespace occa {
   namespace lang {
@@ -27,6 +28,6 @@ namespace occa {
       virtual void debugPrint(const std::string &prefix) const;
     };
   }
-}
+} 
 
 #endif