[flang] Implement nonstandard OPEN statement CARRIAGECONTROL specifier

[PeteSteinfeld]

All builds, tests, and looks good.

flang/docs/Extensions.md

 * `NAMELIST` allowed in the execution part
 * Omitted colons on type declaration statements with attributes
 * COMPLEX constructor expression, e.g. `(x+y,z)`
 * `+` and `-` before all primary expressions, e.g. `x*-y`
 * `.NOT. .NOT.` accepted
 * `NAME=` as synonym for `FILE=`
 * Data edit descriptors without width or other details
 * `D` lines in fixed form as comments or debug code
+* `CARRIAGECONTROL=` on the OPEN and INQUIRE statements
 * `CONVERT=` on the OPEN and INQUIRE statements
 * `DISPOSE=` on the OPEN and INQUIRE statements
 * Leading semicolons are ignored before any statement that
   could have a label
 * The character `&` in column 1 in fixed form source is a variant form
   of continuation line.
 * Character literals as elements of an array constructor without an explicit
   type specifier need not have the same length; the longest literal determines

flang/docs/f2018-grammar.txt

R1205 connect-spec ->
         DECIMAL = scalar-default-char-expr | DELIM = scalar-default-char-expr |
         ENCODING = scalar-default-char-expr | ERR = label |
         FILE = file-name-expr | FORM = scalar-default-char-expr |
         IOMSG = iomsg-variable | IOSTAT = scalar-int-variable |
         NEWUNIT = scalar-int-variable | PAD = scalar-default-char-expr |
         POSITION = scalar-default-char-expr | RECL = scalar-int-expr |
         ROUND = scalar-default-char-expr | SIGN = scalar-default-char-expr |
         STATUS = scalar-default-char-expr
-        @ | CONVERT = scalar-default-char-expr
+        @ | CARRIAGECONTROL = scalar-default-char-expr
+          | CONVERT = scalar-default-char-expr
           | DISPOSE = scalar-default-char-expr
 R1206 file-name-expr -> scalar-default-char-expr
 R1207 iomsg-variable -> scalar-default-char-variable
 R1208 close-stmt -> CLOSE ( close-spec-list )
 R1209 close-spec ->
         [UNIT =] file-unit-number | IOSTAT = scalar-int-variable |
         IOMSG = iomsg-variable | ERR = label |
         STATUS = scalar-default-char-expr
R1231 inquire-spec ->
         READ = scalar-default-char-variable |
         READWRITE = scalar-default-char-variable |
         RECL = scalar-int-variable | ROUND = scalar-default-char-variable |
         SEQUENTIAL = scalar-default-char-variable |
         SIGN = scalar-default-char-variable | SIZE = scalar-int-variable |
         STREAM = scalar-default-char-variable |
         STATUS = scalar-default-char-variable |
         WRITE = scalar-default-char-variable
-        @ | CONVERT = scalar-default-char-expr
+        @ | CARRIAGECONTROL = scalar-default-char-expr
+          | CONVERT = scalar-default-char-expr
           | DISPOSE = scalar-default-char-expr
 
 R1301 format-stmt -> FORMAT format-specification
 R1302 format-specification ->
         ( [format-items] ) | ( [format-items ,] unlimited-format-item )
 R1303 format-items -> format-item [[,] format-item]...
 R1304 format-item ->
         [r] data-edit-desc | control-edit-desc | char-string-edit-desc | [r] ( format-items )

