flang/runtime/io-api.cpp

   1 //===-- runtime/io-api.cpp ------------------------------------------------===//
   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 // Implements the I/O statement API
  10
  11 #include "flang/Runtime/io-api.h"
  12 #include "descriptor-io.h"
  13 #include "edit-input.h"
  14 #include "edit-output.h"
  15 #include "environment.h"
  16 #include "format.h"
  17 #include "io-stmt.h"
  18 #include "terminator.h"
  19 #include "tools.h"
  20 #include "unit.h"
  21 #include "flang/Runtime/descriptor.h"
  22 #include "flang/Runtime/memory.h"
  23 #include <cstdlib>
  24 #include <memory>
  25
  26 namespace Fortran::runtime::io {
  27
  28 const char *InquiryKeywordHashDecode(
  29     char *buffer, std::size_t n, InquiryKeywordHash hash) {
  30   if (n < 1) {
  31     return nullptr;
  32   }
  33   char *p{buffer + n};
  34   *--p = '\0';
  35   while (hash > 1) {
  36     if (p < buffer) {
  37       return nullptr;
  38     }
  39     *--p = 'A' + (hash % 26);
  40     hash /= 26;
  41   }
  42   return hash == 1 ? p : nullptr;
  43 }
  44
  45 template <Direction DIR>
  46 Cookie BeginInternalArrayListIO(const Descriptor &descriptor,
  47     void ** /*scratchArea*/, std::size_t /*scratchBytes*/,
  48     const char *sourceFile, int sourceLine) {
  49   Terminator oom{sourceFile, sourceLine};
  50   return &New<InternalListIoStatementState<DIR>>{oom}(
  51       descriptor, sourceFile, sourceLine)
  52               .release()
  53               ->ioStatementState();
  54 }
  55
  56 Cookie IONAME(BeginInternalArrayListOutput)(const Descriptor &descriptor,
  57     void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
  58     int sourceLine) {
  59   return BeginInternalArrayListIO<Direction::Output>(
  60       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
  61 }
  62
  63 Cookie IONAME(BeginInternalArrayListInput)(const Descriptor &descriptor,
  64     void **scratchArea, std::size_t scratchBytes, const char *sourceFile,
  65     int sourceLine) {
  66   return BeginInternalArrayListIO<Direction::Input>(
  67       descriptor, scratchArea, scratchBytes, sourceFile, sourceLine);
  68 }
  69
  70 template <Direction DIR>
  71 Cookie BeginInternalArrayFormattedIO(const Descriptor &descriptor,
  72     const char *format, std::size_t formatLength,
  73     const Descriptor *formatDescriptor, void ** /*scratchArea*/,
  74     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
  75   Terminator oom{sourceFile, sourceLine};
  76   return &New<InternalFormattedIoStatementState<DIR>>{oom}(descriptor, format,
  77       formatLength, formatDescriptor, sourceFile, sourceLine)
  78               .release()
  79               ->ioStatementState();
  80 }
  81
  82 Cookie IONAME(BeginInternalArrayFormattedOutput)(const Descriptor &descriptor,
  83     const char *format, std::size_t formatLength,
  84     const Descriptor *formatDescriptor, void **scratchArea,
  85     std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
  86   return BeginInternalArrayFormattedIO<Direction::Output>(descriptor, format,
  87       formatLength, formatDescriptor, scratchArea, scratchBytes, sourceFile,
  88       sourceLine);
  89 }
  90
  91 Cookie IONAME(BeginInternalArrayFormattedInput)(const Descriptor &descriptor,
  92     const char *format, std::size_t formatLength,
  93     const Descriptor *formatDescriptor, void **scratchArea,
  94     std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
  95   return BeginInternalArrayFormattedIO<Direction::Input>(descriptor, format,
  96       formatLength, formatDescriptor, scratchArea, scratchBytes, sourceFile,
  97       sourceLine);
  98 }
  99
 100 template <Direction DIR>
 101 Cookie BeginInternalListIO(
 102     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
 103     std::size_t internalLength, void ** /*scratchArea*/,
 104     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
 105   Terminator oom{sourceFile, sourceLine};
 106   return &New<InternalListIoStatementState<DIR>>{oom}(
 107       internal, internalLength, sourceFile, sourceLine)
 108               .release()
 109               ->ioStatementState();
 110 }
 111
 112 Cookie IONAME(BeginInternalListOutput)(char *internal,
 113     std::size_t internalLength, void **scratchArea, std::size_t scratchBytes,
 114     const char *sourceFile, int sourceLine) {
 115   return BeginInternalListIO<Direction::Output>(internal, internalLength,
 116       scratchArea, scratchBytes, sourceFile, sourceLine);
 117 }
 118
 119 Cookie IONAME(BeginInternalListInput)(const char *internal,
 120     std::size_t internalLength, void **scratchArea, std::size_t scratchBytes,
 121     const char *sourceFile, int sourceLine) {
 122   return BeginInternalListIO<Direction::Input>(internal, internalLength,
 123       scratchArea, scratchBytes, sourceFile, sourceLine);
 124 }
 125
 126 template <Direction DIR>
 127 Cookie BeginInternalFormattedIO(
 128     std::conditional_t<DIR == Direction::Input, const char, char> *internal,
 129     std::size_t internalLength, const char *format, std::size_t formatLength,
 130     const Descriptor *formatDescriptor, void ** /*scratchArea*/,
 131     std::size_t /*scratchBytes*/, const char *sourceFile, int sourceLine) {
 132   Terminator oom{sourceFile, sourceLine};
 133   return &New<InternalFormattedIoStatementState<DIR>>{oom}(internal,
 134       internalLength, format, formatLength, formatDescriptor, sourceFile,
 135       sourceLine)
 136               .release()
 137               ->ioStatementState();
 138 }
 139
 140 Cookie IONAME(BeginInternalFormattedOutput)(char *internal,
 141     std::size_t internalLength, const char *format, std::size_t formatLength,
 142     const Descriptor *formatDescriptor, void **scratchArea,
 143     std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
 144   return BeginInternalFormattedIO<Direction::Output>(internal, internalLength,
 145       format, formatLength, formatDescriptor, scratchArea, scratchBytes,
 146       sourceFile, sourceLine);
 147 }
 148
 149 Cookie IONAME(BeginInternalFormattedInput)(const char *internal,
 150     std::size_t internalLength, const char *format, std::size_t formatLength,
 151     const Descriptor *formatDescriptor, void **scratchArea,
 152     std::size_t scratchBytes, const char *sourceFile, int sourceLine) {
 153   return BeginInternalFormattedIO<Direction::Input>(internal, internalLength,
 154       format, formatLength, formatDescriptor, scratchArea, scratchBytes,
 155       sourceFile, sourceLine);
 156 }
 157
 158 static Cookie NoopUnit(const Terminator &terminator, int unitNumber,
 159     enum Iostat iostat = IostatOk) {
 160   Cookie cookie{&New<NoopStatementState>{terminator}(
 161       terminator.sourceFileName(), terminator.sourceLine(), unitNumber)
 162                      .release()
 163                      ->ioStatementState()};
 164   if (iostat != IostatOk) {
 165     cookie->GetIoErrorHandler().SetPendingError(iostat);
 166   }
 167   return cookie;
 168 }
 169
 170 static ExternalFileUnit *GetOrCreateUnit(int unitNumber, Direction direction,
 171     std::optional<bool> isUnformatted, const Terminator &terminator,
 172     Cookie &errorCookie) {
 173   if (ExternalFileUnit *
 174       unit{ExternalFileUnit::LookUpOrCreateAnonymous(
 175           unitNumber, direction, isUnformatted, terminator)}) {
 176     errorCookie = nullptr;
 177     return unit;
 178   } else {
 179     errorCookie = NoopUnit(terminator, unitNumber, IostatBadUnitNumber);
 180     return nullptr;
 181   }
 182 }
 183
 184 template <Direction DIR, template <Direction> class STATE, typename... A>
 185 Cookie BeginExternalListIO(
 186     int unitNumber, const char *sourceFile, int sourceLine, A &&...xs) {
 187   Terminator terminator{sourceFile, sourceLine};
 188   if (unitNumber == DefaultUnit) {
 189     unitNumber = DIR == Direction::Input ? 5 : 6;
 190   }
 191   Cookie errorCookie{nullptr};
 192   ExternalFileUnit *unit{GetOrCreateUnit(
 193       unitNumber, DIR, false /*!unformatted*/, terminator, errorCookie)};
 194   if (!unit) {
 195     return errorCookie;
 196   }
 197   if (!unit->isUnformatted.has_value()) {
 198     unit->isUnformatted = false;
 199   }
 200   Iostat iostat{IostatOk};
 201   if (*unit->isUnformatted) {
 202     iostat = IostatFormattedIoOnUnformattedUnit;
 203   }
 204   if (ChildIo * child{unit->GetChildIo()}) {
 205     if (iostat == IostatOk) {
 206       iostat = child->CheckFormattingAndDirection(false, DIR);
 207     }
 208     if (iostat == IostatOk) {
 209       return &child->BeginIoStatement<ChildListIoStatementState<DIR>>(
 210           *child, sourceFile, sourceLine);
 211     } else {
 212       return &child->BeginIoStatement<ErroneousIoStatementState>(
 213           iostat, nullptr /* no unit */, sourceFile, sourceLine);
 214     }
 215   } else {
 216     if (iostat == IostatOk && unit->access == Access::Direct) {
 217       iostat = IostatListIoOnDirectAccessUnit;
 218     }
 219     if (iostat == IostatOk) {
 220       iostat = unit->SetDirection(DIR);
 221     }
 222     if (iostat == IostatOk) {
 223       return &unit->BeginIoStatement<STATE<DIR>>(
 224           terminator, std::forward<A>(xs)..., *unit, sourceFile, sourceLine);
 225     } else {
 226       return &unit->BeginIoStatement<ErroneousIoStatementState>(
 227           terminator, iostat, unit, sourceFile, sourceLine);
 228     }
 229   }
 230 }
 231
 232 Cookie IONAME(BeginExternalListOutput)(
 233     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 234   return BeginExternalListIO<Direction::Output, ExternalListIoStatementState>(
 235       unitNumber, sourceFile, sourceLine);
 236 }
 237
 238 Cookie IONAME(BeginExternalListInput)(
 239     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 240   return BeginExternalListIO<Direction::Input, ExternalListIoStatementState>(
 241       unitNumber, sourceFile, sourceLine);
 242 }
 243
 244 template <Direction DIR>
 245 Cookie BeginExternalFormattedIO(const char *format, std::size_t formatLength,
 246     const Descriptor *formatDescriptor, ExternalUnit unitNumber,
 247     const char *sourceFile, int sourceLine) {
 248   Terminator terminator{sourceFile, sourceLine};
 249   if (unitNumber == DefaultUnit) {
 250     unitNumber = DIR == Direction::Input ? 5 : 6;
 251   }
 252   Cookie errorCookie{nullptr};
 253   ExternalFileUnit *unit{GetOrCreateUnit(
 254       unitNumber, DIR, false /*!unformatted*/, terminator, errorCookie)};
 255   if (!unit) {
 256     return errorCookie;
 257   }
 258   Iostat iostat{IostatOk};
 259   if (!unit->isUnformatted.has_value()) {
 260     unit->isUnformatted = false;
 261   }
 262   if (*unit->isUnformatted) {
 263     iostat = IostatFormattedIoOnUnformattedUnit;
 264   }
 265   if (ChildIo * child{unit->GetChildIo()}) {
 266     if (iostat == IostatOk) {
 267       iostat = child->CheckFormattingAndDirection(false, DIR);
 268     }
 269     if (iostat == IostatOk) {
 270       return &child->BeginIoStatement<ChildFormattedIoStatementState<DIR>>(
 271           *child, format, formatLength, formatDescriptor, sourceFile,
 272           sourceLine);
 273     } else {
 274       return &child->BeginIoStatement<ErroneousIoStatementState>(
 275           iostat, nullptr /* no unit */, sourceFile, sourceLine);
 276     }
 277   } else {
 278     if (iostat == IostatOk) {
 279       iostat = unit->SetDirection(DIR);
 280     }
 281     if (iostat == IostatOk) {
 282       return &unit->BeginIoStatement<ExternalFormattedIoStatementState<DIR>>(
 283           terminator, *unit, format, formatLength, formatDescriptor, sourceFile,
 284           sourceLine);
 285     } else {
 286       return &unit->BeginIoStatement<ErroneousIoStatementState>(
 287           terminator, iostat, unit, sourceFile, sourceLine);
 288     }
 289   }
 290 }
 291
 292 Cookie IONAME(BeginExternalFormattedOutput)(const char *format,
 293     std::size_t formatLength, const Descriptor *formatDescriptor,
 294     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 295   return BeginExternalFormattedIO<Direction::Output>(format, formatLength,
 296       formatDescriptor, unitNumber, sourceFile, sourceLine);
 297 }
 298
 299 Cookie IONAME(BeginExternalFormattedInput)(const char *format,
 300     std::size_t formatLength, const Descriptor *formatDescriptor,
 301     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 302   return BeginExternalFormattedIO<Direction::Input>(format, formatLength,
 303       formatDescriptor, unitNumber, sourceFile, sourceLine);
 304 }
 305
 306 template <Direction DIR>
 307 Cookie BeginUnformattedIO(
 308     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 309   Terminator terminator{sourceFile, sourceLine};
 310   Cookie errorCookie{nullptr};
 311   ExternalFileUnit *unit{GetOrCreateUnit(
 312       unitNumber, DIR, true /*unformatted*/, terminator, errorCookie)};
 313   if (!unit) {
 314     return errorCookie;
 315   }
 316   Iostat iostat{IostatOk};
 317   if (!unit->isUnformatted.has_value()) {
 318     unit->isUnformatted = true;
 319   }
 320   if (!*unit->isUnformatted) {
 321     iostat = IostatUnformattedIoOnFormattedUnit;
 322   }
 323   if (ChildIo * child{unit->GetChildIo()}) {
 324     if (iostat == IostatOk) {
 325       iostat = child->CheckFormattingAndDirection(true, DIR);
 326     }
 327     if (iostat == IostatOk) {
 328       return &child->BeginIoStatement<ChildUnformattedIoStatementState<DIR>>(
 329           *child, sourceFile, sourceLine);
 330     } else {
 331       return &child->BeginIoStatement<ErroneousIoStatementState>(
 332           iostat, nullptr /* no unit */, sourceFile, sourceLine);
 333     }
 334   } else {
 335     if (iostat == IostatOk) {
 336       iostat = unit->SetDirection(DIR);
 337     }
 338     if (iostat == IostatOk) {
 339       IoStatementState &io{
 340           unit->BeginIoStatement<ExternalUnformattedIoStatementState<DIR>>(
 341               terminator, *unit, sourceFile, sourceLine)};
 342       if constexpr (DIR == Direction::Output) {
 343         if (unit->access == Access::Sequential) {
 344           // Create space for (sub)record header to be completed by
 345           // ExternalFileUnit::AdvanceRecord()
 346           unit->recordLength.reset(); // in case of prior BACKSPACE
 347           io.Emit("\0\0\0\0", 4); // placeholder for record length header
 348         }
 349       }
 350       return &io;
 351     } else {
 352       return &unit->BeginIoStatement<ErroneousIoStatementState>(
 353           terminator, iostat, unit, sourceFile, sourceLine);
 354     }
 355   }
 356 }
 357
 358 Cookie IONAME(BeginUnformattedOutput)(
 359     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 360   return BeginUnformattedIO<Direction::Output>(
 361       unitNumber, sourceFile, sourceLine);
 362 }
 363
 364 Cookie IONAME(BeginUnformattedInput)(
 365     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 366   return BeginUnformattedIO<Direction::Input>(
 367       unitNumber, sourceFile, sourceLine);
 368 }
 369
 370 Cookie IONAME(BeginOpenUnit)( // OPEN(without NEWUNIT=)
 371     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 372   Terminator terminator{sourceFile, sourceLine};
 373   bool wasExtant{false};
 374   if (ExternalFileUnit *
 375       unit{ExternalFileUnit::LookUpOrCreate(
 376           unitNumber, terminator, wasExtant)}) {
 377     if (ChildIo * child{unit->GetChildIo()}) {
 378       return &child->BeginIoStatement<ErroneousIoStatementState>(
 379           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
 380           sourceLine);
 381     } else {
 382       return &unit->BeginIoStatement<OpenStatementState>(terminator, *unit,
 383           wasExtant, false /*not NEWUNIT=*/, sourceFile, sourceLine);
 384     }
 385   } else {
 386     return NoopUnit(terminator, unitNumber, IostatBadUnitNumber);
 387   }
 388 }
 389
 390 Cookie IONAME(BeginOpenNewUnit)( // OPEN(NEWUNIT=j)
 391     const char *sourceFile, int sourceLine) {
 392   Terminator terminator{sourceFile, sourceLine};
 393   ExternalFileUnit &unit{
 394       ExternalFileUnit::NewUnit(terminator, false /*not child I/O*/)};
 395   return &unit.BeginIoStatement<OpenStatementState>(terminator, unit,
 396       false /*was an existing file*/, true /*NEWUNIT=*/, sourceFile,
 397       sourceLine);
 398 }
 399
 400 Cookie IONAME(BeginWait)(ExternalUnit unitNumber, AsynchronousId id,
 401     const char *sourceFile, int sourceLine) {
 402   Terminator terminator{sourceFile, sourceLine};
 403   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
 404     if (unit->Wait(id)) {
 405       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
 406           *unit, ExternalMiscIoStatementState::Wait, sourceFile, sourceLine);
 407     } else {
 408       return &unit->BeginIoStatement<ErroneousIoStatementState>(
 409           terminator, IostatBadWaitId, unit, sourceFile, sourceLine);
 410     }
 411   } else {
 412     return NoopUnit(
 413         terminator, unitNumber, id == 0 ? IostatOk : IostatBadWaitUnit);
 414   }
 415 }
 416 Cookie IONAME(BeginWaitAll)(
 417     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 418   return IONAME(BeginWait)(unitNumber, 0 /*no ID=*/, sourceFile, sourceLine);
 419 }
 420
 421 Cookie IONAME(BeginClose)(
 422     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 423   Terminator terminator{sourceFile, sourceLine};
 424   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
 425     if (ChildIo * child{unit->GetChildIo()}) {
 426       return &child->BeginIoStatement<ErroneousIoStatementState>(
 427           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
 428           sourceLine);
 429     }
 430   }
 431   if (ExternalFileUnit * unit{ExternalFileUnit::LookUpForClose(unitNumber)}) {
 432     return &unit->BeginIoStatement<CloseStatementState>(
 433         terminator, *unit, sourceFile, sourceLine);
 434   } else {
 435     // CLOSE(UNIT=bad unit) is just a no-op
 436     return NoopUnit(terminator, unitNumber);
 437   }
 438 }
 439
 440 Cookie IONAME(BeginFlush)(
 441     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 442   Terminator terminator{sourceFile, sourceLine};
 443   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
 444     if (ChildIo * child{unit->GetChildIo()}) {
 445       return &child->BeginIoStatement<ExternalMiscIoStatementState>(
 446           *unit, ExternalMiscIoStatementState::Flush, sourceFile, sourceLine);
 447     } else {
 448       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
 449           *unit, ExternalMiscIoStatementState::Flush, sourceFile, sourceLine);
 450     }
 451   } else {
 452     // FLUSH(UNIT=bad unit) is an error; an unconnected unit is a no-op
 453     return NoopUnit(terminator, unitNumber,
 454         unitNumber >= 0 ? IostatOk : IostatBadFlushUnit);
 455   }
 456 }
 457
 458 Cookie IONAME(BeginBackspace)(
 459     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 460   Terminator terminator{sourceFile, sourceLine};
 461   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
 462     if (ChildIo * child{unit->GetChildIo()}) {
 463       return &child->BeginIoStatement<ErroneousIoStatementState>(
 464           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
 465           sourceLine);
 466     } else {
 467       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
 468           *unit, ExternalMiscIoStatementState::Backspace, sourceFile,
 469           sourceLine);
 470     }
 471   } else {
 472     return NoopUnit(terminator, unitNumber, IostatBadBackspaceUnit);
 473   }
 474 }
 475
 476 Cookie IONAME(BeginEndfile)(
 477     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 478   Terminator terminator{sourceFile, sourceLine};
 479   Cookie errorCookie{nullptr};
 480   if (ExternalFileUnit *
 481       unit{GetOrCreateUnit(unitNumber, Direction::Output, std::nullopt,
 482           terminator, errorCookie)}) {
 483     if (ChildIo * child{unit->GetChildIo()}) {
 484       return &child->BeginIoStatement<ErroneousIoStatementState>(
 485           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
 486           sourceLine);
 487     } else {
 488       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
 489           *unit, ExternalMiscIoStatementState::Endfile, sourceFile, sourceLine);
 490     }
 491   } else {
 492     return errorCookie;
 493   }
 494 }
 495
 496 Cookie IONAME(BeginRewind)(
 497     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 498   Terminator terminator{sourceFile, sourceLine};
 499   Cookie errorCookie{nullptr};
 500   if (ExternalFileUnit *
 501       unit{GetOrCreateUnit(unitNumber, Direction::Input, std::nullopt,
 502           terminator, errorCookie)}) {
 503     if (ChildIo * child{unit->GetChildIo()}) {
 504       return &child->BeginIoStatement<ErroneousIoStatementState>(
 505           IostatBadOpOnChildUnit, nullptr /* no unit */, sourceFile,
 506           sourceLine);
 507     } else {
 508       return &unit->BeginIoStatement<ExternalMiscIoStatementState>(terminator,
 509           *unit, ExternalMiscIoStatementState::Rewind, sourceFile, sourceLine);
 510     }
 511   } else {
 512     return errorCookie;
 513   }
 514 }
 515
 516 Cookie IONAME(BeginInquireUnit)(
 517     ExternalUnit unitNumber, const char *sourceFile, int sourceLine) {
 518   Terminator terminator{sourceFile, sourceLine};
 519   if (ExternalFileUnit * unit{ExternalFileUnit::LookUp(unitNumber)}) {
 520     if (ChildIo * child{unit->GetChildIo()}) {
 521       return &child->BeginIoStatement<InquireUnitState>(
 522           *unit, sourceFile, sourceLine);
 523     } else {
 524       return &unit->BeginIoStatement<InquireUnitState>(
 525           terminator, *unit, sourceFile, sourceLine);
 526     }
 527   } else {
 528     // INQUIRE(UNIT=unrecognized unit)
 529     return &New<InquireNoUnitState>{terminator}(
 530         sourceFile, sourceLine, unitNumber)
 531                 .release()
 532                 ->ioStatementState();
 533   }
 534 }
 535
 536 Cookie IONAME(BeginInquireFile)(const char *path, std::size_t pathLength,
 537     const char *sourceFile, int sourceLine) {
 538   Terminator terminator{sourceFile, sourceLine};
 539   auto trimmed{SaveDefaultCharacter(
 540       path, TrimTrailingSpaces(path, pathLength), terminator)};
 541   if (ExternalFileUnit *
 542       unit{ExternalFileUnit::LookUp(
 543           trimmed.get(), std::strlen(trimmed.get()))}) {
 544     // INQUIRE(FILE=) to a connected unit
 545     if (ChildIo * child{unit->GetChildIo()}) {
 546       return &child->BeginIoStatement<InquireUnitState>(
 547           *unit, sourceFile, sourceLine);
 548     } else {
 549       return &unit->BeginIoStatement<InquireUnitState>(
 550           terminator, *unit, sourceFile, sourceLine);
 551     }
 552   } else {
 553     return &New<InquireUnconnectedFileState>{terminator}(
 554         std::move(trimmed), sourceFile, sourceLine)
 555                 .release()
 556                 ->ioStatementState();
 557   }
 558 }
 559
 560 Cookie IONAME(BeginInquireIoLength)(const char *sourceFile, int sourceLine) {
 561   Terminator oom{sourceFile, sourceLine};
 562   return &New<InquireIOLengthState>{oom}(sourceFile, sourceLine)
 563               .release()
 564               ->ioStatementState();
 565 }
 566
 567 // Control list items
 568
 569 void IONAME(EnableHandlers)(Cookie cookie, bool hasIoStat, bool hasErr,
 570     bool hasEnd, bool hasEor, bool hasIoMsg) {
 571   IoErrorHandler &handler{cookie->GetIoErrorHandler()};
 572   if (hasIoStat) {
 573     handler.HasIoStat();
 574   }
 575   if (hasErr) {
 576     handler.HasErrLabel();
 577   }
 578   if (hasEnd) {
 579     handler.HasEndLabel();
 580   }
 581   if (hasEor) {
 582     handler.HasEorLabel();
 583   }
 584   if (hasIoMsg) {
 585     handler.HasIoMsg();
 586   }
 587 }
 588
 589 static bool YesOrNo(const char *keyword, std::size_t length, const char *what,
 590     IoErrorHandler &handler) {
 591   static const char *keywords[]{"YES", "NO", nullptr};
 592   switch (IdentifyValue(keyword, length, keywords)) {
 593   case 0:
 594     return true;
 595   case 1:
 596     return false;
 597   default:
 598     handler.SignalError(IostatErrorInKeyword, "Invalid %s='%.*s'", what,
 599         static_cast<int>(length), keyword);
 600     return false;
 601   }
 602 }
 603
 604 bool IONAME(SetAdvance)(
 605     Cookie cookie, const char *keyword, std::size_t length) {
 606   IoStatementState &io{*cookie};
 607   IoErrorHandler &handler{io.GetIoErrorHandler()};
 608   bool nonAdvancing{!YesOrNo(keyword, length, "ADVANCE", handler)};
 609   if (nonAdvancing && io.GetConnectionState().access == Access::Direct) {
 610     handler.SignalError("Non-advancing I/O attempted on direct access file");
 611   } else {
 612     auto *unit{io.GetExternalFileUnit()};
 613     if (unit && unit->GetChildIo()) {
 614       // ADVANCE= is ignored for child I/O (12.6.4.8.3 p3)
 615     } else {
 616       io.mutableModes().nonAdvancing = nonAdvancing;
 617     }
 618   }
 619   return !handler.InError();
 620 }
 621
 622 bool IONAME(SetBlank)(Cookie cookie, const char *keyword, std::size_t length) {
 623   IoStatementState &io{*cookie};
 624   static const char *keywords[]{"NULL", "ZERO", nullptr};
 625   switch (IdentifyValue(keyword, length, keywords)) {
 626   case 0:
 627     io.mutableModes().editingFlags &= ~blankZero;
 628     return true;
 629   case 1:
 630     io.mutableModes().editingFlags |= blankZero;
 631     return true;
 632   default:
 633     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
 634         "Invalid BLANK='%.*s'", static_cast<int>(length), keyword);
 635     return false;
 636   }
 637 }
 638
 639 bool IONAME(SetDecimal)(
 640     Cookie cookie, const char *keyword, std::size_t length) {
 641   IoStatementState &io{*cookie};
 642   static const char *keywords[]{"COMMA", "POINT", nullptr};
 643   switch (IdentifyValue(keyword, length, keywords)) {
 644   case 0:
 645     io.mutableModes().editingFlags |= decimalComma;
 646     return true;
 647   case 1:
 648     io.mutableModes().editingFlags &= ~decimalComma;
 649     return true;
 650   default:
 651     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
 652         "Invalid DECIMAL='%.*s'", static_cast<int>(length), keyword);
 653     return false;
 654   }
 655 }
 656
 657 bool IONAME(SetDelim)(Cookie cookie, const char *keyword, std::size_t length) {
 658   IoStatementState &io{*cookie};
 659   static const char *keywords[]{"APOSTROPHE", "QUOTE", "NONE", nullptr};
 660   switch (IdentifyValue(keyword, length, keywords)) {
 661   case 0:
 662     io.mutableModes().delim = '\'';
 663     return true;
 664   case 1:
 665     io.mutableModes().delim = '"';
 666     return true;
 667   case 2:
 668     io.mutableModes().delim = '\0';
 669     return true;
 670   default:
 671     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
 672         "Invalid DELIM='%.*s'", static_cast<int>(length), keyword);
 673     return false;
 674   }
 675 }
 676
 677 bool IONAME(SetPad)(Cookie cookie, const char *keyword, std::size_t length) {
 678   IoStatementState &io{*cookie};
 679   IoErrorHandler &handler{io.GetIoErrorHandler()};
 680   io.mutableModes().pad = YesOrNo(keyword, length, "PAD", handler);
 681   return !handler.InError();
 682 }
 683
 684 bool IONAME(SetPos)(Cookie cookie, std::int64_t pos) {
 685   IoStatementState &io{*cookie};
 686   IoErrorHandler &handler{io.GetIoErrorHandler()};
 687   if (auto *unit{io.GetExternalFileUnit()}) {
 688     return unit->SetStreamPos(pos, handler);
 689   } else if (!io.get_if<ErroneousIoStatementState>()) {
 690     handler.Crash("SetPos() called on internal unit");
 691   }
 692   return false;
 693 }
 694
 695 bool IONAME(SetRec)(Cookie cookie, std::int64_t rec) {
 696   IoStatementState &io{*cookie};
 697   IoErrorHandler &handler{io.GetIoErrorHandler()};
 698   if (auto *unit{io.GetExternalFileUnit()}) {
 699     if (unit->GetChildIo()) {
 700       handler.SignalError(
 701           IostatBadOpOnChildUnit, "REC= specifier on child I/O");
 702     } else {
 703       unit->SetDirectRec(rec, handler);
 704     }
 705   } else if (!io.get_if<ErroneousIoStatementState>()) {
 706     handler.Crash("SetRec() called on internal unit");
 707   }
 708   return true;
 709 }
 710
 711 bool IONAME(SetRound)(Cookie cookie, const char *keyword, std::size_t length) {
 712   IoStatementState &io{*cookie};
 713   static const char *keywords[]{"UP", "DOWN", "ZERO", "NEAREST", "COMPATIBLE",
 714       "PROCESSOR_DEFINED", nullptr};
 715   switch (IdentifyValue(keyword, length, keywords)) {
 716   case 0:
 717     io.mutableModes().round = decimal::RoundUp;
 718     return true;
 719   case 1:
 720     io.mutableModes().round = decimal::RoundDown;
 721     return true;
 722   case 2:
 723     io.mutableModes().round = decimal::RoundToZero;
 724     return true;
 725   case 3:
 726     io.mutableModes().round = decimal::RoundNearest;
 727     return true;
 728   case 4:
 729     io.mutableModes().round = decimal::RoundCompatible;
 730     return true;
 731   case 5:
 732     io.mutableModes().round = executionEnvironment.defaultOutputRoundingMode;
 733     return true;
 734   default:
 735     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
 736         "Invalid ROUND='%.*s'", static_cast<int>(length), keyword);
 737     return false;
 738   }
 739 }
 740
 741 bool IONAME(SetSign)(Cookie cookie, const char *keyword, std::size_t length) {
 742   IoStatementState &io{*cookie};
 743   static const char *keywords[]{
 744       "PLUS", "SUPPRESS", "PROCESSOR_DEFINED", nullptr};
 745   switch (IdentifyValue(keyword, length, keywords)) {
 746   case 0:
 747     io.mutableModes().editingFlags |= signPlus;
 748     return true;
 749   case 1:
 750   case 2: // processor default is SS
 751     io.mutableModes().editingFlags &= ~signPlus;
 752     return true;
 753   default:
 754     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
 755         "Invalid SIGN='%.*s'", static_cast<int>(length), keyword);
 756     return false;
 757   }
 758 }
 759
 760 bool IONAME(SetAccess)(Cookie cookie, const char *keyword, std::size_t length) {
 761   IoStatementState &io{*cookie};
 762   auto *open{io.get_if<OpenStatementState>()};
 763   if (!open) {
 764     if (!io.get_if<ErroneousIoStatementState>()) {
 765       io.GetIoErrorHandler().Crash(
 766           "SetAccess() called when not in an OPEN statement");
 767     }
 768     return false;
 769   } else if (open->completedOperation()) {
 770     io.GetIoErrorHandler().Crash(
 771         "SetAccess() called after GetNewUnit() for an OPEN statement");
 772   }
 773   static const char *keywords[]{
 774       "SEQUENTIAL", "DIRECT", "STREAM", "APPEND", nullptr};
 775   switch (IdentifyValue(keyword, length, keywords)) {
 776   case 0:
 777     open->set_access(Access::Sequential);
 778     break;
 779   case 1:
 780     open->set_access(Access::Direct);
 781     break;
 782   case 2:
 783     open->set_access(Access::Stream);
 784     break;
 785   case 3: // Sun Fortran extension ACCESS=APPEND: treat as if POSITION=APPEND
 786     open->set_position(Position::Append);
 787     break;
 788   default:
 789     open->SignalError(IostatErrorInKeyword, "Invalid ACCESS='%.*s'",
 790         static_cast<int>(length), keyword);
 791   }
 792   return true;
 793 }
 794
 795 bool IONAME(SetAction)(Cookie cookie, const char *keyword, std::size_t length) {
 796   IoStatementState &io{*cookie};
 797   auto *open{io.get_if<OpenStatementState>()};
 798   if (!open) {
 799     if (!io.get_if<ErroneousIoStatementState>()) {
 800       io.GetIoErrorHandler().Crash(
 801           "SetAction() called when not in an OPEN statement");
 802     }
 803     return false;
 804   } else if (open->completedOperation()) {
 805     io.GetIoErrorHandler().Crash(
 806         "SetAction() called after GetNewUnit() for an OPEN statement");
 807   }
 808   std::optional<Action> action;
 809   static const char *keywords[]{"READ", "WRITE", "READWRITE", nullptr};
 810   switch (IdentifyValue(keyword, length, keywords)) {
 811   case 0:
 812     action = Action::Read;
 813     break;
 814   case 1:
 815     action = Action::Write;
 816     break;
 817   case 2:
 818     action = Action::ReadWrite;
 819     break;
 820   default:
 821     open->SignalError(IostatErrorInKeyword, "Invalid ACTION='%.*s'",
 822         static_cast<int>(length), keyword);
 823     return false;
 824   }
 825   RUNTIME_CHECK(io.GetIoErrorHandler(), action.has_value());
 826   if (open->wasExtant()) {
 827     if ((*action != Action::Write) != open->unit().mayRead() ||
 828         (*action != Action::Read) != open->unit().mayWrite()) {
 829       open->SignalError("ACTION= may not be changed on an open unit");
 830     }
 831   }
 832   open->set_action(*action);
 833   return true;
 834 }
 835
 836 bool IONAME(SetAsynchronous)(
 837     Cookie cookie, const char *keyword, std::size_t length) {
 838   IoStatementState &io{*cookie};
 839   IoErrorHandler &handler{io.GetIoErrorHandler()};
 840   bool isYes{YesOrNo(keyword, length, "ASYNCHRONOUS", handler)};
 841   if (auto *open{io.get_if<OpenStatementState>()}) {
 842     if (open->completedOperation()) {
 843       handler.Crash(
 844           "SetAsynchronous() called after GetNewUnit() for an OPEN statement");
 845     }
 846     open->unit().set_mayAsynchronous(isYes);
 847   } else if (auto *ext{io.get_if<ExternalIoStatementBase>()}) {
 848     if (isYes) {
 849       if (ext->unit().mayAsynchronous()) {
 850         ext->SetAsynchronous();
 851       } else {
 852         handler.SignalError(IostatBadAsynchronous);
 853       }
 854     }
 855   } else if (!io.get_if<ErroneousIoStatementState>()) {
 856     handler.Crash("SetAsynchronous() called when not in an OPEN or external "
 857                   "I/O statement");
 858   }
 859   return !handler.InError();
 860 }
 861
 862 bool IONAME(SetCarriagecontrol)(
 863     Cookie cookie, const char *keyword, std::size_t length) {
 864   IoStatementState &io{*cookie};
 865   auto *open{io.get_if<OpenStatementState>()};
 866   if (!open) {
 867     if (!io.get_if<ErroneousIoStatementState>()) {
 868       io.GetIoErrorHandler().Crash(
 869           "SetCarriageControl() called when not in an OPEN statement");
 870     }
 871     return false;
 872   } else if (open->completedOperation()) {
 873     io.GetIoErrorHandler().Crash(
 874         "SetCarriageControl() called after GetNewUnit() for an OPEN statement");
 875   }
 876   static const char *keywords[]{"LIST", "FORTRAN", "NONE", nullptr};
 877   switch (IdentifyValue(keyword, length, keywords)) {
 878   case 0:
 879     return true;
 880   case 1:
 881   case 2:
 882     open->SignalError(IostatErrorInKeyword,
 883         "Unimplemented CARRIAGECONTROL='%.*s'", static_cast<int>(length),
 884         keyword);
 885     return false;
 886   default:
 887     open->SignalError(IostatErrorInKeyword, "Invalid CARRIAGECONTROL='%.*s'",
 888         static_cast<int>(length), keyword);
 889     return false;
 890   }
 891 }
 892
 893 bool IONAME(SetConvert)(
 894     Cookie cookie, const char *keyword, std::size_t length) {
 895   IoStatementState &io{*cookie};
 896   auto *open{io.get_if<OpenStatementState>()};
 897   if (!open) {
 898     if (!io.get_if<ErroneousIoStatementState>()) {
 899       io.GetIoErrorHandler().Crash(
 900           "SetConvert() called when not in an OPEN statement");
 901     }
 902     return false;
 903   } else if (open->completedOperation()) {
 904     io.GetIoErrorHandler().Crash(
 905         "SetConvert() called after GetNewUnit() for an OPEN statement");
 906   }
 907   if (auto convert{GetConvertFromString(keyword, length)}) {
 908     open->set_convert(*convert);
 909     return true;
 910   } else {
 911     open->SignalError(IostatErrorInKeyword, "Invalid CONVERT='%.*s'",
 912         static_cast<int>(length), keyword);
 913     return false;
 914   }
 915 }
 916
 917 bool IONAME(SetEncoding)(
 918     Cookie cookie, const char *keyword, std::size_t length) {
 919   IoStatementState &io{*cookie};
 920   auto *open{io.get_if<OpenStatementState>()};
 921   if (!open) {
 922     if (!io.get_if<ErroneousIoStatementState>()) {
 923       io.GetIoErrorHandler().Crash(
 924           "SetEncoding() called when not in an OPEN statement");
 925     }
 926     return false;
 927   } else if (open->completedOperation()) {
 928     io.GetIoErrorHandler().Crash(
 929         "SetEncoding() called after GetNewUnit() for an OPEN statement");
 930   }
 931   // Allow the encoding to be changed on an open unit -- it's
 932   // useful and safe.
 933   static const char *keywords[]{"UTF-8", "DEFAULT", nullptr};
 934   switch (IdentifyValue(keyword, length, keywords)) {
 935   case 0:
 936     open->unit().isUTF8 = true;
 937     break;
 938   case 1:
 939     open->unit().isUTF8 = false;
 940     break;
 941   default:
 942     open->SignalError(IostatErrorInKeyword, "Invalid ENCODING='%.*s'",
 943         static_cast<int>(length), keyword);
 944   }
 945   return true;
 946 }
 947
 948 bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
 949   IoStatementState &io{*cookie};
 950   auto *open{io.get_if<OpenStatementState>()};
 951   if (!open) {
 952     if (!io.get_if<ErroneousIoStatementState>()) {
 953       io.GetIoErrorHandler().Crash(
 954           "SetForm() called when not in an OPEN statement");
 955     }
 956   } else if (open->completedOperation()) {
 957     io.GetIoErrorHandler().Crash(
 958         "SetForm() called after GetNewUnit() for an OPEN statement");
 959   }
 960   static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
 961   switch (IdentifyValue(keyword, length, keywords)) {
 962   case 0:
 963     open->set_isUnformatted(false);
 964     break;
 965   case 1:
 966     open->set_isUnformatted(true);
 967     break;
 968   default:
 969     open->SignalError(IostatErrorInKeyword, "Invalid FORM='%.*s'",
 970         static_cast<int>(length), keyword);
 971   }
 972   return true;
 973 }
 974
 975 bool IONAME(SetPosition)(
 976     Cookie cookie, const char *keyword, std::size_t length) {
 977   IoStatementState &io{*cookie};
 978   auto *open{io.get_if<OpenStatementState>()};
 979   if (!open) {
 980     if (!io.get_if<ErroneousIoStatementState>()) {
 981       io.GetIoErrorHandler().Crash(
 982           "SetPosition() called when not in an OPEN statement");
 983     }
 984     return false;
 985   } else if (open->completedOperation()) {
 986     io.GetIoErrorHandler().Crash(
 987         "SetPosition() called after GetNewUnit() for an OPEN statement");
 988   }
 989   static const char *positions[]{"ASIS", "REWIND", "APPEND", nullptr};
 990   switch (IdentifyValue(keyword, length, positions)) {
 991   case 0:
 992     open->set_position(Position::AsIs);
 993     return true;
 994   case 1:
 995     open->set_position(Position::Rewind);
 996     return true;
 997   case 2:
 998     open->set_position(Position::Append);
 999     return true;
1000   default:
1001     io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
1002         "Invalid POSITION='%.*s'", static_cast<int>(length), keyword);
1003   }
1004   return true;
1005 }
1006
1007 bool IONAME(SetRecl)(Cookie cookie, std::size_t n) {
1008   IoStatementState &io{*cookie};
1009   auto *open{io.get_if<OpenStatementState>()};
1010   if (!open) {
1011     if (!io.get_if<ErroneousIoStatementState>()) {
1012       io.GetIoErrorHandler().Crash(
1013           "SetRecl() called when not in an OPEN statement");
1014     }
1015     return false;
1016   } else if (open->completedOperation()) {
1017     io.GetIoErrorHandler().Crash(
1018         "SetRecl() called after GetNewUnit() for an OPEN statement");
1019   }
1020   if (n <= 0) {
1021     io.GetIoErrorHandler().SignalError("RECL= must be greater than zero");
1022     return false;
1023   } else if (open->wasExtant() &&
1024       open->unit().openRecl.value_or(0) != static_cast<std::int64_t>(n)) {
1025     open->SignalError("RECL= may not be changed for an open unit");
1026     return false;
1027   } else {
1028     open->unit().openRecl = n;
1029     return true;
1030   }
1031 }
1032
1033 bool IONAME(SetStatus)(Cookie cookie, const char *keyword, std::size_t length) {
1034   IoStatementState &io{*cookie};
1035   if (auto *open{io.get_if<OpenStatementState>()}) {
1036     if (open->completedOperation()) {
1037       io.GetIoErrorHandler().Crash(
1038           "SetStatus() called after GetNewUnit() for an OPEN statement");
1039     }
1040     static const char *statuses[]{
1041         "OLD", "NEW", "SCRATCH", "REPLACE", "UNKNOWN", nullptr};
1042     switch (IdentifyValue(keyword, length, statuses)) {
1043     case 0:
1044       open->set_status(OpenStatus::Old);
1045       return true;
1046     case 1:
1047       open->set_status(OpenStatus::New);
1048       return true;
1049     case 2:
1050       open->set_status(OpenStatus::Scratch);
1051       return true;
1052     case 3:
1053       open->set_status(OpenStatus::Replace);
1054       return true;
1055     case 4:
1056       open->set_status(OpenStatus::Unknown);
1057       return true;
1058     default:
1059       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
1060           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
1061     }
1062     return false;
1063   }
1064   if (auto *close{io.get_if<CloseStatementState>()}) {
1065     static const char *statuses[]{"KEEP", "DELETE", nullptr};
1066     switch (IdentifyValue(keyword, length, statuses)) {
1067     case 0:
1068       close->set_status(CloseStatus::Keep);
1069       return true;
1070     case 1:
1071       close->set_status(CloseStatus::Delete);
1072       return true;
1073     default:
1074       io.GetIoErrorHandler().SignalError(IostatErrorInKeyword,
1075           "Invalid STATUS='%.*s'", static_cast<int>(length), keyword);
1076     }
1077     return false;
1078   }
1079   if (io.get_if<NoopStatementState>() ||
1080       io.get_if<ErroneousIoStatementState>()) {
1081     return true; // don't bother validating STATUS= in a no-op CLOSE
1082   }
1083   io.GetIoErrorHandler().Crash(
1084       "SetStatus() called when not in an OPEN or CLOSE statement");
1085 }
1086
1087 bool IONAME(SetFile)(Cookie cookie, const char *path, std::size_t chars) {
1088   IoStatementState &io{*cookie};
1089   if (auto *open{io.get_if<OpenStatementState>()}) {
1090     if (open->completedOperation()) {
1091       io.GetIoErrorHandler().Crash(
1092           "SetFile() called after GetNewUnit() for an OPEN statement");
1093     }
1094     open->set_path(path, chars);
1095     return true;
1096   } else if (!io.get_if<ErroneousIoStatementState>()) {
1097     io.GetIoErrorHandler().Crash(
1098         "SetFile() called when not in an OPEN statement");
1099   }
1100   return false;
1101 }
1102
1103 bool IONAME(GetNewUnit)(Cookie cookie, int &unit, int kind) {
1104   IoStatementState &io{*cookie};
1105   auto *open{io.get_if<OpenStatementState>()};
1106   if (!open) {
1107     if (!io.get_if<ErroneousIoStatementState>()) {
1108       io.GetIoErrorHandler().Crash(
1109           "GetNewUnit() called when not in an OPEN statement");
1110     }
1111     return false;
1112   } else if (!open->InError()) {
1113     open->CompleteOperation();
1114   }
1115   if (open->InError()) {
1116     // A failed OPEN(NEWUNIT=n) does not modify 'n'
1117     return false;
1118   }
1119   std::int64_t result{open->unit().unitNumber()};
1120   if (!SetInteger(unit, kind, result)) {
1121     open->SignalError("GetNewUnit(): bad INTEGER kind(%d) or out-of-range "
1122                       "value(%jd) for result",
1123         kind, static_cast<std::intmax_t>(result));
1124   }
1125   return true;
1126 }
1127
1128 // Data transfers
1129
1130 bool IONAME(OutputDescriptor)(Cookie cookie, const Descriptor &descriptor) {
1131   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1132 }
1133
1134 bool IONAME(InputDescriptor)(Cookie cookie, const Descriptor &descriptor) {
1135   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1136 }
1137
1138 bool IONAME(OutputUnformattedBlock)(Cookie cookie, const char *x,
1139     std::size_t length, std::size_t elementBytes) {
1140   IoStatementState &io{*cookie};
1141   if (auto *unf{io.get_if<
1142           ExternalUnformattedIoStatementState<Direction::Output>>()}) {
1143     return unf->Emit(x, length, elementBytes);
1144   } else if (auto *inq{io.get_if<InquireIOLengthState>()}) {
1145     return inq->Emit(x, length, elementBytes);
1146   } else if (!io.get_if<ErroneousIoStatementState>()) {
1147     io.GetIoErrorHandler().Crash("OutputUnformattedBlock() called for an I/O "
1148                                  "statement that is not unformatted output");
1149   }
1150   return false;
1151 }
1152
1153 bool IONAME(InputUnformattedBlock)(
1154     Cookie cookie, char *x, std::size_t length, std::size_t elementBytes) {
1155   IoStatementState &io{*cookie};
1156   IoErrorHandler &handler{io.GetIoErrorHandler()};
1157   io.BeginReadingRecord();
1158   if (handler.InError()) {
1159     return false;
1160   }
1161   if (auto *unf{
1162           io.get_if<ExternalUnformattedIoStatementState<Direction::Input>>()}) {
1163     return unf->Receive(x, length, elementBytes);
1164   } else if (!io.get_if<ErroneousIoStatementState>()) {
1165     handler.Crash("InputUnformattedBlock() called for an I/O statement that is "
1166                   "not unformatted input");
1167   }
1168   return false;
1169 }
1170
1171 bool IONAME(OutputInteger8)(Cookie cookie, std::int8_t n) {
1172   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger8")) {
1173     return false;
1174   }
1175   StaticDescriptor staticDescriptor;
1176   Descriptor &descriptor{staticDescriptor.descriptor()};
1177   descriptor.Establish(
1178       TypeCategory::Integer, 1, reinterpret_cast<void *>(&n), 0);
1179   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1180 }
1181
1182 bool IONAME(OutputInteger16)(Cookie cookie, std::int16_t n) {
1183   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger16")) {
1184     return false;
1185   }
1186   StaticDescriptor staticDescriptor;
1187   Descriptor &descriptor{staticDescriptor.descriptor()};
1188   descriptor.Establish(
1189       TypeCategory::Integer, 2, reinterpret_cast<void *>(&n), 0);
1190   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1191 }
1192
1193 bool IONAME(OutputInteger32)(Cookie cookie, std::int32_t n) {
1194   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger32")) {
1195     return false;
1196   }
1197   StaticDescriptor staticDescriptor;
1198   Descriptor &descriptor{staticDescriptor.descriptor()};
1199   descriptor.Establish(
1200       TypeCategory::Integer, 4, reinterpret_cast<void *>(&n), 0);
1201   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1202 }
1203
1204 bool IONAME(OutputInteger64)(Cookie cookie, std::int64_t n) {
1205   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger64")) {
1206     return false;
1207   }
1208   StaticDescriptor staticDescriptor;
1209   Descriptor &descriptor{staticDescriptor.descriptor()};
1210   descriptor.Establish(
1211       TypeCategory::Integer, 8, reinterpret_cast<void *>(&n), 0);
1212   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1213 }
1214
1215 #ifdef __SIZEOF_INT128__
1216 bool IONAME(OutputInteger128)(Cookie cookie, common::int128_t n) {
1217   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputInteger128")) {
1218     return false;
1219   }
1220   StaticDescriptor staticDescriptor;
1221   Descriptor &descriptor{staticDescriptor.descriptor()};
1222   descriptor.Establish(
1223       TypeCategory::Integer, 16, reinterpret_cast<void *>(&n), 0);
1224   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1225 }
1226 #endif
1227
1228 bool IONAME(InputInteger)(Cookie cookie, std::int64_t &n, int kind) {
1229   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputInteger")) {
1230     return false;
1231   }
1232   StaticDescriptor staticDescriptor;
1233   Descriptor &descriptor{staticDescriptor.descriptor()};
1234   descriptor.Establish(
1235       TypeCategory::Integer, kind, reinterpret_cast<void *>(&n), 0);
1236   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1237 }
1238
1239 bool IONAME(OutputReal32)(Cookie cookie, float x) {
1240   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputReal32")) {
1241     return false;
1242   }
1243   StaticDescriptor staticDescriptor;
1244   Descriptor &descriptor{staticDescriptor.descriptor()};
1245   descriptor.Establish(TypeCategory::Real, 4, reinterpret_cast<void *>(&x), 0);
1246   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1247 }
1248
1249 bool IONAME(OutputReal64)(Cookie cookie, double x) {
1250   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputReal64")) {
1251     return false;
1252   }
1253   StaticDescriptor staticDescriptor;
1254   Descriptor &descriptor{staticDescriptor.descriptor()};
1255   descriptor.Establish(TypeCategory::Real, 8, reinterpret_cast<void *>(&x), 0);
1256   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1257 }
1258
1259 bool IONAME(InputReal32)(Cookie cookie, float &x) {
1260   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputReal32")) {
1261     return false;
1262   }
1263   StaticDescriptor staticDescriptor;
1264   Descriptor &descriptor{staticDescriptor.descriptor()};
1265   descriptor.Establish(TypeCategory::Real, 4, reinterpret_cast<void *>(&x), 0);
1266   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1267 }
1268
1269 bool IONAME(InputReal64)(Cookie cookie, double &x) {
1270   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputReal64")) {
1271     return false;
1272   }
1273   StaticDescriptor staticDescriptor;
1274   Descriptor &descriptor{staticDescriptor.descriptor()};
1275   descriptor.Establish(TypeCategory::Real, 8, reinterpret_cast<void *>(&x), 0);
1276   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1277 }
1278
1279 bool IONAME(OutputComplex32)(Cookie cookie, float r, float i) {
1280   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputComplex32")) {
1281     return false;
1282   }
1283   float z[2]{r, i};
1284   StaticDescriptor staticDescriptor;
1285   Descriptor &descriptor{staticDescriptor.descriptor()};
1286   descriptor.Establish(
1287       TypeCategory::Complex, 4, reinterpret_cast<void *>(&z), 0);
1288   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1289 }
1290
1291 bool IONAME(OutputComplex64)(Cookie cookie, double r, double i) {
1292   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputComplex64")) {
1293     return false;
1294   }
1295   double z[2]{r, i};
1296   StaticDescriptor staticDescriptor;
1297   Descriptor &descriptor{staticDescriptor.descriptor()};
1298   descriptor.Establish(
1299       TypeCategory::Complex, 8, reinterpret_cast<void *>(&z), 0);
1300   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1301 }
1302
1303 bool IONAME(InputComplex32)(Cookie cookie, float z[2]) {
1304   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputComplex32")) {
1305     return false;
1306   }
1307   StaticDescriptor staticDescriptor;
1308   Descriptor &descriptor{staticDescriptor.descriptor()};
1309   descriptor.Establish(
1310       TypeCategory::Complex, 4, reinterpret_cast<void *>(z), 0);
1311   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1312 }
1313
1314 bool IONAME(InputComplex64)(Cookie cookie, double z[2]) {
1315   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputComplex64")) {
1316     return false;
1317   }
1318   StaticDescriptor staticDescriptor;
1319   Descriptor &descriptor{staticDescriptor.descriptor()};
1320   descriptor.Establish(
1321       TypeCategory::Complex, 8, reinterpret_cast<void *>(z), 0);
1322   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1323 }
1324
1325 bool IONAME(OutputCharacter)(
1326     Cookie cookie, const char *x, std::size_t length, int kind) {
1327   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputCharacter")) {
1328     return false;
1329   }
1330   StaticDescriptor staticDescriptor;
1331   Descriptor &descriptor{staticDescriptor.descriptor()};
1332   descriptor.Establish(
1333       kind, length, reinterpret_cast<void *>(const_cast<char *>(x)), 0);
1334   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1335 }
1336
1337 bool IONAME(OutputAscii)(Cookie cookie, const char *x, std::size_t length) {
1338   return IONAME(OutputCharacter(cookie, x, length, 1));
1339 }
1340
1341 bool IONAME(InputCharacter)(
1342     Cookie cookie, char *x, std::size_t length, int kind) {
1343   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputCharacter")) {
1344     return false;
1345   }
1346   StaticDescriptor staticDescriptor;
1347   Descriptor &descriptor{staticDescriptor.descriptor()};
1348   descriptor.Establish(kind, length, reinterpret_cast<void *>(x), 0);
1349   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1350 }
1351
1352 bool IONAME(InputAscii)(Cookie cookie, char *x, std::size_t length) {
1353   return IONAME(InputCharacter)(cookie, x, length, 1);
1354 }
1355
1356 bool IONAME(OutputLogical)(Cookie cookie, bool truth) {
1357   if (!cookie->CheckFormattedStmtType<Direction::Output>("OutputLogical")) {
1358     return false;
1359   }
1360   StaticDescriptor staticDescriptor;
1361   Descriptor &descriptor{staticDescriptor.descriptor()};
1362   descriptor.Establish(
1363       TypeCategory::Logical, sizeof truth, reinterpret_cast<void *>(&truth), 0);
1364   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor);
1365 }
1366
1367 bool IONAME(InputLogical)(Cookie cookie, bool &truth) {
1368   if (!cookie->CheckFormattedStmtType<Direction::Input>("InputLogical")) {
1369     return false;
1370   }
1371   StaticDescriptor staticDescriptor;
1372   Descriptor &descriptor{staticDescriptor.descriptor()};
1373   descriptor.Establish(
1374       TypeCategory::Logical, sizeof truth, reinterpret_cast<void *>(&truth), 0);
1375   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor);
1376 }
1377
1378 bool IONAME(OutputDerivedType)(Cookie cookie, const Descriptor &descriptor,
1379     const NonTbpDefinedIoTable *table) {
1380   return descr::DescriptorIO<Direction::Output>(*cookie, descriptor, table);
1381 }
1382
1383 bool IONAME(InputDerivedType)(Cookie cookie, const Descriptor &descriptor,
1384     const NonTbpDefinedIoTable *table) {
1385   return descr::DescriptorIO<Direction::Input>(*cookie, descriptor, table);
1386 }
1387
1388 std::size_t IONAME(GetSize)(Cookie cookie) {
1389   IoStatementState &io{*cookie};
1390   IoErrorHandler &handler{io.GetIoErrorHandler()};
1391   if (!handler.InError()) {
1392     io.CompleteOperation();
1393   }
1394   if (const auto *formatted{
1395           io.get_if<FormattedIoStatementState<Direction::Input>>()}) {
1396     return formatted->GetEditDescriptorChars();
1397   } else if (!io.get_if<ErroneousIoStatementState>()) {
1398     handler.Crash("GetIoSize() called for an I/O statement that is not a "
1399                   "formatted READ()");
1400   }
1401   return 0;
1402 }
1403
1404 std::size_t IONAME(GetIoLength)(Cookie cookie) {
1405   IoStatementState &io{*cookie};
1406   IoErrorHandler &handler{io.GetIoErrorHandler()};
1407   if (!handler.InError()) {
1408     io.CompleteOperation();
1409   }
1410   if (const auto *inq{io.get_if<InquireIOLengthState>()}) {
1411     return inq->bytes();
1412   } else if (!io.get_if<ErroneousIoStatementState>()) {
1413     handler.Crash("GetIoLength() called for an I/O statement that is not "
1414                   "INQUIRE(IOLENGTH=)");
1415   }
1416   return 0;
1417 }
1418
1419 void IONAME(GetIoMsg)(Cookie cookie, char *msg, std::size_t length) {
1420   IoStatementState &io{*cookie};
1421   IoErrorHandler &handler{io.GetIoErrorHandler()};
1422   if (!handler.InError()) {
1423     io.CompleteOperation();
1424   }
1425   if (handler.InError()) { // leave "msg" alone when no error
1426     handler.GetIoMsg(msg, length);
1427   }
1428 }
1429
1430 bool IONAME(InquireCharacter)(Cookie cookie, InquiryKeywordHash inquiry,
1431     char *result, std::size_t length) {
1432   IoStatementState &io{*cookie};
1433   return io.Inquire(inquiry, result, length);
1434 }
1435
1436 bool IONAME(InquireLogical)(
1437     Cookie cookie, InquiryKeywordHash inquiry, bool &result) {
1438   IoStatementState &io{*cookie};
1439   return io.Inquire(inquiry, result);
1440 }
1441
1442 bool IONAME(InquirePendingId)(Cookie cookie, std::int64_t id, bool &result) {
1443   IoStatementState &io{*cookie};
1444   return io.Inquire(HashInquiryKeyword("PENDING"), id, result);
1445 }
1446
1447 bool IONAME(InquireInteger64)(
1448     Cookie cookie, InquiryKeywordHash inquiry, std::int64_t &result, int kind) {
1449   IoStatementState &io{*cookie};
1450   std::int64_t n{0}; // safe "undefined" value
1451   if (io.Inquire(inquiry, n)) {
1452     if (SetInteger(result, kind, n)) {
1453       return true;
1454     }
1455     io.GetIoErrorHandler().SignalError(
1456         "InquireInteger64(): bad INTEGER kind(%d) or out-of-range "
1457         "value(%jd) for result",
1458         kind, static_cast<std::intmax_t>(n));
1459   }
1460   return false;
1461 }
1462
1463 enum Iostat IONAME(EndIoStatement)(Cookie cookie) {
1464   IoStatementState &io{*cookie};
1465   return static_cast<enum Iostat>(io.EndIoStatement());
1466 }
1467
1468 template <typename INT>
1469 static enum Iostat CheckUnitNumberInRangeImpl(INT unit, bool handleError,
1470     char *ioMsg, std::size_t ioMsgLength, const char *sourceFile,
1471     int sourceLine) {
1472   static_assert(sizeof(INT) >= sizeof(ExternalUnit),
1473       "only intended to be used when the INT to ExternalUnit conversion is "
1474       "narrowing");
1475   if (unit != static_cast<ExternalUnit>(unit)) {
1476     Terminator oom{sourceFile, sourceLine};
1477     IoErrorHandler errorHandler{oom};
1478     if (handleError) {
1479       errorHandler.HasIoStat();
1480       if (ioMsg) {
1481         errorHandler.HasIoMsg();
1482       }
1483     }
1484     // Only provide the bad unit number in the message if SignalError can print
1485     // it accurately. Otherwise, the generic IostatUnitOverflow message will be
1486     // used.
1487     if constexpr (sizeof(INT) > sizeof(std::intmax_t)) {
1488       errorHandler.SignalError(IostatUnitOverflow);
1489     } else if (static_cast<std::intmax_t>(unit) == unit) {
1490       errorHandler.SignalError(IostatUnitOverflow,
1491           "UNIT number %jd is out of range", static_cast<std::intmax_t>(unit));
1492     } else {
1493       errorHandler.SignalError(IostatUnitOverflow);
1494     }
1495     if (ioMsg) {
1496       errorHandler.GetIoMsg(ioMsg, ioMsgLength);
1497     }
1498     return static_cast<enum Iostat>(errorHandler.GetIoStat());
1499   }
1500   return IostatOk;
1501 }
1502
1503 enum Iostat IONAME(CheckUnitNumberInRange64)(std::int64_t unit,
1504     bool handleError, char *ioMsg, std::size_t ioMsgLength,
1505     const char *sourceFile, int sourceLine) {
1506   return CheckUnitNumberInRangeImpl(
1507       unit, handleError, ioMsg, ioMsgLength, sourceFile, sourceLine);
1508 }
1509
1510 #ifdef __SIZEOF_INT128__
1511 enum Iostat IONAME(CheckUnitNumberInRange128)(common::int128_t unit,
1512     bool handleError, char *ioMsg, std::size_t ioMsgLength,
1513     const char *sourceFile, int sourceLine) {
1514   return CheckUnitNumberInRangeImpl(
1515       unit, handleError, ioMsg, ioMsgLength, sourceFile, sourceLine);
1516 }
1517 #endif
1518
1519 } // namespace Fortran::runtime::io
1520
1521 #if defined(_LIBCPP_VERBOSE_ABORT)
1522 // Provide own definition for `std::__libcpp_verbose_abort` to avoid dependency
1523 // on the version provided by libc++.
1524
1525 void std::__libcpp_verbose_abort(char const *format, ...) {
1526   va_list list;
1527   va_start(list, format);
1528   std::vfprintf(stderr, format, list);
1529   va_end(list);
1530
1531   std::abort();
1532 }
1533 #endif