diff --git a/CMakeLists.txt b/CMakeLists.txt
index d8bbac6..cf2e571 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -3,6 +3,8 @@ cmake_minimum_required(VERSION 3.20)
 project(accparser)
 
 set(CMAKE_CXX_STANDARD 17)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_EXTENSIONS OFF)
 
 # Set default build type if not specified
 if(NOT CMAKE_BUILD_TYPE)
diff --git a/src/OpenACCASTConstructor.cpp b/src/OpenACCASTConstructor.cpp
index 0484851..db5345c 100644
--- a/src/OpenACCASTConstructor.cpp
+++ b/src/OpenACCASTConstructor.cpp
@@ -1,14 +1,14 @@
 #include "OpenACCASTConstructor.h"
 #include "acclexer.h"
 #include "accparser.h"
-#include <antlr4-runtime.h>
 #include <algorithm>
+#include <antlr4-runtime.h>
 #include <memory>
 
-OpenACCDirective *current_directive = NULL;
-OpenACCClause *current_clause = NULL;
-OpenACCDirective *current_parent_directive = NULL;
-OpenACCClause *current_parent_clause = NULL;
+OpenACCDirective *current_directive = nullptr;
+OpenACCClause *current_clause = nullptr;
+OpenACCDirective *current_parent_directive = nullptr;
+OpenACCClause *current_parent_clause = nullptr;
 
 static void setOpenACCLang(OpenACCDirective *directive, bool useFortran) {
   if (useFortran == true) {
@@ -18,6 +18,13 @@ static void setOpenACCLang(OpenACCDirective *directive, bool useFortran) {
   }
 }
 
+static std::string stripStringLiteral(const std::string &text) {
+  if (text.size() < 2) {
+    return text;
+  }
+  return text.substr(1, text.size() - 2);
+}
+
 void OpenACCIRConstructor::enterC_prefix(accparser::C_prefixContext *ctx) {
   setFortran(false);
 }
@@ -73,8 +80,8 @@ void OpenACCIRConstructor::exitFortran_paired_directive(
       ->setPairedDirective(current_directive);
   current_directive = current_parent_directive;
   current_clause = current_parent_clause;
-  current_parent_directive = NULL;
-  current_parent_clause = NULL;
+  current_parent_directive = nullptr;
+  current_parent_clause = nullptr;
   setOpenACCLang(current_directive, isFortran());
 }
 
@@ -224,6 +231,9 @@ void OpenACCIRConstructor::exitName_or_string(
   if (current_clause && current_clause->getKind() == ACCC_bind) {
     std::string expression = trimEnclosingWhiteSpace(ctx->getText());
     bool is_string = ctx->STRING_LITERAL() != nullptr;
+    if (is_string) {
+      expression = stripStringLiteral(expression);
+    }
     static_cast<OpenACCBindClause *>(current_clause)
         ->setBinding(expression, is_string);
   }
@@ -525,6 +535,22 @@ void OpenACCIRConstructor::enterGang_no_list_clause(
   current_clause = current_directive->addOpenACCClause(ACCC_gang);
 }
 
+void OpenACCIRConstructor::exitGang_no_list_clause(
+    accparser::Gang_no_list_clauseContext *ctx) {
+  if (!current_clause || current_clause->getKind() != ACCC_gang) {
+    return;
+  }
+  if (ctx->int_expr()) {
+    std::string value_text =
+        trimEnclosingWhiteSpace(ctx->int_expr()->getText());
+    static_cast<OpenACCGangClause *>(current_clause)
+        ->addArg(ACCC_GANG_ARG_dim,
+                 OpenACCExpressionItem{value_text, ACCC_CLAUSE_SEP_comma});
+  }
+  static_cast<OpenACCGangClause *>(current_clause)
+      ->mergeClause(current_directive, current_clause);
+}
+
 void OpenACCIRConstructor::enterHost_clause(
     accparser::Host_clauseContext *ctx) {
   current_clause = current_directive->addOpenACCClause(ACCC_host);
@@ -701,8 +727,7 @@ void OpenACCIRConstructor::enterTile_clause(
   current_clause = current_directive->addOpenACCClause(ACCC_tile);
 }
 
-void OpenACCIRConstructor::exitTile_clause(
-    accparser::Tile_clauseContext *ctx) {
+void OpenACCIRConstructor::exitTile_clause(accparser::Tile_clauseContext *ctx) {
   ((OpenACCTileClause *)current_clause)
       ->mergeClause(current_directive, current_clause);
 }
@@ -738,13 +763,14 @@ void OpenACCIRConstructor::exitVector_clause(
     accparser::Vector_clauseContext *ctx) {
   // If the vector clause had a length expression, capture it
   if (ctx->vector_clause_args() && ctx->vector_clause_args()->int_expr()) {
-    std::string expr =
-        trimEnclosingWhiteSpace(ctx->vector_clause_args()->int_expr()->getText());
+    std::string expr = trimEnclosingWhiteSpace(
+        ctx->vector_clause_args()->int_expr()->getText());
     ((OpenACCVectorClause *)current_clause)
         ->setLengthExpr(OpenACCExpressionItem{expr, ACCC_CLAUSE_SEP_comma});
     if (((OpenACCVectorClause *)current_clause)->getModifier() ==
         ACCC_VECTOR_unspecified) {
-      ((OpenACCVectorClause *)current_clause)->setModifier(ACCC_VECTOR_expr_only);
+      ((OpenACCVectorClause *)current_clause)
+          ->setModifier(ACCC_VECTOR_expr_only);
     }
   }
   ((OpenACCVectorClause *)current_clause)
@@ -759,8 +785,7 @@ void OpenACCIRConstructor::enterVector_length_clause(
 void OpenACCIRConstructor::exitVector_length_clause(
     accparser::Vector_length_clauseContext *ctx) {
   if (ctx->int_expr()) {
-    std::string expr =
-        trimEnclosingWhiteSpace(ctx->int_expr()->getText());
+    std::string expr = trimEnclosingWhiteSpace(ctx->int_expr()->getText());
     ((OpenACCVectorLengthClause *)current_clause)
         ->setLengthExpr(OpenACCExpressionItem{expr, ACCC_CLAUSE_SEP_comma});
   }
@@ -841,13 +866,14 @@ void OpenACCIRConstructor::exitWorker_clause_modifier(
 void OpenACCIRConstructor::exitWorker_clause(
     accparser::Worker_clauseContext *ctx) {
   if (ctx->worker_clause_args() && ctx->worker_clause_args()->int_expr()) {
-    std::string expr =
-        trimEnclosingWhiteSpace(ctx->worker_clause_args()->int_expr()->getText());
+    std::string expr = trimEnclosingWhiteSpace(
+        ctx->worker_clause_args()->int_expr()->getText());
     ((OpenACCWorkerClause *)current_clause)
         ->setNumExpr(OpenACCExpressionItem{expr, ACCC_CLAUSE_SEP_comma});
     if (((OpenACCWorkerClause *)current_clause)->getModifier() ==
         ACCC_WORKER_unspecified) {
-      ((OpenACCWorkerClause *)current_clause)->setModifier(ACCC_WORKER_expr_only);
+      ((OpenACCWorkerClause *)current_clause)
+          ->setModifier(ACCC_WORKER_expr_only);
     }
   }
   ((OpenACCWorkerClause *)current_clause)
@@ -1000,7 +1026,7 @@ OpenACCDirective *parseOpenACC(std::string source) {
   parser.setBuildParseTree(true);
   parser.setErrorHandler(std::make_shared<antlr4::BailErrorStrategy>());
 
-  current_directive = NULL;
+  current_directive = nullptr;
   antlr4::tree::ParseTree *tree = parser.acc();
 
   antlr4::tree::ParseTreeWalker walker;
@@ -1021,20 +1047,8 @@ void OpenACCIRConstructor::enterIndirect_clause(
     std::string text =
         trimEnclosingWhiteSpace(ctx->name_or_string()->getText());
     bool is_str = ctx->name_or_string()->STRING_LITERAL() != nullptr;
-    // Fallback: IF lexer returns EXPR for a quoted string (e.g. in expr_clause mode),
-    // detect it manually to preserve semantics.
-    if (!is_str && text.length() >= 2) {
-      if ((text.front() == '"' && text.back() == '"') ||
-          (text.front() == '\'' && text.back() == '\'')) {
-        is_str = true;
-      }
-    }
-    
-    if (is_str && text.length() >= 2) {
-      if ((text.front() == '"' && text.back() == '"') ||
-          (text.front() == '\'' && text.back() == '\'')) {
-        text = text.substr(1, text.length() - 2);
-      }
+    if (is_str) {
+      text = stripStringLiteral(text);
     }
     indirect->setValue(text, is_str);
   }
diff --git a/src/OpenACCASTConstructor.h b/src/OpenACCASTConstructor.h
index 62a5b80..0f84128 100644
--- a/src/OpenACCASTConstructor.h
+++ b/src/OpenACCASTConstructor.h
@@ -143,6 +143,8 @@ class OpenACCIRConstructor : public accparserBaseListener {
   enterNohost_clause(accparser::Nohost_clauseContext * /*ctx*/) override;
   virtual void enterGang_no_list_clause(
       accparser::Gang_no_list_clauseContext * /*ctx*/) override;
+  virtual void exitGang_no_list_clause(
+      accparser::Gang_no_list_clauseContext * /*ctx*/) override;
   virtual void
   enterHost_clause(accparser::Host_clauseContext * /*ctx*/) override;
   virtual void enterIf_clause(accparser::If_clauseContext * /*ctx*/) override;
@@ -185,8 +187,8 @@ class OpenACCIRConstructor : public accparserBaseListener {
   exitSelf_clause(accparser::Self_clauseContext * /*ctx*/) override;
   virtual void
   enterSelf_list_clause(accparser::Self_list_clauseContext * /*ctx*/) override;
-  virtual void exitSelf_list_clause(
-      accparser::Self_list_clauseContext * /*ctx*/) override;
+  virtual void
+  exitSelf_list_clause(accparser::Self_list_clauseContext * /*ctx*/) override;
   virtual void enterSeq_clause(accparser::Seq_clauseContext * /*ctx*/) override;
   virtual void
   enterTile_clause(accparser::Tile_clauseContext * /*ctx*/) override;
@@ -196,8 +198,8 @@ class OpenACCIRConstructor : public accparserBaseListener {
   enterUpdate_clause(accparser::Update_clauseContext * /*ctx*/) override;
   virtual void enterUse_device_clause(
       accparser::Use_device_clauseContext * /*ctx*/) override;
-  virtual void exitUse_device_clause(
-      accparser::Use_device_clauseContext * /*ctx*/) override;
+  virtual void
+  exitUse_device_clause(accparser::Use_device_clauseContext * /*ctx*/) override;
   virtual void
   enterVector_clause(accparser::Vector_clauseContext * /*ctx*/) override;
   virtual void exitVector_clause_modifier(
diff --git a/src/OpenACCIR.cpp b/src/OpenACCIR.cpp
index d781c49..b01d3c8 100644
--- a/src/OpenACCIR.cpp
+++ b/src/OpenACCIR.cpp
@@ -6,6 +6,21 @@
 // occurrences and ordering.
 bool OpenACCDirective::enable_clause_merging = false;
 
+OpenACCDirective::~OpenACCDirective() {
+  std::unordered_set<OpenACCClause *> unique_clauses;
+  for (const auto &entry : clauses) {
+    for (auto *clause : entry.second) {
+      unique_clauses.insert(clause);
+    }
+  }
+  for (auto *clause : clauses_in_original_order) {
+    unique_clauses.insert(clause);
+  }
+  for (auto *clause : unique_clauses) {
+    delete clause;
+  }
+}
+
 void OpenACCDataClause::addModifier(OpenACCDataClauseModifierKind modifier) {
   if (modifier == ACCC_DATA_MOD_unknown) {
     return;
@@ -42,16 +57,10 @@ void OpenACCClause::addLangExpr(const OpenACCExpressionItem &expression,
 OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
 
   OpenACCClauseKind kind = (OpenACCClauseKind)k;
-  // Check whether the given kind of clause exists first.
-  // If not, create an empty vector.
-  if (clauses.count(kind) == 0) {
-    clauses.insert(std::pair<OpenACCClauseKind, std::vector<OpenACCClause *> *>(
-        kind, new std::vector<OpenACCClause *>));
-  };
   std::vector<OpenACCClause *> *current_clauses = getClauses(kind);
   va_list args;
   va_start(args, k);
-  OpenACCClause *new_clause = NULL;
+  OpenACCClause *new_clause = nullptr;
 
   switch (kind) {
   case ACCC_auto:
@@ -64,11 +73,9 @@ OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
   case ACCC_seq:
   case ACCC_update:
   case ACCC_write: {
-    if (current_clauses->size() == 0) {
+    if (current_clauses->empty()) {
       new_clause = new OpenACCClause(kind);
-      current_clauses = new std::vector<OpenACCClause *>();
       current_clauses->push_back(new_clause);
-      clauses[kind] = current_clauses;
     } else {
       if (kind == ACCC_if) {
         std::cerr << "Cannot have two if clauses for the directive " << kind
@@ -86,12 +93,8 @@ OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
     break;
   }
   case ACCC_device_type: {
-    if (current_clauses->size() == 0 || !enable_clause_merging) {
+    if (current_clauses->empty() || !enable_clause_merging) {
       new_clause = OpenACCDeviceTypeClause::addClause(this);
-      if (current_clauses->size() == 0) {
-        current_clauses = new std::vector<OpenACCClause *>();
-        clauses[kind] = current_clauses;
-      }
       current_clauses->push_back(new_clause);
     } else {
       new_clause = current_clauses->at(0);
@@ -100,11 +103,9 @@ OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
   }
   case ACCC_gang: {
     if (this->getKind() == ACCD_routine) {
-      if (current_clauses->size() == 0) {
+      if (current_clauses->empty()) {
         new_clause = new OpenACCGangClause();
-        current_clauses = new std::vector<OpenACCClause *>();
         current_clauses->push_back(new_clause);
-        clauses[kind] = current_clauses;
       } else {
         /* we can have multiple clause and we merge them together now, thus we
          * return the object that is already created */
@@ -112,11 +113,9 @@ OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
       }
       break;
     } else {
-      if (current_clauses->size() == 0) {
+      if (current_clauses->empty()) {
         new_clause = new OpenACCGangClause();
-        current_clauses = new std::vector<OpenACCClause *>();
         current_clauses->push_back(new_clause);
-        clauses[kind] = current_clauses;
       } else {
         new_clause = new OpenACCGangClause();
         current_clauses->push_back(new_clause);
@@ -267,7 +266,7 @@ OpenACCClause *OpenACCDirective::addOpenACCClause(int k, ...) {
   };
 
   va_end(args);
-  if (new_clause != NULL && new_clause->getClausePosition() == -1) {
+  if (new_clause != nullptr && new_clause->getClausePosition() == -1) {
     this->getClausesInOriginalOrder()->push_back(new_clause);
     new_clause->setClausePosition(this->getClausesInOriginalOrder()->size() -
                                   1);
@@ -305,20 +304,10 @@ void OpenACCAsyncClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCAsyncClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_async);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCAsyncClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_async] = current_clauses;
-  } else {
-    new_clause = new OpenACCAsyncClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCAsyncClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -352,20 +341,10 @@ void OpenACCBindClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCBindClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_bind);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCBindClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_bind] = current_clauses;
-  } else {
-    new_clause = new OpenACCBindClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCBindClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -443,8 +422,7 @@ void OpenACCAttachClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCAttachClause *>(current_clause);
-  auto *existing =
-      static_cast<OpenACCAttachClause *>(current_clauses->front());
+  auto *existing = static_cast<OpenACCAttachClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -452,14 +430,11 @@ void OpenACCAttachClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCAttachClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_attach);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCAttachClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_attach] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -479,8 +454,7 @@ void OpenACCDeleteClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCDeleteClause *>(current_clause);
-  auto *existing =
-      static_cast<OpenACCDeleteClause *>(current_clauses->front());
+  auto *existing = static_cast<OpenACCDeleteClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -488,14 +462,11 @@ void OpenACCDeleteClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCDeleteClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_delete);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDeleteClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_delete] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -515,8 +486,7 @@ void OpenACCDetachClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCDetachClause *>(current_clause);
-  auto *existing =
-      static_cast<OpenACCDetachClause *>(current_clauses->front());
+  auto *existing = static_cast<OpenACCDetachClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -524,14 +494,11 @@ void OpenACCDetachClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCDetachClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_detach);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDetachClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_detach] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -548,14 +515,11 @@ void OpenACCCopyClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCCopyClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_copy);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCCopyClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_copy] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -567,21 +531,10 @@ OpenACCClause *OpenACCCopyClause::addClause(OpenACCDirective *directive) {
 
 OpenACCClause *OpenACCCopyinClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_copyin);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCCopyinClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_copyin] = current_clauses;
-  } else {
-    new_clause = new OpenACCCopyinClause();
-    current_clauses->push_back(new_clause);
-  };
+  OpenACCClause *new_clause = new OpenACCCopyinClause();
+  current_clauses->push_back(new_clause);
 
   return new_clause;
 };
@@ -610,21 +563,10 @@ void OpenACCCopyinClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCCopyoutClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_copyout);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCCopyoutClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_copyout] = current_clauses;
-  } else {
-    new_clause = new OpenACCCopyoutClause();
-    current_clauses->push_back(new_clause);
-  };
+  OpenACCClause *new_clause = new OpenACCCopyoutClause();
+  current_clauses->push_back(new_clause);
 
   return new_clause;
 };
@@ -653,21 +595,10 @@ void OpenACCCopyoutClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCCreateClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_create);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCCreateClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_create] = current_clauses;
-  } else {
-    new_clause = new OpenACCCreateClause();
-    current_clauses->push_back(new_clause);
-  };
+  OpenACCClause *new_clause = new OpenACCCreateClause();
+  current_clauses->push_back(new_clause);
 
   return new_clause;
 };
@@ -731,14 +662,11 @@ void OpenACCIndirectClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCNoCreateClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_no_create);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCNoCreateClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_no_create] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -749,14 +677,11 @@ OpenACCClause *OpenACCNoCreateClause::addClause(OpenACCDirective *directive) {
 }
 
 OpenACCClause *OpenACCPresentClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_present);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCPresentClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_present] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -767,14 +692,11 @@ OpenACCClause *OpenACCPresentClause::addClause(OpenACCDirective *directive) {
 }
 
 OpenACCClause *OpenACCLinkClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_link);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCLinkClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_link] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -786,14 +708,11 @@ OpenACCClause *OpenACCLinkClause::addClause(OpenACCDirective *directive) {
 
 OpenACCClause *
 OpenACCDeviceResidentClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_device_resident);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDeviceResidentClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_device_resident] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -813,8 +732,8 @@ void OpenACCFirstprivateClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCFirstprivateClause *>(current_clause);
-  auto *existing = static_cast<OpenACCFirstprivateClause *>(
-      current_clauses->front());
+  auto *existing =
+      static_cast<OpenACCFirstprivateClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -823,14 +742,11 @@ void OpenACCFirstprivateClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *
 OpenACCFirstprivateClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_firstprivate);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCFirstprivateClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_firstprivate] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -850,8 +766,7 @@ void OpenACCHostClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCHostClause *>(current_clause);