flang/include/flang/Common/Fortran-features.h

 
 ENUM_CLASS(LanguageFeature, BackslashEscapes, OldDebugLines,
     FixedFormContinuationWithColumn1Ampersand, LogicalAbbreviations,
     XOROperator, PunctuationInNames, OptionalFreeFormSpace, BOZExtensions,
     EmptyStatement, AlternativeNE, ExecutionPartNamelist, DECStructures,
     DoubleComplex, Byte, StarKind, QuadPrecision, SlashInitialization,
     TripletInArrayConstructor, MissingColons, SignedComplexLiteral,
     OldStyleParameter, ComplexConstructor, PercentLOC, SignedPrimary, FileName,
-    Convert, Dispose, IOListLeadingComma, AbbreviatedEditDescriptor,
-    ProgramParentheses, PercentRefAndVal, OmitFunctionDummies, CrayPointer,
-    Hollerith, ArithmeticIF, Assign, AssignedGOTO, Pause, OpenACC, OpenMP,
-    CruftAfterAmpersand, ClassicCComments, AdditionalFormats, BigIntLiterals,
-    RealDoControls, EquivalenceNumericWithCharacter, AdditionalIntrinsics,
-    AnonymousParents, OldLabelDoEndStatements, LogicalIntegerAssignment,
-    EmptySourceFile, ProgramReturn, ImplicitNoneTypeNever,
-    ImplicitNoneTypeAlways)
+    Carriagecontrol, Convert, Dispose, IOListLeadingComma,
+    AbbreviatedEditDescriptor, ProgramParentheses, PercentRefAndVal,
+    OmitFunctionDummies, CrayPointer, Hollerith, ArithmeticIF, Assign,
+    AssignedGOTO, Pause, OpenACC, OpenMP, CruftAfterAmpersand, ClassicCComments,
+    AdditionalFormats, BigIntLiterals, RealDoControls,
+    EquivalenceNumericWithCharacter, AdditionalIntrinsics, AnonymousParents,
+    OldLabelDoEndStatements, LogicalIntegerAssignment, EmptySourceFile,
+    ProgramReturn, ImplicitNoneTypeNever, ImplicitNoneTypeAlways)
 
 using LanguageFeatures = EnumSet<LanguageFeature, LanguageFeature_enumSize>;
 
 class LanguageFeatureControl {
 public:
   LanguageFeatureControl() {
     // These features must be explicitly enabled by command line options.
     disable_.set(LanguageFeature::OldDebugLines);

flang/include/flang/Common/Fortran.h

ENUM_CLASS(IoStmtKind, None, Backspace, Close, Endfile, Flush, Inquire, Open,
     Print, Read, Rewind, Wait, Write)
 
 // Union of specifiers for all I/O statements.
 ENUM_CLASS(IoSpecKind, Access, Action, Advance, Asynchronous, Blank, Decimal,
     Delim, Direct, Encoding, End, Eor, Err, Exist, File, Fmt, Form, Formatted,
     Id, Iomsg, Iostat, Name, Named, Newunit, Nextrec, Nml, Number, Opened, Pad,
     Pending, Pos, Position, Read, Readwrite, Rec, Recl, Round, Sequential, Sign,
     Size, Status, Stream, Unformatted, Unit, Write,
+    Carriagecontrol, // nonstandard
     Convert, // nonstandard
     Dispose, // nonstandard
 )
 
 // Floating-point rounding modes; these are packed into a byte to save
 // room in the runtime's format processing context structure.
 enum class RoundingMode : std::uint8_t {
   TiesToEven, // ROUND=NEAREST, RN - default IEEE rounding

flang/include/flang/Parser/parse-tree.h

 //         DELIM = scalar-default-char-expr |
 //         ENCODING = scalar-default-char-expr | ERR = label |
 //         FILE = file-name-expr | FORM = scalar-default-char-expr |
 //         IOMSG = iomsg-variable | IOSTAT = scalar-int-variable |
 //         NEWUNIT = scalar-int-variable | PAD = scalar-default-char-expr |
 //         POSITION = scalar-default-char-expr | RECL = scalar-int-expr |
 //         ROUND = scalar-default-char-expr | SIGN = scalar-default-char-expr |
 //         STATUS = scalar-default-char-expr
-//         @ | CONVERT = scalar-default-char-variable
+//         @ | CARRIAGECONTROL = scalar-default-char-variable
+//           | CONVERT = scalar-default-char-variable
 //           | DISPOSE = scalar-default-char-variable
 WRAPPER_CLASS(StatusExpr, ScalarDefaultCharExpr);
 WRAPPER_CLASS(ErrLabel, Label);
 
 struct ConnectSpec {
   UNION_CLASS_BOILERPLATE(ConnectSpec);
   struct CharExpr {
     ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
         Encoding, Form, Pad, Position, Round, Sign,
-        /* extensions: */ Convert, Dispose)
+        /* extensions: */ Carriagecontrol, Convert, Dispose)
     TUPLE_CLASS_BOILERPLATE(CharExpr);
     std::tuple<Kind, ScalarDefaultCharExpr> t;
   };
   WRAPPER_CLASS(Recl, ScalarIntExpr);
   WRAPPER_CLASS(Newunit, ScalarIntVariable);
   std::variant<FileUnitNumber, FileNameExpr, CharExpr, MsgVariable,
       StatVariable, Recl, Newunit, ErrLabel, StatusExpr>
       u;

 //         RECL = scalar-int-variable | ROUND = scalar-default-char-variable |
 //         SEQUENTIAL = scalar-default-char-variable |
 //         SIGN = scalar-default-char-variable |
 //         SIZE = scalar-int-variable |
 //         STREAM = scalar-default-char-variable |
 //         STATUS = scalar-default-char-variable |
 //         UNFORMATTED = scalar-default-char-variable |
 //         WRITE = scalar-default-char-variable
-//         @ | CONVERT = scalar-default-char-variable
+//         @ | CARRIAGECONTROL = scalar-default-char-variable
+//           | CONVERT = scalar-default-char-variable
 //           | DISPOSE = scalar-default-char-variable
 struct InquireSpec {
   UNION_CLASS_BOILERPLATE(InquireSpec);
   struct CharVar {
     ENUM_CLASS(Kind, Access, Action, Asynchronous, Blank, Decimal, Delim,
         Direct, Encoding, Form, Formatted, Iomsg, Name, Pad, Position, Read,
         Readwrite, Round, Sequential, Sign, Stream, Status, Unformatted, Write,
-        /* extensions: */ Convert, Dispose)
+        /* extensions: */ Carriagecontrol, Convert, Dispose)
     TUPLE_CLASS_BOILERPLATE(CharVar);
     std::tuple<Kind, ScalarDefaultCharVariable> t;
   };
   struct IntVar {
     ENUM_CLASS(Kind, Iostat, Nextrec, Number, Pos, Recl, Size)
     TUPLE_CLASS_BOILERPLATE(IntVar);
     std::tuple<Kind, ScalarIntVariable> t;
   };

flang/lib/Lower/IO.cpp

static constexpr std::tuple<
     mkIOKey(SetRec), mkIOKey(SetRound), mkIOKey(SetSign),
     mkIOKey(OutputDescriptor), mkIOKey(InputDescriptor),
     mkIOKey(OutputUnformattedBlock), mkIOKey(InputUnformattedBlock),
     mkIOKey(OutputInteger64), mkIOKey(InputInteger), mkIOKey(OutputReal32),
     mkIOKey(InputReal32), mkIOKey(OutputReal64), mkIOKey(InputReal64),
     mkIOKey(OutputComplex64), mkIOKey(OutputComplex32), mkIOKey(OutputAscii),
     mkIOKey(InputAscii), mkIOKey(OutputLogical), mkIOKey(InputLogical),
     mkIOKey(SetAccess), mkIOKey(SetAction), mkIOKey(SetAsynchronous),
-    mkIOKey(SetEncoding), mkIOKey(SetForm), mkIOKey(SetPosition),
-    mkIOKey(SetRecl), mkIOKey(SetStatus), mkIOKey(SetFile), mkIOKey(GetNewUnit),
-    mkIOKey(GetSize), mkIOKey(GetIoLength), mkIOKey(GetIoMsg),
-    mkIOKey(InquireCharacter), mkIOKey(InquireLogical),
-    mkIOKey(InquirePendingId), mkIOKey(InquireInteger64),
-    mkIOKey(EndIoStatement)>
+    mkIOKey(SetCarriagecontrol), mkIOKey(SetEncoding), mkIOKey(SetForm),
+    mkIOKey(SetPosition), mkIOKey(SetRecl), mkIOKey(SetStatus),
+    mkIOKey(SetFile), mkIOKey(GetNewUnit), mkIOKey(GetSize),
+    mkIOKey(GetIoLength), mkIOKey(GetIoMsg), mkIOKey(InquireCharacter),
+    mkIOKey(InquireLogical), mkIOKey(InquirePendingId),
+    mkIOKey(InquireInteger64), mkIOKey(EndIoStatement)>
     newIOTable;
 } // namespace Fortran::lower
 
 namespace {
 struct ConditionSpecifierInfo {
   const Fortran::semantics::SomeExpr *ioStatExpr{};
   const Fortran::semantics::SomeExpr *ioMsgExpr{};
   bool hasErr{};
case Fortran::parser::ConnectSpec::CharExpr::Kind::Position:
     ioFunc = getIORuntimeFunc<mkIOKey(SetPosition)>(loc, builder);
     break;
   case Fortran::parser::ConnectSpec::CharExpr::Kind::Round:
     ioFunc = getIORuntimeFunc<mkIOKey(SetRound)>(loc, builder);
     break;
   case Fortran::parser::ConnectSpec::CharExpr::Kind::Sign:
     ioFunc = getIORuntimeFunc<mkIOKey(SetSign)>(loc, builder);
     break;
+  case Fortran::parser::ConnectSpec::CharExpr::Kind::Carriagecontrol:
+    ioFunc = getIORuntimeFunc<mkIOKey(SetCarriagecontrol)>(loc, builder);
+    break;
   case Fortran::parser::ConnectSpec::CharExpr::Kind::Convert:
     llvm_unreachable("CONVERT not part of the runtime::io interface");
   case Fortran::parser::ConnectSpec::CharExpr::Kind::Dispose:
     llvm_unreachable("DISPOSE not part of the runtime::io interface");
   }
   mlir::FunctionType ioFuncTy = ioFunc.getType();
   auto tup = lowerStringLit(
       converter, loc, std::get<Fortran::parser::ScalarDefaultCharExpr>(spec.t),

flang/lib/Parser/io-parsers.cpp

 //         DELIM = scalar-default-char-expr |
 //         ENCODING = scalar-default-char-expr | ERR = label |
 //         FILE = file-name-expr | FORM = scalar-default-char-expr |
 //         IOMSG = iomsg-variable | IOSTAT = scalar-int-variable |
 //         NEWUNIT = scalar-int-variable | PAD = scalar-default-char-expr |
 //         POSITION = scalar-default-char-expr | RECL = scalar-int-expr |
 //         ROUND = scalar-default-char-expr | SIGN = scalar-default-char-expr |
 //         STATUS = scalar-default-char-expr
-//         @ | CONVERT = scalar-default-char-variable
-//         @ | DISPOSE = scalar-default-char-variable
+//         @ | CARRIAGECONTROL = scalar-default-char-variable
+//           | CONVERT = scalar-default-char-variable
+//           | DISPOSE = scalar-default-char-variable
 constexpr auto statusExpr{construct<StatusExpr>(scalarDefaultCharExpr)};
 constexpr auto errLabel{construct<ErrLabel>(label)};
 
 TYPE_PARSER(first(construct<ConnectSpec>(maybe("UNIT ="_tok) >> fileUnitNumber),
     construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
         "ACCESS =" >> pure(ConnectSpec::CharExpr::Kind::Access),
         scalarDefaultCharExpr)),
     construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
construct<ConnectSpec>(
         construct<ConnectSpec::Recl>("RECL =" >> scalarIntExpr)),
     construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
         "ROUND =" >> pure(ConnectSpec::CharExpr::Kind::Round),
         scalarDefaultCharExpr)),
     construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
         "SIGN =" >> pure(ConnectSpec::CharExpr::Kind::Sign),
         scalarDefaultCharExpr)),
     construct<ConnectSpec>("STATUS =" >> statusExpr),
