FLANG
Fortran-features.h
1//===-- include/flang/Support/Fortran-features.h ----------------*- 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
9#ifndef FORTRAN_SUPPORT_FORTRAN_FEATURES_H_
10#define FORTRAN_SUPPORT_FORTRAN_FEATURES_H_
11
12#include "Fortran.h"
13#include "flang/Common/enum-set.h"
14#include <string_view>
15#include <vector>
16
17namespace Fortran::common {
18
19// Non-conforming extensions & legacies
20ENUM_CLASS(LanguageFeature, BackslashEscapes, OldDebugLines,
21 FixedFormContinuationWithColumn1Ampersand, LogicalAbbreviations,
22 XOROperator, PunctuationInNames, OptionalFreeFormSpace, BOZExtensions,
23 EmptyStatement, AlternativeNE, ExecutionPartNamelist, DECStructures,
24 DoubleComplex, Byte, StarKind, ExponentMatchingKindParam, QuadPrecision,
25 SlashInitialization, TripletInArrayConstructor, MissingColons,
26 SignedComplexLiteral, OldStyleParameter, ComplexConstructor, PercentLOC,
27 SignedMultOperand, FileName, Carriagecontrol, Convert, Dispose,
28 IOListLeadingComma, AbbreviatedEditDescriptor, ProgramParentheses,
29 PercentRefAndVal, OmitFunctionDummies, CrayPointer, Hollerith, ArithmeticIF,
30 Assign, AssignedGOTO, Pause, OpenACC, OpenMP, CUDA, CruftAfterAmpersand,
31 ClassicCComments, AdditionalFormats, BigIntLiterals, RealDoControls,
32 EquivalenceNumericWithCharacter, EquivalenceNonDefaultNumeric,
33 EquivalenceSameNonSequence, AdditionalIntrinsics, AnonymousParents,
34 OldLabelDoEndStatements, LogicalIntegerAssignment, EmptySourceFile,
35 ProgramReturn, ImplicitNoneTypeNever, ImplicitNoneTypeAlways,
36 ImplicitNoneExternal, ForwardRefImplicitNone, OpenAccessAppend,
37 BOZAsDefaultInteger, DistinguishableSpecifics, DefaultSave,
38 PointerInSeqType, NonCharacterFormat, SaveMainProgram,
39 SaveBigMainProgramVariables, DistinctArrayConstructorLengths, PPCVector,
40 RelaxedIntentInChecking, ForwardRefImplicitNoneData,
41 NullActualForAllocatable, ActualIntegerConvertedToSmallerKind,
42 HollerithOrCharacterAsBOZ, BindingAsProcedure, StatementFunctionExtensions,
43 UseGenericIntrinsicWhenSpecificDoesntMatch, DataStmtExtensions,
44 RedundantContiguous, RedundantAttribute, InitBlankCommon,
45 EmptyBindCDerivedType, MiscSourceExtensions, AllocateToOtherLength,
46 LongNames, IntrinsicAsSpecific, BenignNameClash, BenignRedundancy,
47 NullMoldAllocatableComponentValue, NopassScalarBase, MiscUseExtensions,
48 ImpliedDoIndexScope, DistinctCommonSizes, OddIndexVariableRestrictions,
49 IndistinguishableSpecifics, SubroutineAndFunctionSpecifics,
50 EmptySequenceType, NonSequenceCrayPointee, BranchIntoConstruct,
51 BadBranchTarget, HollerithPolymorphic, ListDirectedSize,
52 NonBindCInteroperability, CudaManaged, CudaUnified,
53 PolymorphicActualAllocatableOrPointerToMonomorphicDummy, RelaxedPureDummy,
54 UndefinableAsynchronousOrVolatileActual, AutomaticInMainProgram, PrintCptr,
55 SavedLocalInSpecExpr, PrintNamelist, AssumedRankPassedToNonAssumedRank,
56 IgnoreIrrelevantAttributes, Unsigned, AmbiguousStructureConstructor,
57 ContiguousOkForSeqAssociation, ForwardRefExplicitTypeDummy,
58 InaccessibleDeferredOverride, CudaWarpMatchFunction, DoConcurrentOffload,
59 TransferBOZ, Coarray)
60
61// Portability and suspicious usage warnings
62ENUM_CLASS(UsageWarning, Portability, PointerToUndefinable,
63 NonTargetPassedToTarget, PointerToPossibleNoncontiguous,
64 ShortCharacterActual, ShortArrayActual, ImplicitInterfaceActual,
65 PolymorphicTransferArg, PointerComponentTransferArg, TransferSizePresence,
66 F202XAllocatableBreakingChange, OptionalMustBePresent, CommonBlockPadding,
67 LogicalVsCBool, BindCCharLength, ProcDummyArgShapes, ExternalNameConflict,
68 FoldingException, FoldingAvoidsRuntimeCrash, FoldingValueChecks,
69 FoldingFailure, FoldingLimit, Interoperability, CharacterInteroperability,
70 Bounds, Preprocessing, Scanning, OpenAccUsage, ProcPointerCompatibility,
71 VoidMold, KnownBadImplicitInterface, EmptyCase, CaseOverflow, CUDAUsage,
72 IgnoreTKRUsage, ExternalInterfaceMismatch, DefinedOperatorArgs, Final,
73 ZeroDoStep, UnusedForallIndex, OpenMPUsage, DataLength, IgnoredDirective,
74 HomonymousSpecific, HomonymousResult, IgnoredIntrinsicFunctionType,
75 PreviousScalarUse, RedeclaredInaccessibleComponent, ImplicitShared,
76 IndexVarRedefinition, IncompatibleImplicitInterfaces, CdefinedInit,
77 VectorSubscriptFinalization, UndefinedFunctionResult, UselessIomsg,
78 MismatchingDummyProcedure, SubscriptedEmptyArray, UnsignedLiteralTruncation,
79 CompatibleDeclarationsFromDistinctModules, ConstantIsContiguous,
80 NullActualForDefaultIntentAllocatable, UseAssociationIntoSameNameSubprogram,
81 HostAssociatedIntentOutInSpecExpr, NonVolatilePointerToVolatile,
82 RealConstantWidening, VolatileOrAsynchronousTemporary)
83
86using LanguageFeatureOrWarning = std::variant<LanguageFeature, UsageWarning>;
87using LanguageControlFlag =
88 std::pair<LanguageFeatureOrWarning, /*shouldEnable=*/bool>;
89
90class LanguageFeatureControl {
91public:
92 LanguageFeatureControl();
93 LanguageFeatureControl(const LanguageFeatureControl &) = default;
94
95 void Enable(LanguageFeature f, bool yes = true) { disable_.set(f, !yes); }
96 void EnableWarning(LanguageFeature f, bool yes = true) {
97 warnLanguage_.set(f, yes);
98 }
99 void EnableWarning(UsageWarning w, bool yes = true) {
100 warnUsage_.set(w, yes);
101 }
102 void EnableWarning(LanguageFeatureOrWarning flag, bool yes = true) {
103 if (std::holds_alternative<LanguageFeature>(flag)) {
104 EnableWarning(std::get<LanguageFeature>(flag), yes);
105 } else {
106 EnableWarning(std::get<UsageWarning>(flag), yes);
107 }
108 }
109 void WarnOnAllNonstandard(bool yes = true);
110 bool IsWarnOnAllNonstandard() const { return warnAllLanguage_; }
111 void WarnOnAllUsage(bool yes = true);
112 bool IsWarnOnAllUsage() const { return warnAllUsage_; }
113 void DisableAllNonstandardWarnings() {
114 warnAllLanguage_ = false;
115 warnLanguage_.clear();
116 }
117 void DisableAllUsageWarnings() {
118 warnAllUsage_ = false;
119 warnUsage_.clear();
120 }
121 void DisableAllWarnings() {
122 disableAllWarnings_ = true;
123 DisableAllNonstandardWarnings();
124 DisableAllUsageWarnings();
125 }
126 bool AreWarningsDisabled() const { return disableAllWarnings_; }
127 bool IsEnabled(LanguageFeature f) const { return !disable_.test(f); }
128 bool ShouldWarn(LanguageFeature f) const { return warnLanguage_.test(f); }
129 bool ShouldWarn(UsageWarning w) const { return warnUsage_.test(w); }
130 // Cli options
131 // Find a warning by its Cli spelling, i.e. '[no-]warning-name'.
132 std::optional<LanguageControlFlag> FindWarning(std::string_view input);
133 // Take a string from the Cli and apply it to the LanguageFeatureControl.
134 // Return true if the option was recognized (and hence applied).
135 bool EnableWarning(std::string_view input);
136 // The add and replace functions are not currently used but are provided
137 // to allow a flexible many-to-one mapping from Cli spellings to enum values.
138 // Taking a string by value because the functions own this string after the
139 // call.
140 void AddAlternativeCliSpelling(LanguageFeature f, std::string input) {
141 cliOptions_.insert({input, {f}});
142 }
143 void AddAlternativeCliSpelling(UsageWarning w, std::string input) {
144 cliOptions_.insert({input, {w}});
145 }
146 void ReplaceCliCanonicalSpelling(LanguageFeature f, std::string input);
147 void ReplaceCliCanonicalSpelling(UsageWarning w, std::string input);
148 std::string_view getDefaultCliSpelling(LanguageFeature f) const {
149 return languageFeatureCliCanonicalSpelling_[EnumToInt(f)];
150 };
151 std::string_view getDefaultCliSpelling(UsageWarning w) const {
152 return usageWarningCliCanonicalSpelling_[EnumToInt(w)];
153 };
154 // Return all spellings of operators names, depending on features enabled
155 std::vector<const char *> GetNames(LogicalOperator) const;
156 std::vector<const char *> GetNames(RelationalOperator) const;
157
158private:
159 // Map from Cli syntax of language features and usage warnings to their enum
160 // values.
161 std::unordered_map<std::string, LanguageFeatureOrWarning> cliOptions_;
162 // These two arrays map the enum values to their cannonical Cli spellings.
163 // Since each of the CanonicalSpelling is a string in the domain of the map
164 // above we just use a view of the string instead of another copy.
165 std::array<std::string, LanguageFeature_enumSize>
166 languageFeatureCliCanonicalSpelling_;
167 std::array<std::string, UsageWarning_enumSize>
168 usageWarningCliCanonicalSpelling_;
169 LanguageFeatures disable_;
170 LanguageFeatures warnLanguage_;
171 bool warnAllLanguage_{false};
172 UsageWarnings warnUsage_;
173 bool warnAllUsage_{false};
174 bool disableAllWarnings_{false};
175};
176} // namespace Fortran::common
177#endif // FORTRAN_SUPPORT_FORTRAN_FEATURES_H_
Definition enum-set.h:28
Definition bit-population-count.h:20