-  auto *existing =
-      static_cast<OpenACCHostClause *>(current_clauses->front());
+  auto *existing = static_cast<OpenACCHostClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -859,14 +774,11 @@ void OpenACCHostClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCHostClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_host);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCHostClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_host] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -895,14 +807,11 @@ void OpenACCPrivateClause::mergeClause(OpenACCDirective *directive,
 }
 
 OpenACCClause *OpenACCPrivateClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_private);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCPrivateClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_private] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -913,27 +822,18 @@ OpenACCClause *OpenACCPrivateClause::addClause(OpenACCDirective *directive) {
 }
 
 OpenACCClause *OpenACCSelfClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_self);
-  OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
-    current_clauses = new std::vector<OpenACCClause *>();
-    (*all_clauses)[ACCC_self] = current_clauses;
-  }
-  new_clause = new OpenACCSelfClause();
+  OpenACCClause *new_clause = new OpenACCSelfClause();
   current_clauses->push_back(new_clause);
   return new_clause;
 }
 
 OpenACCClause *OpenACCDeviceptrClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_deviceptr);
   OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDeviceptrClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_deviceptr] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -944,18 +844,9 @@ OpenACCClause *OpenACCDeviceptrClause::addClause(OpenACCDirective *directive) {
 }
 
 OpenACCClause *OpenACCUseDeviceClause::addClause(OpenACCDirective *directive) {
-  auto *all_clauses = directive->getAllClauses();
   auto *current_clauses = directive->getClauses(ACCC_use_device);
-  OpenACCClause *new_clause = nullptr;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCUseDeviceClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_use_device] = current_clauses;
-  } else {
-    new_clause = new OpenACCUseDeviceClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCUseDeviceClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -1005,8 +896,7 @@ void OpenACCLinkClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCLinkClause *>(current_clause);
-  auto *existing =
-      static_cast<OpenACCLinkClause *>(current_clauses->front());
+  auto *existing = static_cast<OpenACCLinkClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -1023,8 +913,8 @@ void OpenACCDeviceResidentClause::mergeClause(OpenACCDirective *directive,
     return;
   }
   auto *incoming = static_cast<OpenACCDeviceResidentClause *>(current_clause);
-  auto *existing = static_cast<OpenACCDeviceResidentClause *>(
-      current_clauses->front());
+  auto *existing =
+      static_cast<OpenACCDeviceResidentClause *>(current_clauses->front());
   mergeVarList(existing, incoming);
   current_clauses->pop_back();
   directive->getClausesInOriginalOrder()->pop_back();
@@ -1069,17 +959,13 @@ void OpenACCUseDeviceClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCDefaultClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_default);
-  OpenACCClause *new_clause = NULL;
+  OpenACCClause *new_clause = nullptr;
 