+    extension<LanguageFeature::Carriagecontrol>(construct<ConnectSpec>(
+        construct<ConnectSpec::CharExpr>("CARRIAGECONTROL =" >>
+                pure(ConnectSpec::CharExpr::Kind::Carriagecontrol),
+            scalarDefaultCharExpr))),
     extension<LanguageFeature::Convert>(
         construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
             "CONVERT =" >> pure(ConnectSpec::CharExpr::Kind::Convert),
             scalarDefaultCharExpr))),
     extension<LanguageFeature::Dispose>(
         construct<ConnectSpec>(construct<ConnectSpec::CharExpr>(
             "DISPOSE =" >> pure(ConnectSpec::CharExpr::Kind::Dispose),
             scalarDefaultCharExpr)))))

 //         READWRITE = scalar-default-char-variable |
 //         RECL = scalar-int-variable | ROUND = scalar-default-char-variable |
 //         SEQUENTIAL = scalar-default-char-variable |
 //         SIGN = scalar-default-char-variable |
 //         SIZE = scalar-int-variable |
 //         STREAM = scalar-default-char-variable |
 //         STATUS = scalar-default-char-variable |
 //         WRITE = scalar-default-char-variable
-//         @ | CONVERT = scalar-default-char-variable
+//         @ | CARRIAGECONTROL = scalar-default-char-variable
+//           | CONVERT = scalar-default-char-variable
 //           | DISPOSE = scalar-default-char-variable
 TYPE_PARSER(first(construct<InquireSpec>(maybe("UNIT ="_tok) >> fileUnitNumber),
     construct<InquireSpec>("FILE =" >> fileNameExpr),
     construct<InquireSpec>(
         "ACCESS =" >> construct<InquireSpec::CharVar>(
                           pure(InquireSpec::CharVar::Kind::Access),
                           scalarDefaultCharVariable)),
     construct<InquireSpec>(
construct<InquireSpec>(
                           scalarDefaultCharVariable)),
     construct<InquireSpec>(
         "UNFORMATTED =" >> construct<InquireSpec::CharVar>(
                                pure(InquireSpec::CharVar::Kind::Unformatted),
                                scalarDefaultCharVariable)),
     construct<InquireSpec>("WRITE =" >>
         construct<InquireSpec::CharVar>(pure(InquireSpec::CharVar::Kind::Write),
             scalarDefaultCharVariable)),
+    extension<LanguageFeature::Carriagecontrol>(
+        construct<InquireSpec>("CARRIAGECONTROL =" >>
+            construct<InquireSpec::CharVar>(
+                pure(InquireSpec::CharVar::Kind::Carriagecontrol),
+                scalarDefaultCharVariable))),
     extension<LanguageFeature::Convert>(construct<InquireSpec>(
         "CONVERT =" >> construct<InquireSpec::CharVar>(
                            pure(InquireSpec::CharVar::Kind::Convert),
                            scalarDefaultCharVariable))),
     extension<LanguageFeature::Dispose>(construct<InquireSpec>(
         "DISPOSE =" >> construct<InquireSpec::CharVar>(
                            pure(InquireSpec::CharVar::Kind::Dispose),
                            scalarDefaultCharVariable)))))

