This is an archive of the discontinued LLVM Phabricator instance.

Differential D85164

[flang] Make preprocessing behavior tests runnable as regression tests
ClosedPublic

Authored by klausler on Aug 3 2020, 2:54 PM.

Details

Reviewers
sscalpone
tskeith
PeteSteinfeld
jdoerfert
DavidTruby
Commits
rG089adc339e7d: [flang] Make preprocessing behavior tests runnable as regression tests
Summary

And fix a minor bug exposed by doing so.

Diff Detail

Event Timeline

klausler created this revision.Aug 3 2020, 2:54 PM
Herald added a reviewer: jdoerfert. · View Herald TranscriptAug 3 2020, 2:54 PM
Herald added a reviewer: DavidTruby. · View Herald Transcript
Herald added a project: Restricted Project. · View Herald Transcript
Herald added a subscriber: llvm-commits. · View Herald Transcript
klausler requested review of this revision.Aug 3 2020, 2:54 PM
tskeith accepted this revision.Aug 3 2020, 2:58 PM
This revision is now accepted and ready to land.Aug 3 2020, 2:58 PM
This revision was landed with ongoing or failed builds.Aug 3 2020, 3:08 PM
Closed by commit rG089adc339e7d: [flang] Make preprocessing behavior tests runnable as regression tests (authored by klausler). · Explain Why
This revision was automatically updated to reflect the committed changes.
klausler added a commit: rG089adc339e7d: [flang] Make preprocessing behavior tests runnable as regression tests.
Harbormaster completed remote builds in B66842: Diff 282736.Aug 3 2020, 3:36 PM

Revision Contents

PathSize
flang/
lib/
Parser/
2 lines
2 lines
30 lines
test/
Preprocessing/
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
7 lines
7 lines
7 lines
7 lines
6 lines
6 lines
7 lines
6 lines
6 lines
6 lines
5 lines
7 lines
7 lines
7 lines
7 lines
7 lines
7 lines
6 lines
8 lines
4 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
7 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
6 lines
4 lines
6 lines

Diff 282739

flang/lib/Parser/preprocessor.h

Show First 20 Lines • Show All 61 Lines • ▼ Show 20 Lines
// Preprocessing state // Preprocessing state
class Preprocessor { class Preprocessor {
public: public:
explicit Preprocessor(AllSources &); explicit Preprocessor(AllSources &);
void Define(std::string macro, std::string value); void Define(std::string macro, std::string value);
void Undefine(std::string macro); void Undefine(std::string macro);
bool IsNameDefined(const CharBlock &);
std::optional<TokenSequence> MacroReplacement( std::optional<TokenSequence> MacroReplacement(
const TokenSequence &, const Prescanner &); const TokenSequence &, const Prescanner &);
// Implements a preprocessor directive. // Implements a preprocessor directive.
void Directive(const TokenSequence &, Prescanner *); void Directive(const TokenSequence &, Prescanner *);
private: private:
enum class IsElseActive { No, Yes }; enum class IsElseActive { No, Yes };
enum class CanDeadElseAppear { No, Yes }; enum class CanDeadElseAppear { No, Yes };
CharBlock SaveTokenAsName(const CharBlock &); CharBlock SaveTokenAsName(const CharBlock &);
bool IsNameDefined(const CharBlock &);
TokenSequence ReplaceMacros(const TokenSequence &, const Prescanner &); TokenSequence ReplaceMacros(const TokenSequence &, const Prescanner &);
void SkipDisabledConditionalCode( void SkipDisabledConditionalCode(
const std::string &, IsElseActive, Prescanner *, ProvenanceRange); const std::string &, IsElseActive, Prescanner *, ProvenanceRange);
bool IsIfPredicateTrue(const TokenSequence &expr, std::size_t first, bool IsIfPredicateTrue(const TokenSequence &expr, std::size_t first,
std::size_t exprTokens, Prescanner *); std::size_t exprTokens, Prescanner *);
AllSources &allSources_; AllSources &allSources_;
std::list<std::string> names_; std::list<std::string> names_;
std::unordered_map<CharBlock, Definition> definitions_; std::unordered_map<CharBlock, Definition> definitions_;
std::stack<CanDeadElseAppear> ifStack_; std::stack<CanDeadElseAppear> ifStack_;
}; };
} // namespace Fortran::parser } // namespace Fortran::parser
#endif // FORTRAN_PARSER_PREPROCESSOR_H_ #endif // FORTRAN_PARSER_PREPROCESSOR_H_

flang/lib/Parser/preprocessor.cpp

