FrontendOptions.h

//===- FrontendOptions.h ----------------------------------------*- C++ -*-===//
//
// 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
//
//===----------------------------------------------------------------------===//
//
// Coding style: https://mlir.llvm.org/getting_started/DeveloperGuide/
//
//===----------------------------------------------------------------------===//
 
#ifndef FORTRAN_FRONTEND_FRONTENDOPTIONS_H
#define FORTRAN_FRONTEND_FRONTENDOPTIONS_H
 
#include "flang/Lower/EnvironmentDefault.h"
#include "flang/Parser/characters.h"
#include "flang/Parser/unparse.h"
#include "flang/Support/Fortran-features.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/MemoryBuffer.h"
#include <cstdint>
#include <optional>
#include <string>
 
namespace Fortran::frontend {
 
enum ActionKind {
  InputOutputTest,

  PrintPreprocessedInput,

  ParseSyntaxOnly,

  EmitFIR,

  EmitHLFIR,

  EmitLLVM,

  EmitLLVMBitcode,

  EmitObj,

  EmitAssembly,

  DebugUnparse,

  DebugUnparseNoSema,

  DebugUnparseWithSymbols,

  DebugUnparseWithModules,

  DebugDumpSymbols,

  DebugDumpParseTree,

  DebugDumpPFT,

  DebugDumpAll,

  DebugDumpParseTreeNoSema,

  DebugDumpProvenance,

  DebugDumpParsingLog,

  DebugMeasureParseTree,

  DebugPreFIRTree,

  GetDefinition,

  GetSymbolsSources,

  InitOnly,

  PluginAction
};

bool isFixedFormSuffix(llvm::StringRef suffix);

bool isFreeFormSuffix(llvm::StringRef suffix);

bool isToBePreprocessed(llvm::StringRef suffix);

bool isCUDAFortranSuffix(llvm::StringRef suffix);
 
enum class Language : uint8_t {
  Unknown,

  MLIR,

  LLVM_IR,

  Fortran,
};
 
// Source file layout
enum class FortranForm {
  Unknown,

  FixedForm,

  FreeForm
};

class InputKind {
private:
  Language lang;
 
public:
  enum Format { Source, ModuleMap, Precompiled };
 
  constexpr InputKind(Language l = Language::Unknown) : lang(l) {}
 
  Language getLanguage() const { return static_cast<Language>(lang); }

  bool isUnknown() const { return lang == Language::Unknown; }
};

class FrontendInputFile {
  std::string file;

  const llvm::MemoryBuffer *buffer = nullptr;

  InputKind kind;

  bool isFixedForm = false;

  unsigned mustBePreprocessed : 1;

  bool isCUDAFortran{false};
 
public:
  FrontendInputFile() = default;
  FrontendInputFile(llvm::StringRef file, InputKind inKind)
      : file(file.str()), kind(inKind) {
 
    // Based on the extension, decide whether this is a fixed or free form
    // file.
    auto pathDotIndex{file.rfind(".")};
    std::string pathSuffix{file.substr(pathDotIndex + 1)};
    isFixedForm = isFixedFormSuffix(pathSuffix);
    mustBePreprocessed = isToBePreprocessed(pathSuffix);
    isCUDAFortran = isCUDAFortranSuffix(pathSuffix);
  }
 
  FrontendInputFile(const llvm::MemoryBuffer *memBuf, InputKind inKind)
      : buffer(memBuf), kind(inKind) {}
 
  InputKind getKind() const { return kind; }
 
  bool isEmpty() const { return file.empty() && buffer == nullptr; }
  bool isFile() const { return (buffer == nullptr); }
  bool getIsFixedForm() const { return isFixedForm; }
  bool getMustBePreprocessed() const { return mustBePreprocessed; }
  bool getIsCUDAFortran() const { return isCUDAFortran; }
 
  llvm::StringRef getFile() const {
    assert(isFile());
    return file;
  }
 
  const llvm::MemoryBuffer *getBuffer() const {
    assert(buffer && "Requested buffer, but it is empty!");
    return buffer;
  }
};

struct FrontendOptions {
  FrontendOptions()
      : showHelp(false), showVersion(false), instrumentedParse(false),
        showColors(false), printSupportedCPUs(false),
        needProvenanceRangeToCharBlockMappings(false) {}

  unsigned showHelp : 1;

  unsigned showVersion : 1;

  unsigned instrumentedParse : 1;

  unsigned showColors : 1;

  unsigned printSupportedCPUs : 1;

  unsigned needProvenanceRangeToCharBlockMappings : 1;

  struct GetDefinitionVals {
    unsigned line;
    unsigned startColumn;
    unsigned endColumn;
  };
  GetDefinitionVals getDefVals;

  std::vector<FrontendInputFile> inputs;

  std::string outputFile;

  std::string dependencyOutputFile;

  std::vector<std::string> dependencyTargets;

  frontend::ActionKind programAction = ParseSyntaxOnly;
 
  // The form to process files in, if specified.
  FortranForm fortranForm = FortranForm::Unknown;
 
  // Default values for environment variables to be set by the runtime.
  std::vector<Fortran::lower::EnvironmentDefault> envDefaults;
 
  // The column after which characters are ignored in fixed form lines in the
  // source file. std::nullopt means there is no limit
  // (-ffixed-line-length=none or -ffixed-line-length=0).
  std::optional<int> fixedFormColumns = 72;

  InputKind dashX;
 
  // Language features
  common::LanguageFeatureControl features;
 
  // Source file encoding
  Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};

  std::vector<std::string> plugins;

  std::string actionName;

  std::vector<std::string> llvmArgs;

  std::vector<std::string> mlirArgs;
 
  // Return the appropriate input kind for a file extension. For example,
  static InputKind getInputKindForExtension(llvm::StringRef extension);
};
} // namespace Fortran::frontend
 
#endif // FORTRAN_FRONTEND_FRONTENDOPTIONS_H