flang/lib/Semantics/check-io.cpp

case ParseKind::Position:
     specKind = IoSpecKind::Position;
     break;
   case ParseKind::Round:
     specKind = IoSpecKind::Round;
     break;
   case ParseKind::Sign:
     specKind = IoSpecKind::Sign;
     break;
+  case ParseKind::Carriagecontrol:
+    specKind = IoSpecKind::Carriagecontrol;
+    break;
   case ParseKind::Convert:
     specKind = IoSpecKind::Convert;
     break;
   case ParseKind::Dispose:
     specKind = IoSpecKind::Dispose;
     break;
   }
   SetSpecifier(specKind);
   if (const std::optional<std::string> charConst{GetConstExpr<std::string>(
           std::get<parser::ScalarDefaultCharExpr>(spec.t))}) {
     std::string s{parser::ToUpperCaseLetters(*charConst)};
     if (specKind == IoSpecKind::Access) {
       flags_.set(Flag::KnownAccess);
       flags_.set(Flag::AccessDirect, s == "DIRECT");
       flags_.set(Flag::AccessStream, s == "STREAM");
     }
     CheckStringValue(specKind, *charConst, parser::FindSourceLocation(spec));
+    if (specKind == IoSpecKind::Carriagecontrol &&
+        (s == "FORTRAN" || s == "NONE")) {
+      context_.Say(parser::FindSourceLocation(spec),
+          "Unimplemented %s value '%s'"_err_en_US,
+          parser::ToUpperCaseLetters(common::EnumToString(specKind)),
+          *charConst);
+    }
   }
 }
 
 void IoChecker::Enter(const parser::ConnectSpec::Newunit &var) {
   CheckForDefinableVariable(var, "NEWUNIT");
   SetSpecifier(IoSpecKind::Newunit);
 }
 