Show First 20 Lines • Show All 206 Lines • ▼ Show 20 LinesPreprocessor::Preprocessor(AllSources &allSources) : allSources_{allSources} {
// The values of these predefined macros depend on their invocation sites. // The values of these predefined macros depend on their invocation sites.
definitions_.emplace( definitions_.emplace(
SaveTokenAsName("__FILE__"s), Definition{"__FILE__"s, allSources}); SaveTokenAsName("__FILE__"s), Definition{"__FILE__"s, allSources});
definitions_.emplace( definitions_.emplace(
SaveTokenAsName("__LINE__"s), Definition{"__LINE__"s, allSources}); SaveTokenAsName("__LINE__"s), Definition{"__LINE__"s, allSources});
} }
void Preprocessor::Define(std::string macro, std::string value) { void Preprocessor::Define(std::string macro, std::string value) {
definitions_.emplace(SaveTokenAsName(macro), Definition{value, allSources_}); definitions_.emplace(macro, Definition{value, allSources_});
} }
void Preprocessor::Undefine(std::string macro) { definitions_.erase(macro); } void Preprocessor::Undefine(std::string macro) { definitions_.erase(macro); }
std::optional<TokenSequence> Preprocessor::MacroReplacement( std::optional<TokenSequence> Preprocessor::MacroReplacement(
const TokenSequence &input, const Prescanner &prescanner) { const TokenSequence &input, const Prescanner &prescanner) {
// Do quick scan for any use of a defined name. // Do quick scan for any use of a defined name.
std::size_t tokens{input.SizeInTokens()}; std::size_t tokens{input.SizeInTokens()};
▲ Show 20 Lines • Show All 827 Lines • Show Last 20 Lines

flang/lib/Parser/prescan.cpp

Show First 20 Lines • Show All 240 Lines • ▼ Show 20 Lines if (!v) {
nextLine_ = limit_; nextLine_ = limit_;
} else { } else {
const char *nl{const_cast<const char *>(static_cast<char *>(v))}; const char *nl{const_cast<const char *>(static_cast<char *>(v))};
nextLine_ = nl + 1; nextLine_ = nl + 1;
} }
} }
void Prescanner::LabelField(TokenSequence &token, int outCol) { void Prescanner::LabelField(TokenSequence &token, int outCol) {
bool badLabel{false}; const char *bad{nullptr};
for (; *at_ != '\n' && column_ <= 6; ++at_) { for (; *at_ != '\n' && column_ <= 6; ++at_) {
if (*at_ == '\t') { if (*at_ == '\t') {
++at_; ++at_;
column_ = 7; column_ = 7;
break; break;
} }
if (*at_ != ' ' && if (*at_ != ' ' &&
!(*at_ == '0' && column_ == 6)) { // '0' in column 6 becomes space !(*at_ == '0' && column_ == 6)) { // '0' in column 6 becomes space
EmitChar(token, *at_); EmitChar(token, *at_);
if (!IsDecimalDigit(*at_) && !badLabel) { if (!bad && !IsDecimalDigit(*at_)) {
Say(GetProvenance(at_), bad = at_;
"Character in fixed-form label field must be a digit"_en_US);
badLabel = true;
} }
++outCol; ++outCol;
} }
++column_; ++column_;
} }
if (outCol > 1) { if (outCol > 1) {
if (bad && !preprocessor_.IsNameDefined(token.CurrentOpenToken())) {
Say(GetProvenance(bad),
"Character in fixed-form label field must be a digit"_en_US);
}
token.CloseToken(); token.CloseToken();
} }
SkipToNextSignificantCharacter(); SkipToNextSignificantCharacter();
if (IsDecimalDigit(*at_)) { if (IsDecimalDigit(*at_)) {
Say(GetProvenance(at_), Say(GetProvenance(at_),
"Label digit is not in fixed-form label field"_en_US); "Label digit is not in fixed-form label field"_en_US);
} }
} }
▲ Show 20 Lines • Show All 816 Lines • ▼ Show 20 Linesconst char *Prescanner::IsCompilerDirectiveSentinel(
if (n == 0 || !compilerDirectiveBloomFilter_.test(packed % prime1) || if (n == 0 || !compilerDirectiveBloomFilter_.test(packed % prime1) ||
!compilerDirectiveBloomFilter_.test(packed % prime2)) { !compilerDirectiveBloomFilter_.test(packed % prime2)) {
return nullptr; return nullptr;
} }
const auto iter{compilerDirectiveSentinels_.find(std::string(sentinel, n))}; const auto iter{compilerDirectiveSentinels_.find(std::string(sentinel, n))};
return iter == compilerDirectiveSentinels_.end() ? nullptr : iter->c_str(); return iter == compilerDirectiveSentinels_.end() ? nullptr : iter->c_str();
} }
constexpr bool IsDirective(const char *match, const char *dir) {
for (; *match; ++match) {
if (*match != ToLowerCaseLetter(*dir++)) {
return false;
}
}
return true;
}
Prescanner::LineClassification Prescanner::ClassifyLine( Prescanner::LineClassification Prescanner::ClassifyLine(
const char *start) const { const char *start) const {
if (inFixedForm_) { if (inFixedForm_) {
if (std::optional<LineClassification> lc{ if (std::optional<LineClassification> lc{
IsFixedFormCompilerDirectiveLine(start)}) { IsFixedFormCompilerDirectiveLine(start)}) {
return std::move(*lc); return std::move(*lc);
} }
if (IsFixedFormCommentLine(start)) { if (IsFixedFormCommentLine(start)) {
return {LineClassification::Kind::Comment}; return {LineClassification::Kind::Comment};
} }
} else { } else {
if (std::optional<LineClassification> lc{ if (std::optional<LineClassification> lc{
IsFreeFormCompilerDirectiveLine(start)}) { IsFreeFormCompilerDirectiveLine(start)}) {
return std::move(*lc); return std::move(*lc);
} }
if (const char *bang{IsFreeFormComment(start)}) { if (const char *bang{IsFreeFormComment(start)}) {
return {LineClassification::Kind::Comment, return {LineClassification::Kind::Comment,
static_cast<std::size_t>(bang - start)}; static_cast<std::size_t>(bang - start)};
} }
} }
if (std::optional<std::size_t> quoteOffset{IsIncludeLine(start)}) { if (std::optional<std::size_t> quoteOffset{IsIncludeLine(start)}) {
return {LineClassification::Kind::IncludeLine, *quoteOffset}; return {LineClassification::Kind::IncludeLine, *quoteOffset};
} }
if (const char *dir{IsPreprocessorDirectiveLine(start)}) { if (const char *dir{IsPreprocessorDirectiveLine(start)}) {
if (std::memcmp(dir, "if", 2) == 0 || std::memcmp(dir, "elif", 4) == 0 || if (IsDirective("if", dir) || IsDirective("elif", dir) ||
std::memcmp(dir, "else", 4) == 0 || std::memcmp(dir, "endif", 5) == 0) { IsDirective("else", dir) || IsDirective("endif", dir)) {
return {LineClassification::Kind::ConditionalCompilationDirective}; return {LineClassification::Kind::ConditionalCompilationDirective};
} else if (std::memcmp(dir, "include", 7) == 0) { } else if (IsDirective("include", dir)) {
return {LineClassification::Kind::IncludeDirective}; return {LineClassification::Kind::IncludeDirective};
} else if (std::memcmp(dir, "define", 6) == 0 || } else if (IsDirective("define", dir) || IsDirective("undef", dir)) {
std::memcmp(dir, "undef", 5) == 0) {
return {LineClassification::Kind::DefinitionDirective}; return {LineClassification::Kind::DefinitionDirective};
} else { } else {
return {LineClassification::Kind::PreprocessorDirective}; return {LineClassification::Kind::PreprocessorDirective};
} }
} }
return {LineClassification::Kind::Source}; return {LineClassification::Kind::Source};
} }
void Prescanner::SourceFormChange(std::string &&dir) { void Prescanner::SourceFormChange(std::string &&dir) {
if (dir == "!dir$ free") { if (dir == "!dir$ free") {
inFixedForm_ = false; inFixedForm_ = false;
} else if (dir == "!dir$ fixed") { } else if (dir == "!dir$ fixed") {
inFixedForm_ = true; inFixedForm_ = true;
} }
} }
} // namespace Fortran::parser } // namespace Fortran::parser

