[flang] All fixed except for a few NAG differences

Original-commit: flang-compiler/f18@8dea4fb760
Reviewed-on: https://github.com/flang-compiler/f18/pull/496
Tree-same-pre-rewrite: false

flang/lib/parser/characters.cc

@@ -14,6 +14,7 @@
 
 #include "characters.h"
 #include "../common/idioms.h"
+#include <algorithm>
 #include <cstddef>
 #include <optional>
 #include <type_traits>
@@ -210,13 +211,11 @@ static DecodedCharacter DecodeEscapedCharacter(
   if (cp[0] == '\\' && bytes >= 2) {
     if (std::optional<char> escChar{BackslashEscapeValue(cp[1])}) {
       return {static_cast<unsigned char>(*escChar), 2};
-    }
-    if (IsOctalDigit(cp[1])) {
-      std::size_t maxDigits{static_cast<std::size_t>(cp[1] > '3' ? 2 : 3)};
-      std::size_t maxLen{std::max(maxDigits + 1, bytes)};
+    } else if (IsOctalDigit(cp[1])) {
+      std::size_t maxLen{std::min(std::size_t{4}, bytes)};
       char32_t code{static_cast<char32_t>(cp[1] - '0')};
       std::size_t len{2};  // so far
-      for (; len < maxLen && IsOctalDigit(cp[len]); ++len) {
+      for (; code <= 037 && len < maxLen && IsOctalDigit(cp[len]); ++len) {
         code = 8 * code + DecimalDigitValue(cp[len]);
       }
       return {code, static_cast<int>(len)};
@@ -225,6 +224,9 @@ static DecodedCharacter DecodeEscapedCharacter(
       return {static_cast<char32_t>(16 * HexadecimalDigitValue(cp[2]) +
                   HexadecimalDigitValue(cp[3])),
           4};
+    } else {
+      // unknown escape - ignore the '\' (PGI compatibility)
+      return {static_cast<unsigned char>(cp[1]), 2};
     }
   }
   return {static_cast<unsigned char>(cp[0]), 1};

flang/lib/parser/characters.h

@@ -109,7 +109,7 @@ inline constexpr char HexadecimalDigitValue(char ch) {
 
 inline constexpr std::optional<char> BackslashEscapeValue(char ch) {
   switch (ch) {
-  case 'a': return '\a';
+  case 'a': return std::nullopt;  // '\a';  PGF90 doesn't know \a
   case 'b': return '\b';
   case 'f': return '\f';
   case 'n': return '\n';
@@ -125,7 +125,7 @@ inline constexpr std::optional<char> BackslashEscapeValue(char ch) {
 
 inline constexpr std::optional<char> BackslashEscapeChar(char ch) {
   switch (ch) {
-    //  case '\a': return 'a';  // PGF90 doesn't know \a
+  case '\a': return std::nullopt;  // 'a';  PGF90 doesn't know \a
   case '\b': return 'b';
   case '\f': return 'f';
   case '\n': return 'n';

flang/lib/parser/prescan.cc

@@ -21,7 +21,6 @@
 #include "../common/idioms.h"
 #include <cstddef>
 #include <cstring>
-#include <iostream>  // TODO pmk rm
 #include <sstream>
 #include <utility>
 #include <vector>
@@ -562,6 +561,8 @@ void Prescanner::QuotedCharacterLiteral(
   if (isKanji) {
     // NC'...' - the contents are always decoded as EUC_JP
     encoding = Encoding::EUC_JP;
+  } else if (encoding == Encoding::EUC_JP) {
+    encoding = Encoding::LATIN_1;  // for compatibility with tests
   }
   while (true) {
     DecodedCharacter decoded{DecodeCharacter(

flang/lib/parser/token-parsers.h

@@ -25,6 +25,7 @@
 #include "provenance.h"
 #include "type-parsers.h"
 #include "../common/idioms.h"
+#include <cctype>
 #include <cstddef>
 #include <cstring>
 #include <functional>
@@ -227,8 +228,7 @@ struct CharLiteralChar {
       }
       if (std::optional<char> escChar{BackslashEscapeValue(**cp)}) {
         return std::make_pair(*escChar, true);
-      }
-      if (IsOctalDigit(**cp)) {
+      } else if (IsOctalDigit(**cp)) {
         char result{static_cast<char>(**cp - '0')};
         for (int j = (result > 3 ? 1 : 2); j-- > 0;) {
           static constexpr auto octalDigit{attempt("01234567"_ch)};
@@ -239,8 +239,10 @@ struct CharLiteralChar {
           }
         }
         return std::make_pair(result, true);
+      } else {
+        // unknown escape - ignore the '\' (PGI compatibility)
+        return std::make_pair(static_cast<char>(1 [*cp]), true);
       }
-      state.Say(at, "Bad escaped character"_err_en_US);
     }
     return std::nullopt;
   }
@@ -518,7 +520,7 @@ struct HollerithLiteral {
       int chBytes{UTF_8CharacterBytes(state.GetLocation())};
       for (int bytes{chBytes}; bytes > 0; --bytes) {
         if (std::optional<const char *> at{nextCh.Parse(state)}) {
-          if (chBytes == 1 && !isprint(**at)) {
+          if (chBytes == 1 && !std::isprint(**at)) {
             state.Say(start, "Bad character in Hollerith"_err_en_US);
             return std::nullopt;
           }

flang/lib/parser/unparse.cc

@@ -186,7 +186,7 @@ public:
         x.u);
   }
   void Unparse(const CharLiteralConstant &x) {  // R724
-    Encoding encoding{encoding_};
+    Encoding encoding{Encoding::LATIN_1};
     if (const auto &k{std::get<std::optional<KindParam>>(x.t)}) {
       if (std::holds_alternative<KindParam::Kanji>(k->u)) {
         Word("NC");

flang/tools/f18/f18.cc

@@ -513,10 +513,6 @@ int main(int argc, char *const argv[]) {
   if (driver.warnOnNonstandardUsage) {
     options.features.WarnOnAllNonstandard();
   }
-  if (!options.features.IsEnabled(
-          Fortran::parser::LanguageFeature::BackslashEscapes)) {
-    driver.pgf90Args.push_back("-Mbackslash");
-  }
   if (options.features.IsEnabled(Fortran::parser::LanguageFeature::OpenMP)) {
     driver.pgf90Args.push_back("-mp");
   }