DirectiveNameParser.cpp

Go to the documentation of this file.

//===- DirectiveNameParser.cpp --------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
 
#include "llvm/Frontend/OpenMP/DirectiveNameParser.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Frontend/OpenMP/OMP.h"
 
#include <cassert>
#include <memory>
 
namespace llvm::omp {
DirectiveNameParser::DirectiveNameParser(SourceLanguage L) {
  // Take every directive, get its name in every version, break the name up
  // into whitespace-separated tokens, and insert each token.
  for (Directive D : directives()) {
    if (D == Directive::OMPD_unknown || !(getDirectiveLanguages(D) & L))
      continue;
    // Parse "ORDERED" as OMPD_ordered_standalone.
    if (D == OMPD_ordered_blockassoc)
      continue;
    for (Version V : getOpenMPVersions())
      insertName(getOpenMPDirectiveName(D, V), D);
  }
}
 
const DirectiveNameParser::State *
DirectiveNameParser::consume(const State *Current, StringRef Tok) const {
  if (!Current)
    return Current;
  assert(Current->isValid() && "Invalid input state");
  if (const State *Next = Current->next(Tok))
    return Next->isValid() ? Next : nullptr;
  return nullptr;
}
 
SmallVector<StringRef> DirectiveNameParser::tokenize(StringRef Str) {
  SmallVector<StringRef> Tokens;
  SplitString(Str, Tokens);
  return Tokens;
}
 
void DirectiveNameParser::insertName(StringRef Name, Directive D) {
  State *Where = &InitialState;
 
  for (StringRef Tok : tokenize(Name))
    Where = insertTransition(Where, Tok);
 
  Where->Value = D;
}
 
DirectiveNameParser::State *
DirectiveNameParser::insertTransition(State *From, StringRef Tok) {
  assert(From && "Expecting state");
  if (!From->Transition)
    From->Transition = std::make_unique<State::TransitionMapTy>();
  if (State *Next = From->next(Tok))
    return Next;
 
  auto [Where, DidIt] = From->Transition->try_emplace(Tok, State());
  assert(DidIt && "Map insertion failed");
  return &Where->second;
}
 
const DirectiveNameParser::State *
DirectiveNameParser::State::next(StringRef Tok) const {
  if (!Transition)
    return nullptr;
  auto F = Transition->find(Tok);
  return F != Transition->end() ? &F->second : nullptr;
}
 
DirectiveNameParser::State *DirectiveNameParser::State::next(StringRef Tok) {
  if (!Transition)
    return nullptr;
  auto F = Transition->find(Tok);
  return F != Transition->end() ? &F->second : nullptr;
}
} // namespace llvm::omp