-  if (current_clauses->size() == 0) {
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDefaultClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_default] = current_clauses;
   } else { /* could be an error since default clause may only appear once */
     std::cerr << "Cannot have two default clause for the directive "
               << directive->getKind() << ", ignored\n";
@@ -1115,23 +1001,13 @@ void OpenACCDefaultAsyncClause::mergeClause(OpenACCDirective *directive,
   }
 };
 
-OpenACCClause *OpenACCDefaultAsyncClause::addClause(
-    OpenACCDirective *directive) {
+OpenACCClause *
+OpenACCDefaultAsyncClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_default_async);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCDefaultAsyncClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_default_async] = current_clauses;
-  } else {
-    new_clause = new OpenACCDefaultAsyncClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCDefaultAsyncClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -1170,16 +1046,12 @@ void OpenACCDeviceClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCDeviceClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_device);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
+  OpenACCClause *new_clause = nullptr;
+  if (current_clauses->empty()) {
     new_clause = new OpenACCDeviceClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_device] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -1216,16 +1088,12 @@ void OpenACCIfClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCIfClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_if);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
+  OpenACCClause *new_clause = nullptr;
+  if (current_clauses->empty()) {
     new_clause = new OpenACCIfClause();
-    current_clauses = new std::vector<OpenACCClause *>();
     current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_if] = current_clauses;
   } else if (OpenACCDirective::getClauseMerging()) {
     new_clause = current_clauses->at(0);
   } else {
@@ -1260,39 +1128,19 @@ void OpenACCDeviceNumClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCDeviceNumClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_device_num);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCDeviceNumClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_device_num] = current_clauses;
-  } else {
-    new_clause = new OpenACCDeviceNumClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCDeviceNumClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
 OpenACCClause *OpenACCTileClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_tile);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCTileClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_tile] = current_clauses;
