flang/runtime/pseudo-unit.cpp

   1 //===-- runtime/pseudo-unit.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 // Implemenation of ExternalFileUnit and PseudoOpenFile for
  10 // RT_USE_PSEUDO_FILE_UNIT=1.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "io-error.h"
  15 #include "tools.h"
  16 #include "unit.h"
  17
  18 // NOTE: the header files above may define OpenMP declare target
  19 // variables, so they have to be included unconditionally
  20 // so that the offload entries are consistent between host and device.
  21 #if defined(RT_USE_PSEUDO_FILE_UNIT)
  22 #include <cstdio>
  23
  24 namespace Fortran::runtime::io {
  25
  26 void FlushOutputOnCrash(const Terminator &) {}
  27
  28 ExternalFileUnit *ExternalFileUnit::LookUp(int) {
  29   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  30 }
  31
  32 ExternalFileUnit *ExternalFileUnit::LookUpOrCreate(
  33     int, const Terminator &, bool &) {
  34   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  35 }
  36
  37 ExternalFileUnit *ExternalFileUnit::LookUpOrCreateAnonymous(int unit,
  38     Direction direction, Fortran::common::optional<bool>,
  39     IoErrorHandler &handler) {
  40   if (direction != Direction::Output) {
  41     handler.Crash("ExternalFileUnit only supports output IO");
  42   }
  43   return New<ExternalFileUnit>{handler}(unit).release();
  44 }
  45
  46 ExternalFileUnit *ExternalFileUnit::LookUp(const char *, std::size_t) {
  47   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  48 }
  49
  50 ExternalFileUnit &ExternalFileUnit::CreateNew(int, const Terminator &) {
  51   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  52 }
  53
  54 ExternalFileUnit *ExternalFileUnit::LookUpForClose(int) {
  55   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  56 }
  57
  58 ExternalFileUnit &ExternalFileUnit::NewUnit(const Terminator &, bool) {
  59   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  60 }
  61
  62 bool ExternalFileUnit::OpenUnit(Fortran::common::optional<OpenStatus> status,
  63     Fortran::common::optional<Action>, Position, OwningPtr<char> &&,
  64     std::size_t, Convert, IoErrorHandler &handler) {
  65   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  66 }
  67
  68 bool ExternalFileUnit::OpenAnonymousUnit(Fortran::common::optional<OpenStatus>,
  69     Fortran::common::optional<Action>, Position, Convert convert,
  70     IoErrorHandler &handler) {
  71   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  72 }
  73
  74 void ExternalFileUnit::CloseUnit(CloseStatus, IoErrorHandler &handler) {
  75   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  76 }
  77
  78 void ExternalFileUnit::DestroyClosed() {
  79   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  80 }
  81
  82 Iostat ExternalFileUnit::SetDirection(Direction direction) {
  83   if (direction != Direction::Output) {
  84     return IostatReadFromWriteOnly;
  85   }
  86   direction_ = direction;
  87   return IostatOk;
  88 }
  89
  90 void ExternalFileUnit::CloseAll(IoErrorHandler &) {}
  91
  92 void ExternalFileUnit::FlushAll(IoErrorHandler &) {}
  93
  94 int ExternalFileUnit::GetAsynchronousId(IoErrorHandler &handler) {
  95   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
  96 }
  97
  98 bool ExternalFileUnit::Wait(int) {
  99   Terminator{__FILE__, __LINE__}.Crash("unsupported");
 100 }
 101
 102 void PseudoOpenFile::set_mayAsynchronous(bool yes) {
 103   if (yes) {
 104     Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 105   }
 106 }
 107
 108 Fortran::common::optional<PseudoOpenFile::FileOffset>
 109 PseudoOpenFile::knownSize() const {
 110   Terminator{__FILE__, __LINE__}.Crash("unsupported");
 111 }
 112
 113 void PseudoOpenFile::Open(OpenStatus, Fortran::common::optional<Action>,
 114     Position, IoErrorHandler &handler) {
 115   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 116 }
 117
 118 void PseudoOpenFile::Close(CloseStatus, IoErrorHandler &handler) {
 119   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 120 }
 121
 122 std::size_t PseudoOpenFile::Read(
 123     FileOffset, char *, std::size_t, std::size_t, IoErrorHandler &handler) {
 124   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 125 }
 126
 127 std::size_t PseudoOpenFile::Write(FileOffset at, const char *buffer,
 128     std::size_t bytes, IoErrorHandler &handler) {
 129   if (at) {
 130     handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 131   }
 132   // TODO: use persistent string buffer that can be reallocated
 133   // as needed, and only freed at destruction of *this.
 134   auto string{SizedNew<char>{handler}(bytes + 1)};
 135   std::memcpy(string.get(), buffer, bytes);
 136   string.get()[bytes] = '\0';
 137   std::printf("%s", string.get());
 138   return bytes;
 139 }
 140
 141 void PseudoOpenFile::Truncate(FileOffset, IoErrorHandler &handler) {
 142   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 143 }
 144
 145 int PseudoOpenFile::ReadAsynchronously(
 146     FileOffset, char *, std::size_t, IoErrorHandler &handler) {
 147   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 148 }
 149
 150 int PseudoOpenFile::WriteAsynchronously(
 151     FileOffset, const char *, std::size_t, IoErrorHandler &handler) {
 152   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 153 }
 154
 155 void PseudoOpenFile::Wait(int, IoErrorHandler &handler) {
 156   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 157 }
 158
 159 void PseudoOpenFile::WaitAll(IoErrorHandler &handler) {
 160   handler.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 161 }
 162
 163 Position PseudoOpenFile::InquirePosition() const {
 164   Terminator{__FILE__, __LINE__}.Crash("%s: unsupported", RT_PRETTY_FUNCTION);
 165 }
 166
 167 } // namespace Fortran::runtime::io
 168
 169 #endif // defined(RT_USE_PSEUDO_FILE_UNIT)