flang/test/Preprocessing/lit.local.cfg.py

  • This file was deleted.
# -*- Python -*-
from lit.llvm import llvm_config
# Added this line file to prevent lit from discovering these tests
# See Issue #1052
config.suffixes = []

flang/test/Preprocessing/pp001.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
* keyword macros * keyword macros
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp001.F pass' print *, 'pp001.F yes'
else else
print *, 'pp001.F FAIL: ', KWM print *, 'pp001.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp002.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm.eq.777)then
* #undef * #undef
integer, parameter :: KWM = 777 integer, parameter :: KWM = 777
#define KWM 666 #define KWM 666
#undef KWM #undef KWM
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp002.F pass' print *, 'pp002.F yes'
else else
print *, 'pp002.F FAIL: ', KWM print *, 'pp002.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp003.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* function-like macros * function-like macros
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM(666) res = IFLM(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp003.F pass' print *, 'pp003.F yes'
else else
print *, 'pp003.F FAIL: ', res print *, 'pp003.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp004.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm.eq.777)then
* KWMs case-sensitive * KWMs case-sensitive
integer, parameter :: KWM = 777 integer, parameter :: KWM = 777
#define KWM 666 #define KWM 666
if (kwm .eq. 777) then if (kwm .eq. 777) then
print *, 'pp004.F pass' print *, 'pp004.F yes'
else else
print *, 'pp004.F FAIL: ', kwm print *, 'pp004.F no: ', kwm
end if end if
end end

flang/test/Preprocessing/pp005.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=777
* KWM split across continuation, implicit padding * KWM split across continuation, implicit padding
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW res = KW
+M +M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp005.F pass' print *, 'pp005.F yes'
else else
print *, 'pp005.F FAIL: ', res print *, 'pp005.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp006.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=777
* ditto, but with intervening *comment line * ditto, but with intervening *comment line
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW res = KW
*comment *comment
+M +M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp006.F pass' print *, 'pp006.F yes'
else else
print *, 'pp006.F FAIL: ', res print *, 'pp006.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp007.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=kwm
* KWM split across continuation, clipped after column 72 * KWM split across continuation, clipped after column 72
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
* 'comment' is in column 73 * 'comment' is in column 73
* 1 2 3 4 5 6 7 * 1 2 3 4 5 6 7
*234567890123456789012345678901234567890123456789012345678901234567890123 *234567890123456789012345678901234567890123456789012345678901234567890123
res = KW comment res = KW comment
+M +M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp007.F pass' print *, 'pp007.F yes'
else else
print *, 'pp007.F FAIL: ', res print *, 'pp007.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp008.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=kwm
* KWM with spaces in name at invocation NOT replaced * KWM with spaces in name at invocation NOT replaced
integer, parameter :: KWM = 777 integer, parameter :: KWM = 777
#define KWM 666 #define KWM 666
integer :: res integer :: res
res = K W M res = K W M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp008.F pass' print *, 'pp008.F yes'
else else
print *, 'pp008.F FAIL: ', res print *, 'pp008.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp009.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call split across continuation, implicit padding * FLM call split across continuation, implicit padding
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL res = IFL
+M(666) +M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp009.F pass' print *, 'pp009.F yes'
else else
print *, 'pp009.F FAIL: ', res print *, 'pp009.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp010.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* ditto, but with intervening *comment line * ditto, but with intervening *comment line
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL res = IFL
*comment *comment
+M(666) +M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp010.F pass' print *, 'pp010.F yes'
else else
print *, 'pp010.F FAIL: ', res print *, 'pp010.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp011.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=iflm(666)
* FLM call name split across continuation, clipped * FLM call name split across continuation, clipped
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
* 'comment' is in column 73 * 'comment' is in column 73
* 1 2 3 4 5 6 7 * 1 2 3 4 5 6 7
*234567890123456789012345678901234567890123456789012345678901234567890123 *234567890123456789012345678901234567890123456789012345678901234567890123
res = IFL comment res = IFL comment
+M(666) +M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp011.F pass' print *, 'pp011.F yes'
else else
print *, 'pp011.F FAIL: ', res print *, 'pp011.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp012.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call name split across continuation * FLM call name split across continuation
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL res = IFL
+M(666) +M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp012.F pass' print *, 'pp012.F yes'
else else
print *, 'pp012.F FAIL: ', res print *, 'pp012.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp013.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call split between name and ( * FLM call split between name and (
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM res = IFLM
+(666) +(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp013.F pass' print *, 'pp013.F yes'
else else
print *, 'pp013.F FAIL: ', res print *, 'pp013.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp014.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call split between name and (, with intervening *comment * FLM call split between name and (, with intervening *comment
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM res = IFLM
*comment *comment
+(666) +(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp014.F pass' print *, 'pp014.F yes'
else else
print *, 'pp014.F FAIL: ', res print *, 'pp014.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp015.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call split between name and (, clipped * FLM call split between name and (, clipped
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
* 'comment' is in column 73 * 'comment' is in column 73
* 1 2 3 4 5 6 7 * 1 2 3 4 5 6 7
*234567890123456789012345678901234567890123456789012345678901234567890123 *234567890123456789012345678901234567890123456789012345678901234567890123
res = IFLM comment res = IFLM comment
+(666) +(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp015.F pass' print *, 'pp015.F yes'
else else
print *, 'pp015.F FAIL: ', res print *, 'pp015.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp016.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call split between name and ( and in argument * FLM call split between name and ( and in argument
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM res = IFLM
+(66 +(66
+6) +6)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp016.F pass' print *, 'pp016.F yes'
else else
print *, 'pp016.F FAIL: ', res print *, 'pp016.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp017.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
* KLM rescan * KLM rescan
integer, parameter :: KWM = 666, KWM2 = 667 integer, parameter :: KWM = 666, KWM2 = 667
#define KWM2 777 #define KWM2 777
#define KWM KWM2 #define KWM KWM2
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp017.F pass' print *, 'pp017.F yes'
else else
print *, 'pp017.F FAIL: ', KWM print *, 'pp017.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp018.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm2.eq.777)then
* KLM rescan with #undef (so rescan is after expansion) * KLM rescan with #undef (so rescan is after expansion)
integer, parameter :: KWM2 = 777, KWM = 667 integer, parameter :: KWM2 = 777, KWM = 667
#define KWM2 666 #define KWM2 666
#define KWM KWM2 #define KWM KWM2
#undef KWM2 #undef KWM2
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp018.F pass' print *, 'pp018.F yes'
else else
print *, 'pp018.F FAIL: ', KWM print *, 'pp018.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp019.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM rescan * FLM rescan
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
integer, parameter :: KWM = 999 integer, parameter :: KWM = 999
#define KWM 111 #define KWM 111
#define IFLM(x) ((x)+KWM) #define IFLM(x) ((x)+KWM)
integer :: res integer :: res
res = IFLM(666) res = IFLM(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp019.F pass' print *, 'pp019.F yes'
else else
print *, 'pp019.F FAIL: ', res print *, 'pp019.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp020.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((111)+666)
* FLM expansion of argument * FLM expansion of argument
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
integer, parameter :: KWM = 999 integer, parameter :: KWM = 999
#define KWM 111 #define KWM 111
#define IFLM(x) ((x)+666) #define IFLM(x) ((x)+666)
integer :: res integer :: res
res = IFLM(KWM) res = IFLM(KWM)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp020.F pass' print *, 'pp020.F yes'
else else
print *, 'pp020.F FAIL: ', res print *, 'pp020.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp021.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch='KWM'
! CHECK: if(ch.eq.'KWM')then
* KWM NOT expanded in 'literal' * KWM NOT expanded in 'literal'
#define KWM 666 #define KWM 666
character(len=3) :: ch character(len=3) :: ch
ch = 'KWM' ch = 'KWM'
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp021.F pass' print *, 'pp021.F yes'
else else
print *, 'pp021.F FAIL: ', ch print *, 'pp021.F no: ', ch
end if end if
end end

flang/test/Preprocessing/pp022.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch="KWM"
! CHECK: if(ch.eq.'KWM')then
* KWM NOT expanded in "literal" * KWM NOT expanded in "literal"
#define KWM 666 #define KWM 666
character(len=3) :: ch character(len=3) :: ch
ch = "KWM" ch = "KWM"
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp022.F pass' print *, 'pp022.F yes'
else else
print *, 'pp022.F FAIL: ', ch print *, 'pp022.F no: ', ch
end if end if
end end

flang/test/Preprocessing/pp023.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch=3hKWM
! CHECK: if(ch.eq.'KWM')then
* KWM NOT expanded in 9HHOLLERITH literal * KWM NOT expanded in 9HHOLLERITH literal
#define KWM 666 #define KWM 666
#define HKWM 667 #define HKWM 667
character(len=3) :: ch character(len=3) :: ch
ch = 3HKWM ch = 3HKWM
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp023.F pass' print *, 'pp023.F yes'
else else
print *, 'pp023.F FAIL: ', ch print *, 'pp023.F no: ', ch
end if end if
end end

flang/test/Preprocessing/pp024.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: 100format(3hKWM)
! CHECK: if(ch.eq.'KWM')then
* KWM NOT expanded in Hollerith in FORMAT * KWM NOT expanded in Hollerith in FORMAT
#define KWM 666 #define KWM 666
#define HKWM 667 #define HKWM 667
character(len=3) :: ch character(len=3) :: ch
100 format(3HKWM) 100 format(3HKWM)
write(ch, 100) write(ch, 100)
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp024.F pass' print *, 'pp024.F yes'
else else
print *, 'pp024.F FAIL: ', ch print *, 'pp024.F no: ', ch
end if end if
end end

flang/test/Preprocessing/pp025.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=ikwm2z
* KWM expansion is before token pasting due to fixed-form space removal * KWM expansion is before token pasting due to fixed-form space removal
integer, parameter :: IKWM2Z = 777 integer, parameter :: IKWM2Z = 777
#define KWM KWM2 #define KWM KWM2
integer :: res integer :: res
res = I KWM Z res = I KWM Z
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp025.F pass' print *, 'pp025.F yes'
else else
print *, 'pp025.F FAIL: ', res print *, 'pp025.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp026.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((111)+666)
* ## token pasting works in FLM * ## token pasting works in FLM
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
integer, parameter :: KWM = 668, KWM21 = 111, KWM1 = 669 integer, parameter :: KWM = 668, KWM21 = 111, KWM1 = 669
#define KWM1 111 #define KWM1 111
#define KWM2 33 #define KWM2 33
#define KWM KWM2 #define KWM KWM2
#define IFLM(x) ((x##1)+6##6##6) #define IFLM(x) ((x##1)+6##6##6)
integer :: res integer :: res
res = IFLM(KWM) res = IFLM(KWM)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp026.F pass' print *, 'pp026.F yes'
else else
print *, 'pp026.F FAIL: ', res print *, 'pp026.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp027.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: kwm=666
! CHECK: if(777.eq.777)then
* #DEFINE works in fixed form * #DEFINE works in fixed form
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#DEFINE KWM 777 #DEFINE KWM 777
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp027.F pass' print *, 'pp027.F yes'
else else
print *, 'pp027.F FAIL: ', KWM print *, 'pp027.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp028.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=kw
* fixed-form clipping done before KWM expansion on source line * fixed-form clipping done before KWM expansion on source line
integer, parameter :: KW = 777 integer, parameter :: KW = 777
#define KWM 666 #define KWM 666
integer :: res integer :: res
* 'M' is in column 73 * 'M' is in column 73
* 1 2 3 4 5 6 7 * 1 2 3 4 5 6 7
*234567890123456789012345678901234567890123456789012345678901234567890123 *234567890123456789012345678901234567890123456789012345678901234567890123
res = KWM res = KWM
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp028.F pass' print *, 'pp028.F yes'
else else
print *, 'pp028.F FAIL: ', res print *, 'pp028.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp029.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(77 7.eq.777)then
* \ newline allowed in #define * \ newline allowed in #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 77\ #define KWM 77\
7 7
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp029.F pass' print *, 'pp029.F yes'
else else
print *, 'pp029.F FAIL: ', KWM print *, 'pp029.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp030.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
* /* C comment */ erased from #define * /* C comment */ erased from #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 /* C comment */ #define KWM 777 /* C comment */
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp030.F pass' print *, 'pp030.F yes'
else else
print *, 'pp030.F FAIL: ', KWM print *, 'pp030.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp031.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777//ccomment.eq.777)then
! CHECK: print*,'pp031.F no: ',777//ccomment
* // C++ comment NOT erased from #define * // C++ comment NOT erased from #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 // C comment #define KWM 777 // C comment
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp031.F FAIL (should not have compiled)' print *, 'pp031.F FAIL (should not have compiled)'
else else
print *, 'pp031.F FAIL: ', KWM print *, 'pp031.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp032.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
! CHECK: print*,'pp032.F no: ',777
* /* C comment */ \ newline erased from #define * /* C comment */ \ newline erased from #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 77/* C comment */\ #define KWM 77/* C comment */\
7 7
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp032.F pass' print *, 'pp032.F yes'
else else
print *, 'pp032.F FAIL: ', KWM print *, 'pp032.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp033.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
! CHECK: print*,'pp033.F no: ',777
* /* C comment \ newline */ erased from #define * /* C comment \ newline */ erased from #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 77/* C comment \ #define KWM 77/* C comment \
*/7 */7
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp033.F pass' print *, 'pp033.F yes'
else else
print *, 'pp033.F FAIL: ', KWM print *, 'pp033.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp034.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
! CHECK: print*,'pp034.F no: ',777
* \ newline allowed in name on KWM definition * \ newline allowed in name on KWM definition
integer, parameter :: KWMC = 666 integer, parameter :: KWMC = 666
#define KWM\ #define KWM\
C 777 C 777
if (KWMC .eq. 777) then if (KWMC .eq. 777) then
print *, 'pp034.F pass' print *, 'pp034.F yes'
else else
print *, 'pp034.F FAIL: ', KWMC print *, 'pp034.F no: ', KWMC
end if end if
end end

flang/test/Preprocessing/pp035.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777.eq.777)then
! CHECK: print*,'pp035.F no: ',777
* #if 2 .LT. 3 works * #if 2 .LT. 3 works
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#if 2 .LT. 3 #if 2 .LT. 3
#define KWM 777 #define KWM 777
#else #else
#define KWM 667 #define KWM 667
#endif #endif
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp035.F pass' print *, 'pp035.F yes'
else else
print *, 'pp035.F FAIL: ', KWM print *, 'pp035.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp036.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(.true.)then
! CHECK: print*,'pp036.F no: ',.true.
* #define FALSE TRUE ... .FALSE. -> .TRUE. * #define FALSE TRUE ... .FALSE. -> .TRUE.
#define FALSE TRUE #define FALSE TRUE
if (.FALSE.) then if (.FALSE.) then
print *, 'pp036.F pass' print *, 'pp036.F yes'
else else
print *, 'pp036.F FAIL: ', .FALSE. print *, 'pp036.F no: ', .FALSE.
end if end if
end end

flang/test/Preprocessing/pp037.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(7777.eq.777)then
! CHECK: print*,'pp037.F no: ',7777
* fixed-form clipping NOT applied to #define * fixed-form clipping NOT applied to #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
* 1 2 3 4 5 6 7 * 1 2 3 4 5 6 7
*234567890123456789012345678901234567890123456789012345678901234567890123 *234567890123456789012345678901234567890123456789012345678901234567890123
#define KWM 7777 #define KWM 7777
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp037.F pass' print *, 'pp037.F yes'
else else
print *, 'pp037.F FAIL: ', KWM print *, 'pp037.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp038.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=((666)+111)
* FLM call with closing ')' on next line (not a continuation) * FLM call with closing ')' on next line (not a continuation)
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM(666 res = IFLM(666
) )
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp038.F pass' print *, 'pp038.F yes'
else else
print *, 'pp038.F FAIL: ', res print *, 'pp038.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp039.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res=iflm
! CHECK: (666)
! CHECK-NOT: res=((666)+111)
* FLM call with '(' on next line (not a continuation) * FLM call with '(' on next line (not a continuation)
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM res = IFLM
(666) (666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp039.F pass' print *, 'pp039.F yes'
else else
print *, 'pp039.F FAIL: ', res print *, 'pp039.F no: ', res
end if end if
end end

flang/test/Preprocessing/pp040.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK-NOT: FAIL HARD!
* #define KWM c, then KWM works as comment line initiator * #define KWM c, then KWM works as comment line initiator
#define KWM c #define KWM c
KWM print *, 'pp040.F FAIL HARD!'; stop KWM print *, 'pp040.F FAIL HARD!'; stop
print *, 'pp040.F pass' print *, 'pp040.F yes'
end end

flang/test/Preprocessing/pp041.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: j=666wmj=j+1wm211
* use KWM expansion as continuation indicators * use KWM expansion as continuation indicators
#define KWM 0 #define KWM 0
#define KWM2 1 #define KWM2 1
integer :: j integer :: j
j = 666 j = 666
KWM j = j + 1 KWM j = j + 1
KWM2 11 KWM2 11
if (j .eq. 777) then if (j .eq. 777) then
print *, 'pp041.F pass' print *, 'pp041.F yes'
else else
print *, 'pp041.F FAIL', j print *, 'pp041.F no', j
end if end if
end end

flang/test/Preprocessing/pp042.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK-NOT: goto 2
* #define c 1, then use c as label in fixed-form * #define c 1, then use c as label in fixed-form
#define c 1 #define c 1
c print *, 'pp042.F pass'; goto 2 c print *, 'pp042.F yes'; goto 2
print *, 'pp042.F FAIL' print *, 'pp042.F no'
2 continue 2 continue
end end

flang/test/Preprocessing/pp043.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm.eq.777)then
* #define with # in column 6 is a continuation line in fixed-form * #define with # in column 6 is a continuation line in fixed-form
integer, parameter :: defineKWM666 = 555 integer, parameter :: defineKWM666 = 555
integer, parameter :: KWM = integer, parameter :: KWM =
#define KWM 666 #define KWM 666
++222 ++222
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp043.F pass' print *, 'pp043.F yes'
else else
print *, 'pp043.F FAIL: ', KWM print *, 'pp043.F no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp044.F

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK-NOT:z=111
* #define directive amid continuations * #define directive amid continuations
integer, parameter :: KWM = 222, KWM111 = 333, KWM222 = 555 integer, parameter :: KWM = 222, KWM111 = 333, KWM222 = 555
integer, parameter :: KWMKWM = 333 integer, parameter :: KWMKWM = 333
integer, parameter :: z = KWM integer, parameter :: z = KWM
#define KWM 111 #define KWM 111
+KWM+444 +KWM+444
if (z .EQ. 777) then if (z .EQ. 777) then
print *, 'pass' print *, 'yes'
else else
print *, 'FAIL', z print *, 'no', z
end if end if
end end

flang/test/Preprocessing/pp101.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777 .eq. 777) then
! keyword macros ! keyword macros
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp101.F90 pass' print *, 'pp101.F90 yes'
else else
print *, 'pp101.F90 FAIL: ', KWM print *, 'pp101.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp102.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm .eq. 777) then
! #undef ! #undef
integer, parameter :: KWM = 777 integer, parameter :: KWM = 777
#define KWM 666 #define KWM 666
#undef KWM #undef KWM
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp102.F90 pass' print *, 'pp102.F90 yes'
else else
print *, 'pp102.F90 FAIL: ', KWM print *, 'pp102.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp103.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! function-like macros ! function-like macros
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM(666) res = IFLM(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp103.F90 pass' print *, 'pp103.F90 yes'
else else
print *, 'pp103.F90 FAIL: ', res print *, 'pp103.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp104.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm .eq. 777) then
! KWMs case-sensitive ! KWMs case-sensitive
integer, parameter :: KWM = 777 integer, parameter :: KWM = 777
#define KWM 666 #define KWM 666
if (kwm .eq. 777) then if (kwm .eq. 777) then
print *, 'pp104.F90 pass' print *, 'pp104.F90 yes'
else else
print *, 'pp104.F90 FAIL: ', kwm print *, 'pp104.F90 no: ', kwm
end if end if
end end

flang/test/Preprocessing/pp105.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = 777
! KWM call name split across continuation, with leading & ! KWM call name split across continuation, with leading &
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW& res = KW&
&M &M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp105.F90 pass' print *, 'pp105.F90 yes'
else else
print *, 'pp105.F90 FAIL: ', res print *, 'pp105.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp106.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = 777
! ditto, with & ! comment ! ditto, with & ! comment
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW& ! comment res = KW& ! comment
&M &M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp106.F90 pass' print *, 'pp106.F90 yes'
else else
print *, 'pp106.F90 FAIL: ', res print *, 'pp106.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp107.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = kwm
! KWM call name split across continuation, no leading &, with & ! comment ! KWM call name split across continuation, no leading &, with & ! comment
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW& ! comment res = KW& ! comment
M M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp107.F90 pass' print *, 'pp107.F90 yes'
else else
print *, 'pp107.F90 FAIL: ', res print *, 'pp107.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp108.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = kwm
! ditto, but without & ! comment ! ditto, but without & ! comment
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 777 #define KWM 777
integer :: res integer :: res
res = KW& res = KW&
M M
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp108.F90 pass' print *, 'pp108.F90 yes'
else else
print *, 'pp108.F90 FAIL: ', res print *, 'pp108.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp109.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! FLM call name split with leading & ! FLM call name split with leading &
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL& res = IFL&
&M(666) &M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp109.F90 pass' print *, 'pp109.F90 yes'
else else
print *, 'pp109.F90 FAIL: ', res print *, 'pp109.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp110.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! ditto, with & ! comment ! ditto, with & ! comment
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL& ! comment res = IFL& ! comment
&M(666) &M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp110.F90 pass' print *, 'pp110.F90 yes'
else else
print *, 'pp110.F90 FAIL: ', res print *, 'pp110.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp111.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm (666)
! FLM call name split across continuation, no leading &, with & ! comment ! FLM call name split across continuation, no leading &, with & ! comment
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL& ! comment res = IFL& ! comment
M(666) M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp111.F90 pass' print *, 'pp111.F90 yes'
else else
print *, 'pp111.F90 FAIL: ', res print *, 'pp111.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp112.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm (666)
! ditto, but without & ! comment ! ditto, but without & ! comment
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFL& res = IFL&
M(666) M(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp112.F90 pass' print *, 'pp112.F90 yes'
else else
print *, 'pp112.F90 FAIL: ', res print *, 'pp112.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp113.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! FLM call split across continuation between name and (, leading & ! FLM call split across continuation between name and (, leading &
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM& res = IFLM&
&(666) &(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp113.F90 pass' print *, 'pp113.F90 yes'
else else
print *, 'pp113.F90 FAIL: ', res print *, 'pp113.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp114.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! ditto, with & ! comment, leading & ! ditto, with & ! comment, leading &
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM& ! comment res = IFLM& ! comment
&(666) &(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp114.F90 pass' print *, 'pp114.F90 yes'
else else
print *, 'pp114.F90 FAIL: ', res print *, 'pp114.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp115.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm (666)
! ditto, with & ! comment, no leading & ! ditto, with & ! comment, no leading &
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM& ! comment res = IFLM& ! comment
(666) (666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp115.F90 pass' print *, 'pp115.F90 yes'
else else
print *, 'pp115.F90 FAIL: ', res print *, 'pp115.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp116.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm (666)
! FLM call split between name and (, no leading & ! FLM call split between name and (, no leading &
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM& res = IFLM&
(666) (666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp116.F90 pass' print *, 'pp116.F90 yes'
else else
print *, 'pp116.F90 FAIL: ', res print *, 'pp116.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp117.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777 .eq. 777) then
! KWM rescan ! KWM rescan
integer, parameter :: KWM = 666, KWM2 = 667 integer, parameter :: KWM = 666, KWM2 = 667
#define KWM2 777 #define KWM2 777
#define KWM KWM2 #define KWM KWM2
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp117.F90 pass' print *, 'pp117.F90 yes'
else else
print *, 'pp117.F90 FAIL: ', KWM print *, 'pp117.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp118.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(kwm2 .eq. 777) then
! KWM rescan with #undef, proving rescan after expansion ! KWM rescan with #undef, proving rescan after expansion
integer, parameter :: KWM2 = 777, KWM = 667 integer, parameter :: KWM2 = 777, KWM = 667
#define KWM2 666 #define KWM2 666
#define KWM KWM2 #define KWM KWM2
#undef KWM2 #undef KWM2
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp118.F90 pass' print *, 'pp118.F90 yes'
else else
print *, 'pp118.F90 FAIL: ', KWM print *, 'pp118.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp119.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((666)+111)
! FLM rescan ! FLM rescan
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
integer, parameter :: KWM = 999 integer, parameter :: KWM = 999
#define KWM 111 #define KWM 111
#define IFLM(x) ((x)+KWM) #define IFLM(x) ((x)+KWM)
integer :: res integer :: res
res = IFLM(666) res = IFLM(666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp119.F90 pass' print *, 'pp119.F90 yes'
else else
print *, 'pp119.F90 FAIL: ', res print *, 'pp119.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp120.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = ((111)+666)
! FLM expansion of argument ! FLM expansion of argument
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
integer, parameter :: KWM = 999 integer, parameter :: KWM = 999
#define KWM 111 #define KWM 111
#define IFLM(x) ((x)+666) #define IFLM(x) ((x)+666)
integer :: res integer :: res
res = IFLM(KWM) res = IFLM(KWM)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp120.F90 pass' print *, 'pp120.F90 yes'
else else
print *, 'pp120.F90 FAIL: ', res print *, 'pp120.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp121.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch = 'KWM'
! CHECK: if(ch .eq. 'KWM') then
! KWM NOT expanded in 'literal' ! KWM NOT expanded in 'literal'
#define KWM 666 #define KWM 666
character(len=3) :: ch character(len=3) :: ch
ch = 'KWM' ch = 'KWM'
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp121.F90 pass' print *, 'pp121.F90 yes'
else else
print *, 'pp121.F90 FAIL: ', ch print *, 'pp121.F90 no: ', ch
end if end if
end end

flang/test/Preprocessing/pp122.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch = "KWM"
! KWM NOT expanded in "literal" ! KWM NOT expanded in "literal"
#define KWM 666 #define KWM 666
character(len=3) :: ch character(len=3) :: ch
ch = "KWM" ch = "KWM"
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp122.F90 pass' print *, 'pp122.F90 yes'
else else
print *, 'pp122.F90 FAIL: ', ch print *, 'pp122.F90 no: ', ch
end if end if
end end

flang/test/Preprocessing/pp123.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: ch = 3hKWM
! KWM NOT expanded in Hollerith literal ! KWM NOT expanded in Hollerith literal
#define KWM 666 #define KWM 666
#define HKWM 667 #define HKWM 667
character(len=3) :: ch character(len=3) :: ch
ch = 3HKWM ch = 3HKWM
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp123.F90 pass' print *, 'pp123.F90 yes'
else else
print *, 'pp123.F90 FAIL: ', ch print *, 'pp123.F90 no: ', ch
end if end if
end end

flang/test/Preprocessing/pp124.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: 100 format(3hKWM)
! KWM NOT expanded in Hollerith in FORMAT ! KWM NOT expanded in Hollerith in FORMAT
#define KWM 666 #define KWM 666
#define HKWM 667 #define HKWM 667
character(len=3) :: ch character(len=3) :: ch
100 format(3HKWM) 100 format(3HKWM)
write(ch, 100) write(ch, 100)
if (ch .eq. 'KWM') then if (ch .eq. 'KWM') then
print *, 'pp124.F90 pass' print *, 'pp124.F90 yes'
else else
print *, 'pp124.F90 FAIL: ', ch print *, 'pp124.F90 no: ', ch
end if end if
end end

flang/test/Preprocessing/pp125.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777 .eq. 777) then
! #DEFINE works in free form ! #DEFINE works in free form
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#DEFINE KWM 777 #DEFINE KWM 777
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp125.F90 pass' print *, 'pp125.F90 yes'
else else
print *, 'pp125.F90 FAIL: ', KWM print *, 'pp125.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp126.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: if(777 .eq. 777) then
! \ newline works in #define ! \ newline works in #define
integer, parameter :: KWM = 666 integer, parameter :: KWM = 666
#define KWM 77\ #define KWM 77\
7 7
if (KWM .eq. 777) then if (KWM .eq. 777) then
print *, 'pp126.F90 pass' print *, 'pp126.F90 yes'
else else
print *, 'pp126.F90 FAIL: ', KWM print *, 'pp126.F90 no: ', KWM
end if end if
end end

flang/test/Preprocessing/pp127.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm(666 )
! FLM call with closing ')' on next line (not a continuation) ! FLM call with closing ')' on next line (not a continuation)
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM(666 res = IFLM(666
) )
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp127.F90 pass' print *, 'pp127.F90 yes'
else else
print *, 'pp127.F90 FAIL: ', res print *, 'pp127.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp128.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: res = iflm
! FLM call with '(' on next line (not a continuation) ! FLM call with '(' on next line (not a continuation)
integer function IFLM(x) integer function IFLM(x)
integer :: x integer :: x
IFLM = x IFLM = x
end function IFLM end function IFLM
program main program main
#define IFLM(x) ((x)+111) #define IFLM(x) ((x)+111)
integer :: res integer :: res
res = IFLM res = IFLM
(666) (666)
if (res .eq. 777) then if (res .eq. 777) then
print *, 'pp128.F90 pass' print *, 'pp128.F90 yes'
else else
print *, 'pp128.F90 FAIL: ', res print *, 'pp128.F90 no: ', res
end if end if
end end

flang/test/Preprocessing/pp129.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK-NOT: stop
! #define KWM !, then KWM works as comment line initiator ! #define KWM !, then KWM works as comment line initiator
#define KWM ! #define KWM !
KWM print *, 'pp129.F90 FAIL HARD!'; stop KWM print *, 'pp129.F90 FAIL HARD!'; stop
print *, 'pp129.F90 pass' print *, 'pp129.F90 yes'
end end

flang/test/Preprocessing/pp130.F90

! RUN: %f18 -E %s 2>&1 | FileCheck %s
! CHECK: j = j + &
! #define KWM &, use for continuation w/o pasting (ifort and nag seem to continue #define) ! #define KWM &, use for continuation w/o pasting (ifort and nag seem to continue #define)
#define KWM & #define KWM &
integer :: j integer :: j
j = 666 j = 666
j = j + KWM j = j + KWM
111 111
if (j .eq. 777) then if (j .eq. 777) then
print *, 'pp130.F90 pass' print *, 'pp130.F90 yes'
else else
print *, 'pp130.F90 FAIL', j print *, 'pp130.F90 no', j
end if end if
end end
flang/lib/Parser/prescan.cpp