-  } else {
-    new_clause = new OpenACCTileClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCTileClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -1324,38 +1172,22 @@ void OpenACCTileClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCCollapseClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_collapse);
-  OpenACCClause *new_clause = NULL;
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCCollapseClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_collapse] = current_clauses;
-  } else {
-    new_clause = new OpenACCCollapseClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCCollapseClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
 OpenACCClause *OpenACCGangClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_gang);
   OpenACCGangClause *new_clause = nullptr;
-  if (directive->getKind() == ACCD_routine && current_clauses->size() != 0) {
+  if (directive->getKind() == ACCD_routine && !current_clauses->empty()) {
     new_clause = static_cast<OpenACCGangClause *>(current_clauses->at(0));
   } else {
     new_clause = new OpenACCGangClause();
-    if (current_clauses->size() == 0) {
-      current_clauses = new std::vector<OpenACCClause *>();
-      (*all_clauses)[ACCC_gang] = current_clauses;
-    }
     current_clauses->push_back(new_clause);
   }
   return new_clause;
@@ -1452,21 +1284,10 @@ void OpenACCNumGangsClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCNumGangsClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_num_gangs);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCNumGangsClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_num_gangs] = current_clauses;
-  } else {
-    new_clause = new OpenACCNumGangsClause();
-    current_clauses->push_back(new_clause);
-  }
+  OpenACCClause *new_clause = new OpenACCNumGangsClause();
+  current_clauses->push_back(new_clause);
   return new_clause;
 }
 
@@ -1499,19 +1320,13 @@ void OpenACCNumWorkersClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCNumWorkersClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_num_workers);
-  OpenACCClause *new_clause = NULL;
-  if (directive->getKind() == ACCD_routine && current_clauses->size() != 0) {
+  OpenACCClause *new_clause = nullptr;
+  if (directive->getKind() == ACCD_routine && !current_clauses->empty()) {
     new_clause = current_clauses->at(0);
   } else {
     new_clause = new OpenACCNumWorkersClause();
-    if (current_clauses->size() == 0) {
-      current_clauses = new std::vector<OpenACCClause *>();
-      (*all_clauses)[ACCC_num_workers] = current_clauses;
-    }
     current_clauses->push_back(new_clause);
   }
 
@@ -1520,21 +1335,10 @@ OpenACCClause *OpenACCNumWorkersClause::addClause(OpenACCDirective *directive) {
 
 OpenACCClause *OpenACCReductionClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_reduction);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    new_clause = new OpenACCReductionClause();
-    current_clauses = new std::vector<OpenACCClause *>();
-    current_clauses->push_back(new_clause);
-    (*all_clauses)[ACCC_reduction] = current_clauses;
-  } else {
-    new_clause = new OpenACCReductionClause();
-    current_clauses->push_back(new_clause);
-  };
+  OpenACCClause *new_clause = new OpenACCReductionClause();
+  current_clauses->push_back(new_clause);
 
   return new_clause;
 };
@@ -1616,30 +1420,19 @@ void OpenACCSelfClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCVectorClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_vector);
-  OpenACCClause *new_clause = NULL;
+  OpenACCClause *new_clause = nullptr;
   if (directive->getKind() == ACCD_routine) {
-    if (current_clauses->size() == 0) {
+    if (current_clauses->empty()) {
       new_clause = new OpenACCVectorClause();
-      current_clauses = new std::vector<OpenACCClause *>();
       current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_vector] = current_clauses;
     } else {
       new_clause = current_clauses->at(0);
     }
   } else {
-    if (current_clauses->size() == 0) {
-      new_clause = new OpenACCVectorClause();
-      current_clauses = new std::vector<OpenACCClause *>();
-      current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_vector] = current_clauses;
-    } else {
-      new_clause = new OpenACCVectorClause();
-      current_clauses->push_back(new_clause);
-    };
+    new_clause = new OpenACCVectorClause();
+    current_clauses->push_back(new_clause);
   }
 
   return new_clause;
@@ -1671,33 +1464,22 @@ void OpenACCVectorClause::mergeClause(OpenACCDirective *directive,
   }
 };
 
-OpenACCClause *OpenACCVectorLengthClause::addClause(
-    OpenACCDirective *directive) {
+OpenACCClause *
+OpenACCVectorLengthClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_vector_length);
-  OpenACCClause *new_clause = NULL;
+  OpenACCClause *new_clause = nullptr;
   if (directive->getKind() == ACCD_routine) {
-    if (current_clauses->size() == 0) {
+    if (current_clauses->empty()) {
       new_clause = new OpenACCVectorLengthClause();
-      current_clauses = new std::vector<OpenACCClause *>();
       current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_vector_length] = current_clauses;
     } else {
       new_clause = current_clauses->at(0);
     }
   } else {
-    if (current_clauses->size() == 0) {
-      new_clause = new OpenACCVectorLengthClause();
-      current_clauses = new std::vector<OpenACCClause *>();
-      current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_vector_length] = current_clauses;
-    } else {
-      new_clause = new OpenACCVectorLengthClause();
-      current_clauses->push_back(new_clause);
-    };
+    new_clause = new OpenACCVectorLengthClause();
+    current_clauses->push_back(new_clause);
   }
 
   return new_clause;
@@ -1732,17 +1514,9 @@ void OpenACCVectorLengthClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCWaitClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_wait);
-  OpenACCClause *new_clause = NULL;
-
-  if (current_clauses->size() == 0) {
-    current_clauses = new std::vector<OpenACCClause *>();
-    (*all_clauses)[ACCC_wait] = current_clauses;
-  };
-  new_clause = new OpenACCWaitClause();
+  OpenACCClause *new_clause = new OpenACCWaitClause();
   current_clauses->push_back(new_clause);
 
   return new_clause;
