[flang] Treat tabs like spaces in formatted input.

[klausler]

Summary

In formatted input, treat tabs as if they were spaces.

[sscalpone]

The standard goes out of its way not to define blanks.

flang/runtime/edit-input.cpp

 
 static bool EditBOZInput(IoStatementState &io, const DataEdit &edit, void *n,
     int base, int totalBitSize) {
   std::optional<int> remaining;
   std::optional<char32_t> next{PrepareInput(io, edit, remaining)};
   common::UnsignedInt128 value{0};
   for (; next; next = io.NextInField(remaining)) {
     char32_t ch{*next};
-    if (ch == ' ') {
+    if (ch == ' ' || ch == '\t') {
       continue;
     }
     int digit{0};
     if (ch >= '0' && ch <= '1') {
       digit = ch - '0';
     } else if (base >= 8 && ch >= '2' && ch <= '7') {
       digit = ch - '0';
     } else if (base >= 10 && ch >= '8' && ch <= '9') {
default:
     return false;
   }
   std::optional<int> remaining;
   std::optional<char32_t> next;
   bool negate{ScanNumericPrefix(io, edit, next, remaining)};
   common::UnsignedInt128 value;
   for (; next; next = io.NextInField(remaining)) {
     char32_t ch{*next};
-    if (ch == ' ') {
+    if (ch == ' ' || ch == '\t') {
       if (edit.modes.editingFlags & blankZero) {
         ch = '0'; // BZ mode - treat blank as if it were zero
       } else {
         continue;
       }
     }
     int digit{0};
     if (ch >= '0' && ch <= '9') {
if (next && *next == '(') { // NaN(...)
       while (next && *next != ')') {
         next = io.NextInField(remaining);
       }
     }
     exponent = 0;
   } else if (*next == decimal || (*next >= '0' && *next <= '9')) {
     for (; next; next = io.NextInField(remaining)) {
       char32_t ch{*next};
-      if (ch == ' ') {
+      if (ch == ' ' || ch == '\t') {
         if (edit.modes.editingFlags & blankZero) {
           ch = '0'; // BZ mode - treat blank as if it were zero
         } else {
           continue;
         }
       }
       if (ch == '0' && got == start) {
         // omit leading zeroes
if (decimalPoint) {
       exponent += got - start - edit.digits.value_or(0);
     }
   } else {
     // TODO: hex FP input
     exponent = 0;
     return 0;
   }
   if (remaining) {
-    while (next && *next == ' ') {
+    while (next && (*next == ' ' || *next == '\t')) {
       next = io.NextInField(remaining);
     }
     if (next) {
       return 0; // error: unused nonblank character in fixed-width field
     }
   }
   return got;
 }
static bool EditListDirectedDefaultCharacterInput(
   }
   // Undelimited list-directed character input: stop at a value separator
   // or the end of the current record.
   std::optional<int> remaining{length};
   for (std::optional<char32_t> next{io.NextInField(remaining)}; next;
        next = io.NextInField(remaining)) {
     switch (*next) {
     case ' ':
+    case '\t':
     case ',':
     case ';':
     case '/':
       remaining = 0; // value separator: stop
       break;
     default:
       *x++ = *next;
       --length;

flang/runtime/io-stmt.cpp

return EmitRepeated(' ', static_cast<int>(width - length)) &&
         Emit(p, length);
   }
 }
 
 std::optional<char32_t> IoStatementState::SkipSpaces(
     std::optional<int> &remaining) {
   while (!remaining || *remaining > 0) {
     if (auto ch{GetCurrentChar()}) {
-      if (*ch != ' ') {
+      if (*ch != ' ' && *ch != '\t') {
         return ch;
       }
       HandleRelativePosition(1);
       if (remaining) {
         --*remaining;
       }
     } else {
       break;
     }
   }
   return std::nullopt;
 }
 
 std::optional<char32_t> IoStatementState::NextInField(
     std::optional<int> &remaining) {
   if (!remaining) { // list-directed or namelist: check for separators
     if (auto next{GetCurrentChar()}) {
       switch (*next) {
       case ' ':
+      case '\t':
       case ',':
       case ';':
       case '/':
       case '(':
       case ')':
       case '\'':
       case '"':
       case '*':
if (!connection.IsAtEOF() && connection.isFixedRecordLength &&
       }
     }
   }
   return std::nullopt;
 }
 
 std::optional<char32_t> IoStatementState::GetNextNonBlank() {
   auto ch{GetCurrentChar()};
-  while (ch.value_or(' ') == ' ') {
+  while (!ch || *ch == ' ' || *ch == '\t') {
     if (ch) {
       HandleRelativePosition(1);
     } else if (!AdvanceRecord()) {
       return std::nullopt;
     }
     ch = GetCurrentChar();
   }
   return ch;
ListDirectedStatementState<Direction::Input>::GetNextDataEdit(
   if (remaining_ > 0 && !realPart_) { // "r*c" repetition in progress
     while (connection.currentRecordNumber > initialRecordNumber_) {
       io.BackspaceRecord();
     }
     connection.HandleAbsolutePosition(initialPositionInRecord_);
     if (!imaginaryPart_) {
       edit.repeat = std::min<int>(remaining_, maxRepeat);
       auto ch{io.GetNextNonBlank()};
-      if (!ch || *ch == ' ' || *ch == comma) { // "r*" repeated null
+      if (!ch || *ch == ' ' || *ch == '\t' || *ch == comma) {
+        // "r*" repeated null
         edit.descriptor = DataEdit::ListDirectedNullValue;
       }
     }
     remaining_ -= edit.repeat;
     return edit;
   }
   // Skip separators, handle a "r*c" repeat count; see 13.10.2 in Fortran 2018
   auto ch{io.GetNextNonBlank()};
if (*ch >= '0' && *ch <= '9') { // look for "r*" repetition count
     if (r > 0 && ch && *ch == '*') { // subtle: r must be nonzero
       io.HandleRelativePosition(1);
       ch = io.GetCurrentChar();
       if (ch && *ch == '/') { // r*/
         hitSlash_ = true;
         edit.descriptor = DataEdit::ListDirectedNullValue;
         return edit;
       }
-      if (!ch || *ch == ' ' || *ch == comma) { // "r*" null
+      if (!ch || *ch == ' ' || *ch == '\t' || *ch == comma) { // "r*" null
         edit.descriptor = DataEdit::ListDirectedNullValue;
       }
       edit.repeat = std::min<int>(r, maxRepeat);
       remaining_ = r - edit.repeat;
       initialRecordNumber_ = connection.currentRecordNumber;
       initialPositionInRecord_ = connection.positionInRecord;
     } else { // not a repetition count, just an integer value; rewind
       connection.positionInRecord = start;