case ParseKind::Stream:
     specKind = IoSpecKind::Stream;
     break;
   case ParseKind::Unformatted:
     specKind = IoSpecKind::Unformatted;
     break;
   case ParseKind::Write:
     specKind = IoSpecKind::Write;
     break;
+  case ParseKind::Carriagecontrol:
+    specKind = IoSpecKind::Carriagecontrol;
+    break;
   case ParseKind::Convert:
     specKind = IoSpecKind::Convert;
     break;
   case ParseKind::Dispose:
     specKind = IoSpecKind::Dispose;
     break;
   }
   CheckForDefinableVariable(std::get<parser::ScalarDefaultCharVariable>(spec.t),
static std::unordered_map<IoSpecKind, const std::set<std::string>> specValues{
       {IoSpecKind::Pad, {"NO", "YES"}},
       {IoSpecKind::Position, {"APPEND", "ASIS", "REWIND"}},
       {IoSpecKind::Round,
           {"COMPATIBLE", "DOWN", "NEAREST", "PROCESSOR_DEFINED", "UP", "ZERO"}},
       {IoSpecKind::Sign, {"PLUS", "PROCESSOR_DEFINED", "SUPPRESS"}},
       {IoSpecKind::Status,
           // Open values; Close values are {"DELETE", "KEEP"}.
           {"NEW", "OLD", "REPLACE", "SCRATCH", "UNKNOWN"}},
+      {IoSpecKind::Carriagecontrol, {"LIST", "FORTRAN", "NONE"}},
       {IoSpecKind::Convert, {"BIG_ENDIAN", "LITTLE_ENDIAN", "NATIVE"}},
       {IoSpecKind::Dispose, {"DELETE", "KEEP"}},
   };
   if (!specValues.at(specKind).count(parser::ToUpperCaseLetters(value))) {
     context_.Say(source, "Invalid %s value '%s'"_err_en_US,
         parser::ToUpperCaseLetters(common::EnumToString(specKind)), value);
   }
 }

