1 //===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- C -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 #ifndef LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
9 #define LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
10 
11 #include "flang/Frontend/FrontendOptions.h"
12 #include "flang/Frontend/PreprocessorOptions.h"
13 #include "flang/Parser/parsing.h"
14 #include "flang/Semantics/semantics.h"
15 #include "clang/Basic/Diagnostic.h"
16 #include "clang/Basic/DiagnosticOptions.h"
17 #include "llvm/Option/ArgList.h"
18 #include <memory>
19 
20 namespace Fortran::frontend {
21 
22 /// Fill out Opts based on the options given in Args.
23 ///
24 /// When errors are encountered, return false and, if Diags is non-null,
25 /// report the error(s).
26 bool ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
27     llvm::opt::ArgList &args, bool defaultDiagColor = true);
28 
29 class CompilerInvocationBase {
30 public:
31   /// Options controlling the diagnostic engine.
32   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagnosticOpts_;
33   /// Options for the preprocessor.
34   std::shared_ptr<Fortran::frontend::PreprocessorOptions> preprocessorOpts_;
35 
36   CompilerInvocationBase();
37   CompilerInvocationBase(const CompilerInvocationBase &x);
38   ~CompilerInvocationBase();
39 
40   clang::DiagnosticOptions &GetDiagnosticOpts() {
41     return *diagnosticOpts_.get();
42   }
43   const clang::DiagnosticOptions &GetDiagnosticOpts() const {
44     return *diagnosticOpts_.get();
45   }
46 
47   PreprocessorOptions &preprocessorOpts() { return *preprocessorOpts_; }
48   const PreprocessorOptions &preprocessorOpts() const {
49     return *preprocessorOpts_;
50   }
51 };
52 
53 class CompilerInvocation : public CompilerInvocationBase {
54   /// Options for the frontend driver
55   // TODO: Merge with or translate to parserOpts_. We shouldn't need two sets of
56   // options.
57   FrontendOptions frontendOpts_;
58 
59   /// Options for Flang parser
60   // TODO: Merge with or translate to frontendOpts_. We shouldn't need two sets
61   // of options.
62   Fortran::parser::Options parserOpts_;
63 
64   // Semantics context
65   std::unique_ptr<Fortran::semantics::SemanticsContext> semanticsContext_;
66 
67   /// Semantic options
68   // TODO: Merge with or translate to frontendOpts_. We shouldn't need two sets
69   // of options.
70   std::string moduleDir_ = ".";
71 
72   bool debugModuleDir_ = false;
73 
74   bool warnAsErr_ = false;
75 
76   // Fortran Dialect options
77   Fortran::common::IntrinsicTypeDefaultKinds defaultKinds_;
78 
79   bool EnableConformanceChecks_ = false;
80 
81 public:
82   CompilerInvocation() = default;
83 
84   FrontendOptions &frontendOpts() { return frontendOpts_; }
85   const FrontendOptions &frontendOpts() const { return frontendOpts_; }
86 
87   Fortran::parser::Options &fortranOpts() { return parserOpts_; }
88   const Fortran::parser::Options &fortranOpts() const { return parserOpts_; }
89 
90   Fortran::semantics::SemanticsContext &semanticsContext() {
91     return *semanticsContext_;
92   }
93   const Fortran::semantics::SemanticsContext &semanticsContext() const {
94     return *semanticsContext_;
95   }
96 
97   std::string &moduleDir() { return moduleDir_; }
98   const std::string &moduleDir() const { return moduleDir_; }
99 
100   bool &debugModuleDir() { return debugModuleDir_; }
101   const bool &debugModuleDir() const { return debugModuleDir_; }
102 
103   bool &warnAsErr() { return warnAsErr_; }
104   const bool &warnAsErr() const { return warnAsErr_; }
105 
106   bool &enableConformanceChecks() { return EnableConformanceChecks_; }
107   const bool &enableConformanceChecks() const {
108     return EnableConformanceChecks_;
109   }
110 
111   Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() {
112     return defaultKinds_;
113   }
114   const Fortran::common::IntrinsicTypeDefaultKinds &defaultKinds() const {
115     return defaultKinds_;
116   }
117 
118   /// Create a compiler invocation from a list of input options.
119   /// \returns true on success.
120   /// \returns false if an error was encountered while parsing the arguments
121   /// \param [out] res - The resulting invocation.
122   static bool CreateFromArgs(CompilerInvocation &res,
123       llvm::ArrayRef<const char *> commandLineArgs,
124       clang::DiagnosticsEngine &diags);
125 
126   // Enables the std=f2018 conformance check
127   void set_EnableConformanceChecks() { EnableConformanceChecks_ = true; }
128 
129   /// Useful setters
130   void SetModuleDir(std::string &moduleDir) { moduleDir_ = moduleDir; }
131 
132   void SetDebugModuleDir(bool flag) { debugModuleDir_ = flag; }
133 
134   void SetWarnAsErr(bool flag) { warnAsErr_ = flag; }
135 
136   /// Set the Fortran options to predifined defaults. These defaults are
137   /// consistend with f18/f18.cpp.
138   // TODO: We should map frontendOpts_ to parserOpts_ instead. For that, we
139   // need to extend frontendOpts_ first. Next, we need to add the corresponding
140   // compiler driver options in libclangDriver.
141   void SetDefaultFortranOpts();
142 
143   /// Set the default predefinitions.
144   void setDefaultPredefinitions();
145 
146   /// Collect the macro definitions from preprocessorOpts_ and prepare them for
147   /// the parser (i.e. copy into parserOpts_)
148   void collectMacroDefinitions();
149 
150   /// Set the Fortran options to user-specified values.
151   /// These values are found in the preprocessor options.
152   void setFortranOpts();
153 
154   /// Set the Semantic Options
155   void setSemanticsOpts(Fortran::parser::AllCookedSources &);
156 };
157 
158 } // end namespace Fortran::frontend
159 #endif // LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
160