@@ -1800,30 +1574,19 @@ void OpenACCWaitClause::mergeClause(OpenACCDirective *directive,
 
 OpenACCClause *OpenACCWorkerClause::addClause(OpenACCDirective *directive) {
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *all_clauses =
-      directive->getAllClauses();
   std::vector<OpenACCClause *> *current_clauses =
       directive->getClauses(ACCC_worker);
-  OpenACCClause *new_clause = NULL;
+  OpenACCClause *new_clause = nullptr;
   if (directive->getKind() == ACCD_routine) {
-    if (current_clauses->size() == 0) {
+    if (current_clauses->empty()) {
       new_clause = new OpenACCWorkerClause();
-      current_clauses = new std::vector<OpenACCClause *>();
       current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_worker] = current_clauses;
     } else {
       new_clause = current_clauses->at(0);
     }
   } else {
-    if (current_clauses->size() == 0) {
-      new_clause = new OpenACCWorkerClause();
-      current_clauses = new std::vector<OpenACCClause *>();
-      current_clauses->push_back(new_clause);
-      (*all_clauses)[ACCC_worker] = current_clauses;
-    } else {
-      new_clause = new OpenACCWorkerClause();
-      current_clauses->push_back(new_clause);
-    };
+    new_clause = new OpenACCWorkerClause();
+    current_clauses->push_back(new_clause);
   }
 
   return new_clause;
@@ -1922,8 +1685,7 @@ void OpenACCDeviceTypeClause::mergeClause(OpenACCDirective *directive,
     }
   }
   auto *current_clauses = directive->getClauses(ACCC_device_type);
-  if (!current_clauses->empty() &&
-      current_clauses->back() == merge_clause &&
+  if (!current_clauses->empty() && current_clauses->back() == merge_clause &&
       current_clauses->size() > 1) {
     current_clauses->pop_back();
   }
diff --git a/src/OpenACCIR.h b/src/OpenACCIR.h
index c8ed1c8..50d587a 100644
--- a/src/OpenACCIR.h
+++ b/src/OpenACCIR.h
@@ -4,6 +4,7 @@
 #include <fstream>
 #include <iostream>
 #include <map>
+#include <unordered_set>
 #include <vector>
 
 #include "OpenACCKinds.h"
@@ -36,8 +37,8 @@ class ACC_SourceLocation {
 
 public:
   ACC_SourceLocation(int _line = 0, int _col = 0,
-                     ACC_SourceLocation *_parent_construct = NULL)
-      : line(_line), column(_col), parent_construct(_parent_construct){};
+                     ACC_SourceLocation *_parent_construct = nullptr)
+      : line(_line), column(_col), parent_construct(_parent_construct) {};
   void setParentConstruct(ACC_SourceLocation *_parent_construct) {
     parent_construct = _parent_construct;
   };
@@ -63,7 +64,7 @@ class OpenACCClause : public ACC_SourceLocation {
 
 public:
   OpenACCClause(OpenACCClauseKind k, int _line = 0, int _col = 0)
-      : ACC_SourceLocation(_line, _col), kind(k){};
+      : ACC_SourceLocation(_line, _col), kind(k) {};
 
   OpenACCClauseKind getKind() { return kind; };
   int getClausePosition() { return clause_position; };
@@ -183,8 +184,7 @@ class OpenACCDirective : public ACC_SourceLocation {
    * the first one. Then the second one will be eliminated and not stored
    * anywhere.
    */
-  std::vector<OpenACCClause *> *clauses_in_original_order =
-      new std::vector<OpenACCClause *>();
+  std::vector<OpenACCClause *> clauses_in_original_order;
 
   /* the map to store clauses of the directive, for each clause, we store a
    * vector of OpenACCClause objects since there could be multiple clause
@@ -198,7 +198,7 @@ class OpenACCDirective : public ACC_SourceLocation {
    * should only have one OpenACCClause object for each instance of kind and
    * full parameters
    */
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> clauses;
+  std::map<OpenACCClauseKind, std::vector<OpenACCClause *>> clauses;
   /**
    *
    * This method searches the clauses map to see whether one or more
@@ -245,7 +245,7 @@ class OpenACCDirective : public ACC_SourceLocation {
   OpenACCDirective(OpenACCDirectiveKind k,
                    OpenACCBaseLang _lang = ACC_Lang_unknown, int _line = 0,
                    int _col = 0)
-      : ACC_SourceLocation(_line, _col), kind(k), lang(_lang){};
+      : ACC_SourceLocation(_line, _col), kind(k), lang(_lang) {};
 
   OpenACCDirectiveKind getKind() { return kind; };
 
@@ -253,22 +253,22 @@ class OpenACCDirective : public ACC_SourceLocation {
   static void setClauseMerging(bool enable) { enable_clause_merging = enable; }
   static bool getClauseMerging() { return enable_clause_merging; }
 
-  std::map<OpenACCClauseKind, std::vector<OpenACCClause *> *> *getAllClauses() {
+  std::map<OpenACCClauseKind, std::vector<OpenACCClause *>> *getAllClauses() {
     return &clauses;
   };
 
   std::vector<OpenACCClause *> *getClauses(OpenACCClauseKind kind) {
-    return clauses[kind];
+    return &clauses[kind];
   };
   std::vector<OpenACCClause *> *getClausesInOriginalOrder() {
-    return clauses_in_original_order;
+    return &clauses_in_original_order;
   };
 
   virtual std::string toString();
 
   /* Ensure safe polymorphic destruction when callers delete a derived
    * directive via an OpenACCDirective* pointer (tests do this). */
-  virtual ~OpenACCDirective() = default;
+  virtual ~OpenACCDirective();
 
   std::string generatePragmaString(std::string _prefix = "#pragma acc ",
                                    std::string _beginning_symbol = "",
@@ -290,7 +290,7 @@ class OpenACCCacheDirective : public OpenACCDirective {
   std::vector<OpenACCExpressionItem> vars;
 
 public:
-  OpenACCCacheDirective() : OpenACCDirective(ACCD_cache){};
+  OpenACCCacheDirective() : OpenACCDirective(ACCD_cache) {};
   OpenACCCacheDirectiveModifier getModifier() { return modifier; };
   void setModifier(OpenACCCacheDirectiveModifier _modifier) {
     modifier = _modifier;
@@ -327,7 +327,7 @@ class OpenACCEndDirective : public OpenACCDirective {
   OpenACCDirective *paired_directive;
 
 public:
-  OpenACCEndDirective() : OpenACCDirective(ACCD_end){};
+  OpenACCEndDirective() : OpenACCDirective(ACCD_end) {};
   void setPairedDirective(OpenACCDirective *_paired_directive) {
     paired_directive = _paired_directive;
   };
@@ -340,7 +340,7 @@ class OpenACCRoutineDirective : public OpenACCDirective {
   OpenACCIdentifier name;
 
 public:
-  OpenACCRoutineDirective() : OpenACCDirective(ACCD_routine){};
+  OpenACCRoutineDirective() : OpenACCDirective(ACCD_routine) {};
   void setName(std::string _name, bool is_string_literal = false) {
     name = {_name, is_string_literal};
   };
@@ -356,7 +356,7 @@ class OpenACCWaitDirective : public OpenACCDirective {
   bool queues = false;
 
 public:
-  OpenACCWaitDirective() : OpenACCDirective(ACCD_wait){};
+  OpenACCWaitDirective() : OpenACCDirective(ACCD_wait) {};
   void setDevnum(const OpenACCExpressionItem &_devnum) { devnum = _devnum; };
   void setDevnum(const std::string &_devnum,
                  OpenACCClauseSeparator sep = ACCC_CLAUSE_SEP_comma) {
@@ -387,7 +387,7 @@ class OpenACCAsyncClause : public OpenACCClause {
   OpenACCExpressionItem async_expr;
 
 public:
-  OpenACCAsyncClause() : OpenACCClause(ACCC_async){};
+  OpenACCAsyncClause() : OpenACCClause(ACCC_async) {};
 
   void setModifier(OpenACCAsyncModifier m) { modifier = m; }
   OpenACCAsyncModifier getModifier() const { return modifier; }
@@ -410,7 +410,7 @@ class OpenACCBindClause : public OpenACCClause {
   OpenACCIdentifier binding;
 
 public:
-  OpenACCBindClause() : OpenACCClause(ACCC_bind){};
+  OpenACCBindClause() : OpenACCClause(ACCC_bind) {};
 
   void setBinding(const std::string &_binding, bool _is_string_literal) {
     binding = {_binding, _is_string_literal};
@@ -432,16 +432,16 @@ class OpenACCCollapseClause : public OpenACCClause {
   bool force = false;
 
 public:
-  OpenACCCollapseClause() : OpenACCClause(ACCC_collapse){};
+  OpenACCCollapseClause() : OpenACCClause(ACCC_collapse) {};
 
-  void addCountExpr(const OpenACCExpressionItem &expr) { counts.push_back(expr); }
+  void addCountExpr(const OpenACCExpressionItem &expr) {
+    counts.push_back(expr);
+  }
   void addCountExpr(const std::string &expr,
                     OpenACCClauseSeparator sep = ACCC_CLAUSE_SEP_comma) {
     addCountExpr(OpenACCExpressionItem{expr, sep});
   }
-  const std::vector<OpenACCExpressionItem> &getCounts() const {
-    return counts;
-  }
+  const std::vector<OpenACCExpressionItem> &getCounts() const { return counts; }
   void setForce(bool f) { force = f; }
   bool isForce() const { return force; }
 
@@ -527,8 +527,7 @@ class OpenACCLinkClause : public OpenACCVarListClause {
 // Device Resident Clause
 class OpenACCDeviceResidentClause : public OpenACCVarListClause {
 public:
-  OpenACCDeviceResidentClause()
-      : OpenACCVarListClause(ACCC_device_resident) {}
+  OpenACCDeviceResidentClause() : OpenACCVarListClause(ACCC_device_resident) {}
 
   static OpenACCClause *addClause(OpenACCDirective *);
   std::string toString();
@@ -562,7 +561,7 @@ class OpenACCDefaultClause : public OpenACCClause {
   OpenACCDefaultClauseKind default_kind = ACCC_DEFAULT_unspecified;
 
 public:
-  OpenACCDefaultClause() : OpenACCClause(ACCC_default){};
+  OpenACCDefaultClause() : OpenACCClause(ACCC_default) {};
 
   OpenACCDefaultClauseKind getKind() { return default_kind; };
 
@@ -581,7 +580,7 @@ class OpenACCDefaultAsyncClause : public OpenACCClause {
   OpenACCExpressionItem async_expr;
 
 public:
-  OpenACCDefaultAsyncClause() : OpenACCClause(ACCC_default_async){};
+  OpenACCDefaultAsyncClause() : OpenACCClause(ACCC_default_async) {};
 
   void setAsyncExpr(const OpenACCExpressionItem &expr) { async_expr = expr; }
   void setAsyncExpr(const std::string &expr,
@@ -723,7 +722,7 @@ class OpenACCGangClause : public OpenACCClause {
   std::vector<GangArg> args;
 
 public:
-  OpenACCGangClause() : OpenACCClause(ACCC_gang){};
+  OpenACCGangClause() : OpenACCClause(ACCC_gang) {};
 
   void addArg(OpenACCGangArgKind kind, const OpenACCExpressionItem &value) {
     args.push_back({kind, value});
@@ -745,7 +744,7 @@ class OpenACCNumGangsClause : public OpenACCClause {
   std::vector<OpenACCExpressionItem> nums;
 
 public:
-  OpenACCNumGangsClause() : OpenACCClause(ACCC_num_gangs){};
+  OpenACCNumGangsClause() : OpenACCClause(ACCC_num_gangs) {};
 
   void addNum(const OpenACCExpressionItem &expr) { nums.push_back(expr); }
   void addNum(const std::string &expr,
@@ -766,7 +765,7 @@ class OpenACCNumWorkersClause : public OpenACCClause {
   OpenACCExpressionItem num_expr;
 
 public:
-  OpenACCNumWorkersClause() : OpenACCClause(ACCC_num_workers){};
+  OpenACCNumWorkersClause() : OpenACCClause(ACCC_num_workers) {};
 
   void setNumExpr(const OpenACCExpressionItem &expr) { num_expr = expr; }
   void setNumExpr(const std::string &expr,
@@ -832,7 +831,7 @@ class OpenACCReductionClause : public OpenACCVarListClause {
       ACCC_REDUCTION_unspecified;
 
 public:
-  OpenACCReductionClause() : OpenACCVarListClause(ACCC_reduction){};
+  OpenACCReductionClause() : OpenACCVarListClause(ACCC_reduction) {};
 
   OpenACCReductionClauseOperator getOperator() { return reduction_operator; };
 
@@ -873,7 +872,7 @@ class OpenACCVectorClause : public OpenACCClause {
   OpenACCExpressionItem length_expr;
 
 public:
-  OpenACCVectorClause() : OpenACCClause(ACCC_vector){};
+  OpenACCVectorClause() : OpenACCClause(ACCC_vector) {};
 
   OpenACCVectorClauseModifier getModifier() const { return modifier; };
 
@@ -899,7 +898,7 @@ class OpenACCVectorLengthClause : public OpenACCClause {
   OpenACCExpressionItem length_expr;
 
 public:
-  OpenACCVectorLengthClause() : OpenACCClause(ACCC_vector_length){};
+  OpenACCVectorLengthClause() : OpenACCClause(ACCC_vector_length) {};
 
   void setLengthExpr(const OpenACCExpressionItem &expr) { length_expr = expr; }
   void setLengthExpr(const std::string &expr,
@@ -922,7 +921,7 @@ class OpenACCWaitClause : public OpenACCClause {
   std::vector<OpenACCExpressionItem> async_ids;
 
 public:
-  OpenACCWaitClause() : OpenACCClause(ACCC_wait){};
+  OpenACCWaitClause() : OpenACCClause(ACCC_wait) {};
 
   void setDevnum(const OpenACCExpressionItem &_devnum) { devnum = _devnum; };
   void setDevnum(const std::string &_devnum,
@@ -932,12 +931,16 @@ class OpenACCWaitClause : public OpenACCClause {
   const OpenACCExpressionItem &getDevnum() const { return devnum; };
   void setQueues(bool _queues) { queues = _queues; };
   bool getQueues() { return queues; };
-  void addAsyncId(const OpenACCExpressionItem &expr) { async_ids.push_back(expr); }
+  void addAsyncId(const OpenACCExpressionItem &expr) {
+    async_ids.push_back(expr);
+  }
   void addAsyncId(const std::string &expr,
                   OpenACCClauseSeparator sep = ACCC_CLAUSE_SEP_comma) {
     async_ids.push_back(OpenACCExpressionItem{expr, sep});
   }
-  const std::vector<OpenACCExpressionItem> &getAsyncIds() const { return async_ids; }
+  const std::vector<OpenACCExpressionItem> &getAsyncIds() const {
+    return async_ids;
+  }
 
   static OpenACCClause *addClause(OpenACCDirective *);
   std::string toString();
@@ -975,7 +978,7 @@ class OpenACCWorkerClause : public OpenACCClause {
   OpenACCExpressionItem num_expr;
 
 public:
-  OpenACCWorkerClause() : OpenACCClause(ACCC_worker){};
+  OpenACCWorkerClause() : OpenACCClause(ACCC_worker) {};
 
   OpenACCWorkerClauseModifier getModifier() const { return modifier; };
 
diff --git a/src/OpenACCIRToString.cpp b/src/OpenACCIRToString.cpp
index 15b6011..19cf0c3 100644
--- a/src/OpenACCIRToString.cpp
+++ b/src/OpenACCIRToString.cpp
@@ -97,8 +97,7 @@ std::string OpenACCDirective::toString() {
   case ACCD_routine:
     result += "routine ";
     if (!((OpenACCRoutineDirective *)this)->getName().text.empty()) {
-      result +=
-          "(" + ((OpenACCRoutineDirective *)this)->getName().text + ") ";
+      result += "(" + ((OpenACCRoutineDirective *)this)->getName().text + ") ";
     }
     break;
   case ACCD_serial:
@@ -128,11 +127,11 @@ std::string OpenACCClause::expressionToString() const {
 
   std::string result;
   const auto *expr = this->getExpressions();
-  if (expr != NULL && !expr->empty()) {
+  if (expr != nullptr && !expr->empty()) {
     for (size_t idx = 0; idx < expr->size(); ++idx) {
       if (idx > 0) {
-        result += ((*expr)[idx].separator == ACCC_CLAUSE_SEP_comma) ? ", "
-                                                                    : " ";
+        result +=
+            ((*expr)[idx].separator == ACCC_CLAUSE_SEP_comma) ? ", " : " ";
       }
       result += (*expr)[idx].text;
     }
@@ -147,7 +146,8 @@ std::string OpenACCClause::toString() {
 
   switch (this->getKind()) {
   case ACCC_async:
-    return static_cast<OpenACCAsyncClause *>(this)->OpenACCAsyncClause::toString();
+    return static_cast<OpenACCAsyncClause *>(this)
+        ->OpenACCAsyncClause::toString();
   case ACCC_attach:
     return static_cast<OpenACCAttachClause *>(this)
         ->OpenACCAttachClause::toString();
@@ -155,7 +155,8 @@ std::string OpenACCClause::toString() {
     result += "auto ";
     break;
   case ACCC_bind:
-    return static_cast<OpenACCBindClause *>(this)->OpenACCBindClause::toString();
+    return static_cast<OpenACCBindClause *>(this)
+        ->OpenACCBindClause::toString();
   case ACCC_capture:
     result += "capture ";
     break;
@@ -169,7 +170,8 @@ std::string OpenACCClause::toString() {
     return static_cast<OpenACCCollapseClause *>(this)
         ->OpenACCCollapseClause::toString();
   case ACCC_copy:
-    return static_cast<OpenACCCopyClause *>(this)->OpenACCCopyClause::toString();
+    return static_cast<OpenACCCopyClause *>(this)
+        ->OpenACCCopyClause::toString();
   case ACCC_copyin:
     return static_cast<OpenACCCopyinClause *>(this)
         ->OpenACCCopyinClause::toString();
@@ -183,7 +185,8 @@ std::string OpenACCClause::toString() {
     return static_cast<OpenACCDefaultAsyncClause *>(this)
         ->OpenACCDefaultAsyncClause::toString();
   case ACCC_device:
-    return static_cast<OpenACCDeviceClause *>(this)->OpenACCDeviceClause::toString();
+    return static_cast<OpenACCDeviceClause *>(this)
+        ->OpenACCDeviceClause::toString();
   case ACCC_device_num:
     return static_cast<OpenACCDeviceNumClause *>(this)
         ->OpenACCDeviceNumClause::toString();
@@ -203,9 +206,11 @@ std::string OpenACCClause::toString() {
     return static_cast<OpenACCFirstprivateClause *>(this)
         ->OpenACCFirstprivateClause::toString();
   case ACCC_gang:
-    return static_cast<OpenACCGangClause *>(this)->OpenACCGangClause::toString();
+    return static_cast<OpenACCGangClause *>(this)
+        ->OpenACCGangClause::toString();
   case ACCC_host:
-    return static_cast<OpenACCHostClause *>(this)->OpenACCHostClause::toString();
+    return static_cast<OpenACCHostClause *>(this)
+        ->OpenACCHostClause::toString();
   case ACCC_if:
     return static_cast<OpenACCIfClause *>(this)->OpenACCIfClause::toString();
   case ACCC_if_present:
@@ -218,7 +223,8 @@ std::string OpenACCClause::toString() {
     return static_cast<OpenACCIndirectClause *>(this)
         ->OpenACCIndirectClause::toString();
   case ACCC_link:
-    return static_cast<OpenACCLinkClause *>(this)->OpenACCLinkClause::toString();
+    return static_cast<OpenACCLinkClause *>(this)
+        ->OpenACCLinkClause::toString();
   case ACCC_nohost:
     result += "nohost ";
     break;
@@ -241,12 +247,14 @@ std::string OpenACCClause::toString() {
     result += "read ";
     break;
   case ACCC_self:
-    return static_cast<OpenACCSelfClause *>(this)->OpenACCSelfClause::toString();
+    return static_cast<OpenACCSelfClause *>(this)
+        ->OpenACCSelfClause::toString();
   case ACCC_seq:
     result += "seq ";
     break;
   case ACCC_tile:
-    return static_cast<OpenACCTileClause *>(this)->OpenACCTileClause::toString();
+    return static_cast<OpenACCTileClause *>(this)
+        ->OpenACCTileClause::toString();
   case ACCC_update:
     result += "update ";
     break;
@@ -263,9 +271,11 @@ std::string OpenACCClause::toString() {
     result += "write ";
     break;
   case ACCC_vector:
-    return static_cast<OpenACCVectorClause *>(this)->OpenACCVectorClause::toString();
+    return static_cast<OpenACCVectorClause *>(this)
+        ->OpenACCVectorClause::toString();
   case ACCC_worker:
-    return static_cast<OpenACCWorkerClause *>(this)->OpenACCWorkerClause::toString();
+    return static_cast<OpenACCWorkerClause *>(this)
+        ->OpenACCWorkerClause::toString();
   default:
     std::cerr << "Unsupported OpenACC clause kind in toString(): "
               << this->getKind() << std::endl;
@@ -276,7 +286,8 @@ std::string OpenACCClause::toString() {
   clause_string += this->expressionToString();
   clause_string += ") ";
   if (clause_string.size() > 3) {
-    // Remove trailing space from clause name before adding parenthesized expression
+    // Remove trailing space from clause name before adding parenthesized
+    // expression
     if (!result.empty() && result.back() == ' ') {
       result.pop_back();
     }
@@ -489,8 +500,7 @@ std::string OpenACCGangClause::toString() {
   const auto &arg_list = getArgs();
   for (auto it = arg_list.begin(); it != arg_list.end(); ++it) {
     if (it != arg_list.begin()) {
-      parameter_string +=
-          (it->separator == ACCC_CLAUSE_SEP_comma) ? ", " : " ";
+      parameter_string += (it->separator == ACCC_CLAUSE_SEP_comma) ? ", " : " ";
     }
     switch (it->kind) {
     case ACCC_GANG_ARG_num:
@@ -570,7 +580,11 @@ std::string OpenACCBindClause::toString() {
 
   std::string result = "bind";
   if (!getBinding().text.empty()) {
-    result += "(" + getBinding().text + ") ";
+    std::string binding = getBinding().text;
+    if (getBinding().is_string_literal) {
+      binding = "\"" + binding + "\"";
+    }
+    result += "(" + binding + ") ";
   } else {
     result += " ";
   }
diff --git a/src/acclexer.g4 b/src/acclexer.g4
index d0c2f3d..b498ff2 100644
--- a/src/acclexer.g4
+++ b/src/acclexer.g4
@@ -398,9 +398,9 @@ LINK
 INDIRECT
    : 'indirect' [\p{White_Space}]*
    {
-      if (_input->LA(1) == '(') {
-          pushMode(expr_clause);
-      }
+  if (_input->LA(1) == '(') {
+    pushMode(bind_clause);
+  }
    }
    ;
 
@@ -1736,4 +1736,3 @@ EXPRESSION_CHAR
   }
 }
    ;
-
diff --git a/src/accparser.g4 b/src/accparser.g4
index 461e514..55a3a4b 100644
--- a/src/accparser.g4
+++ b/src/accparser.g4
@@ -22,13 +22,6 @@ options { tokenVocab = acclexer; }
 
 @ parser :: context
 {/* parser context section */}
-// Appears in the private part of the parser in the h file.
-
-// The function bodies could also appear in the definitions section, but I want to maximize
-
-// Java compatibility, so we can also create a Java parser from this grammar.
-
-// Still, some tweaking is necessary after the Java file generation (e.g. bool -> boolean).
 
 @ parser :: members
 {
@@ -168,6 +161,7 @@ data_clauses
    | copyout_clause
    | create_clause
    | default_clause
+   | device_type_clause
    | deviceptr_clause
    | if_clause
    | no_create_clause
@@ -768,6 +762,7 @@ gang_arg
 
 gang_no_list_clause
    : GANG
+   | GANG LEFT_PAREN DIM COLON int_expr RIGHT_PAREN
    ;
 
 host_clause
@@ -904,7 +899,7 @@ vector_length_clause
 
 wait_clause
    : WAIT
-   | WAIT LEFT_PAREN int_expr_list RIGHT_PAREN
+   | WAIT LEFT_PAREN wait_argument RIGHT_PAREN
    ;
 
 wait_argument_clause
diff --git a/tests/builtin/data.txt b/tests/builtin/data.txt
index 390a0d9..ff98aed 100644
--- a/tests/builtin/data.txt
+++ b/tests/builtin/data.txt
@@ -29,6 +29,8 @@
 
 #pragma acc data default(present)
 
+#pragma acc data device_type(x, y, z)
+
 #pragma acc data deviceptr(a, b, c)
 
 #pragma acc data if(5)
@@ -70,4 +72,3 @@
 #pragma acc data create( x, y, z) create( a, b, c)
 
 #pragma acc data copyin( readonly : x, y, z) copyout( zero : x, y, z) create( zero : x, y, z)
-
diff --git a/tests/builtin/data_fortran.txt b/tests/builtin/data_fortran.txt
index ecb39b5..ec7f51c 100644
--- a/tests/builtin/data_fortran.txt
+++ b/tests/builtin/data_fortran.txt
@@ -29,6 +29,8 @@
 
 !$acc data default(present)
 
+!$acc data device_type(x, y, z)
+
 !$acc data deviceptr(a, b, c)
 
 !$acc data if(5)
@@ -72,4 +74,3 @@
 !$acc data copyin( readonly : x, y, z) copyout( zero : x, y, z) create( zero : x, y, z)
 
 !$acc end data
-
diff --git a/tests/builtin/parallel.txt b/tests/builtin/parallel.txt
index 1a079b5..c82f200 100644
--- a/tests/builtin/parallel.txt
+++ b/tests/builtin/parallel.txt
@@ -31,6 +31,8 @@
 
 #pragma acc parallel wait(12, 23, 34)
 
+#pragma acc parallel wait(devnum: 2: queues: 7, 9)
+
 #pragma acc parallel copyout(12, 23, 34)
 
 #pragma acc parallel copyout(zero: 12, 23, 34)
diff --git a/tests/builtin/parallel_fortran.txt b/tests/builtin/parallel_fortran.txt
index 95db84c..641f138 100644
--- a/tests/builtin/parallel_fortran.txt
+++ b/tests/builtin/parallel_fortran.txt
@@ -31,6 +31,8 @@
 
 !$acc parallel wait(12, 23, 34)
 
+!$acc parallel wait(devnum: 2: queues: 7, 9)
+
 !$acc parallel copyout(12, 23, 34)
 
 !$acc parallel copyout(zero: 12, 23, 34)
diff --git a/tests/builtin/reference/ref_data.txt b/tests/builtin/reference/ref_data.txt
index 8878559..ba1a20b 100644
--- a/tests/builtin/reference/ref_data.txt
+++ b/tests/builtin/reference/ref_data.txt
@@ -13,6 +13,7 @@
 #pragma acc data create(zero: 12, 23, 34, zero)
 #pragma acc data create(zero: zero::12, 23, 34)
 #pragma acc data default(present)
+#pragma acc data device_type(x, y, z)
 #pragma acc data deviceptr(a, b, c)
 #pragma acc data if(5)
 #pragma acc data if(x==3)
diff --git a/tests/builtin/reference/ref_data_fortran.txt b/tests/builtin/reference/ref_data_fortran.txt
index 7d85701..498faf9 100644
--- a/tests/builtin/reference/ref_data_fortran.txt
+++ b/tests/builtin/reference/ref_data_fortran.txt
@@ -13,6 +13,7 @@
 !$acc data create(zero: 12, 23, 34, zero)
 !$acc data create(zero: zero::12, 23, 34)
 !$acc data default(present)
+!$acc data device_type(x, y, z)
 !$acc data deviceptr(a, b, c)
 !$acc data if(5)
 !$acc data if(x==3)
diff --git a/tests/builtin/reference/ref_parallel.txt b/tests/builtin/reference/ref_parallel.txt
index 25941ce..f79565d 100644
--- a/tests/builtin/reference/ref_parallel.txt
+++ b/tests/builtin/reference/ref_parallel.txt
@@ -14,6 +14,7 @@
 #pragma acc parallel present(a, b, c)
 #pragma acc parallel vector_length(512)
 #pragma acc parallel wait(12, 23, 34)
+#pragma acc parallel wait(devnum: 2: queues: 7, 9)
 #pragma acc parallel copyout(12, 23, 34)
 #pragma acc parallel copyout(zero: 12, 23, 34)
 #pragma acc parallel copyout(zero: 12, 23, 34, zero)
diff --git a/tests/builtin/reference/ref_parallel_fortran.txt b/tests/builtin/reference/ref_parallel_fortran.txt
index ff86600..421293c 100644
--- a/tests/builtin/reference/ref_parallel_fortran.txt
+++ b/tests/builtin/reference/ref_parallel_fortran.txt
@@ -14,6 +14,7 @@
 !$acc parallel present(a, b, c)
 !$acc parallel vector_length(512)
 !$acc parallel wait(12, 23, 34)
+!$acc parallel wait(devnum: 2: queues: 7, 9)
 !$acc parallel copyout(12, 23, 34)
 !$acc parallel copyout(zero: 12, 23, 34)
 !$acc parallel copyout(zero: 12, 23, 34, zero)
diff --git a/tests/builtin/reference/ref_routine.txt b/tests/builtin/reference/ref_routine.txt
index deec741..50bd2b0 100644
--- a/tests/builtin/reference/ref_routine.txt
+++ b/tests/builtin/reference/ref_routine.txt
@@ -1,4 +1,5 @@
 #pragma acc routine gang
+#pragma acc routine gang(dim:2)
 #pragma acc routine worker
 #pragma acc routine vector
 #pragma acc routine seq
diff --git a/tests/builtin/reference/ref_routine_fortran.txt b/tests/builtin/reference/ref_routine_fortran.txt
index ad0c372..c94ccae 100644
--- a/tests/builtin/reference/ref_routine_fortran.txt
+++ b/tests/builtin/reference/ref_routine_fortran.txt
@@ -1,4 +1,5 @@
 !$acc routine gang
+!$acc routine gang(dim:2)
 !$acc routine worker
 !$acc routine vector
 !$acc routine seq
diff --git a/tests/builtin/routine.txt b/tests/builtin/routine.txt
index 892d231..48d31e7 100644
--- a/tests/builtin/routine.txt
+++ b/tests/builtin/routine.txt
@@ -1,6 +1,8 @@
 
 #pragma acc routine gang
 
+#pragma acc routine gang ( dim: 2 )
+
 #pragma acc routine worker
 
 #pragma acc routine vector
diff --git a/tests/builtin/routine_fortran.txt b/tests/builtin/routine_fortran.txt
index 3025b91..741c1bd 100644
--- a/tests/builtin/routine_fortran.txt
+++ b/tests/builtin/routine_fortran.txt
@@ -1,6 +1,8 @@
 
 !$acc routine gang
 
+!$acc routine gang ( dim: 2 )
+
 !$acc routine worker
 
 !$acc routine vector