flang/runtime/io-api.h

 // SetDelim(), GetIoMsg(), SetPad(), SetRound(), & SetSign()
 // are also acceptable for OPEN.
 // ACCESS=SEQUENTIAL, DIRECT, STREAM
 bool IONAME(SetAccess)(Cookie, const char *, std::size_t);
 // ACTION=READ, WRITE, or READWRITE
 bool IONAME(SetAction)(Cookie, const char *, std::size_t);
 // ASYNCHRONOUS=YES, NO
 bool IONAME(SetAsynchronous)(Cookie, const char *, std::size_t);
+// CARRIAGECONTROL=LIST, FORTRAN, NONE
+bool IONAME(SetCarriagecontrol)(Cookie, const char *, std::size_t);
 // CONVERT=NATIVE, LITTLE_ENDIAN, BIG_ENDIAN, or SWAP
 bool IONAME(SetConvert)(Cookie, const char *, std::size_t);
 // ENCODING=UTF-8, DEFAULT
 bool IONAME(SetEncoding)(Cookie, const char *, std::size_t);
 // FORM=FORMATTED, UNFORMATTED
 bool IONAME(SetForm)(Cookie, const char *, std::size_t);
 // POSITION=ASIS, REWIND, APPEND
 bool IONAME(SetPosition)(Cookie, const char *, std::size_t);

flang/runtime/io-api.cpp

case 1:
     return true;
   default:
     open->SignalError(IostatErrorInKeyword, "Invalid ASYNCHRONOUS='%.*s'",
         static_cast<int>(length), keyword);
     return false;
   }
 }
 
+bool IONAME(SetCarriagecontrol)(
+    Cookie cookie, const char *keyword, std::size_t length) {
+  IoStatementState &io{*cookie};
+  auto *open{io.get_if<OpenStatementState>()};
+  if (!open) {
+    io.GetIoErrorHandler().Crash(
+        "SetCarriageControl() called when not in an OPEN statement");
+  }
+  static const char *keywords[]{"LIST", "FORTRAN", "NONE", nullptr};
+  switch (IdentifyValue(keyword, length, keywords)) {
+  case 0:
+    return true;
+  case 1:
+  case 2:
+    open->SignalError(IostatErrorInKeyword,
+        "Unimplemented CARRIAGECONTROL='%.*s'", static_cast<int>(length),
+        keyword);
+    return false;
+  default:
+    open->SignalError(IostatErrorInKeyword, "Invalid CARRIAGECONTROL='%.*s'",
+        static_cast<int>(length), keyword);
+    return false;
+  }
+}
+
 bool IONAME(SetConvert)(
     Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
         "SetConvert() called when not in an OPEN statement");
   }
bool IONAME(SetEncoding)(
   return true;
 }
 
 bool IONAME(SetForm)(Cookie cookie, const char *keyword, std::size_t length) {
   IoStatementState &io{*cookie};
   auto *open{io.get_if<OpenStatementState>()};
   if (!open) {
     io.GetIoErrorHandler().Crash(
-        "SetEncoding() called when not in an OPEN statement");
+        "SetForm() called when not in an OPEN statement");
   }
   static const char *keywords[]{"FORMATTED", "UNFORMATTED", nullptr};
   switch (IdentifyValue(keyword, length, keywords)) {
   case 0:
     open->set_isUnformatted(false);
     break;
   case 1:
     open->set_isUnformatted(true);

flang/runtime/io-stmt.cpp

bool InquireUnitState::Inquire(
   case HashInquiryKeyword("ASYNCHRONOUS"):
     str = unit().mayAsynchronous() ? "YES" : "NO";
     break;
   case HashInquiryKeyword("BLANK"):
     str = unit().isUnformatted                  ? "UNDEFINED"
         : unit().modes.editingFlags & blankZero ? "ZERO"
                                                 : "NULL";
     break;
+  case HashInquiryKeyword("CARRIAGECONTROL"):
+    str = "LIST";
+    break;
   case HashInquiryKeyword("CONVERT"):
     str = unit().swapEndianness() ? "SWAP" : "NATIVE";
     break;
   case HashInquiryKeyword("DECIMAL"):
     str = unit().isUnformatted                     ? "UNDEFINED"
         : unit().modes.editingFlags & decimalComma ? "COMMA"
                                                    : "POINT";
     break;

 
 bool InquireNoUnitState::Inquire(
     InquiryKeywordHash inquiry, char *result, std::size_t length) {
   switch (inquiry) {
   case HashInquiryKeyword("ACCESS"):
   case HashInquiryKeyword("ACTION"):
   case HashInquiryKeyword("ASYNCHRONOUS"):
   case HashInquiryKeyword("BLANK"):
+  case HashInquiryKeyword("CARRIAGECONTROL"):
   case HashInquiryKeyword("CONVERT"):
   case HashInquiryKeyword("DECIMAL"):
   case HashInquiryKeyword("DELIM"):
   case HashInquiryKeyword("FORM"):
   case HashInquiryKeyword("NAME"):
   case HashInquiryKeyword("PAD"):
   case HashInquiryKeyword("POSITION"):
   case HashInquiryKeyword("ROUND"):

 bool InquireUnconnectedFileState::Inquire(
     InquiryKeywordHash inquiry, char *result, std::size_t length) {
   const char *str{nullptr};
   switch (inquiry) {
   case HashInquiryKeyword("ACCESS"):
   case HashInquiryKeyword("ACTION"):
   case HashInquiryKeyword("ASYNCHRONOUS"):
   case HashInquiryKeyword("BLANK"):
+  case HashInquiryKeyword("CARRIAGECONTROL"):
   case HashInquiryKeyword("CONVERT"):
   case HashInquiryKeyword("DECIMAL"):
   case HashInquiryKeyword("DELIM"):
   case HashInquiryKeyword("FORM"):
   case HashInquiryKeyword("PAD"):
   case HashInquiryKeyword("POSITION"):
   case HashInquiryKeyword("ROUND"):
   case HashInquiryKeyword("SIGN"):

flang/test/Semantics/io01.f90

3 continue
   open(unit=70, sign='suppress', &
       status='unknown', iostat=stat2)
   open(unit=70, sign=sign_(2), status=status_(2))
 
   open(80, convert='big_endian', dispose='delete')
   open(81, convert=convert_(2), dispose=dispose_(2))
 
   open(access='STREAM', 90) ! nonstandard
+  open (unit=91, file='xfile', carriagecontrol='list') ! nonstandard
 
   !ERROR: OPEN statement must have a UNIT or NEWUNIT specifier
   !ERROR: If ACCESS='DIRECT' appears, RECL must also appear
   open(access='direct')
 
   !ERROR: If STATUS='STREAM' appears, RECL must not appear
   open(10, access='st'//'ream', recl=13)
 
3 continue
   !ERROR: If STATUS='REPLACE' appears, FILE must also appear
   open(114, status='replace')
 
   !ERROR: If STATUS='SCRATCH' appears, FILE must not appear
   open(115, file='abc', status='scratch')
 
   !ERROR: If NEWUNIT appears, FILE or STATUS='SCRATCH' must also appear
   open(newunit=nn, status='old')
+
+  !ERROR: Unimplemented CARRIAGECONTROL value 'fortran'
+  open (unit=116, file='xfile', carriagecontrol='fortran') ! nonstandard
+
+  !ERROR: Invalid CARRIAGECONTROL value 'nonsense'
+  open (unit=116, file='xfile', carriagecontrol='nonsense') ! nonstandard
 end

flang/test/Semantics/io05.f90

inquire(file='abc', &
       err=9, &
       nextrec=nextrec, number=number, pos=jpos, recl=jrecl, size=jsize, &
       iomsg=msg, &
       iostat=stat4, &
       exist=v(1), named=v(2), opened=v(3), pending=v(4))
   inquire(pending=v(5), file='abc')
   inquire(10, id=id, pending=v(5))
   inquire(10, id=const_id, pending=v(5))
+  inquire(10, carriagecontrol=c(1)) ! nonstandard
 
   ! using variable 'cv' multiple times seems to be allowed
   inquire(file='abc', &
       access=cv, action=cv, asynchronous=cv, blank=cv, decimal=cv, &
       delim=cv, direct=cv, encoding=cv, form=cv, formatted=cv, &
       name=cv, pad=cv, position=cv, read=cv, readwrite=cv, &
       round=cv, sequential=cv, sign=cv, stream=cv, &
       unformatted=cv, write=cv, &