gcc/fortran/io.c

   1 /* Deal with I/O statements & related stuff.
   2    Copyright (C) 2000, 2001, 2002, 2003, 2004, 2005, 2006 Free Software
   3    Foundation, Inc.
   4    Contributed by Andy Vaught
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 2, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to the Free
  20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
  21 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "flags.h"
  26 #include "gfortran.h"
  27 #include "match.h"
  28 #include "parse.h"
  29
  30 gfc_st_label format_asterisk =
  31   {0, NULL, NULL, -1, ST_LABEL_FORMAT, ST_LABEL_FORMAT, NULL,
  32    0, {NULL, NULL}};
  33
  34 typedef struct
  35 {
  36   const char *name, *spec;
  37   bt type;
  38 }
  39 io_tag;
  40
  41 static const io_tag
  42         tag_file        = { "FILE", " file = %e", BT_CHARACTER },
  43         tag_status      = { "STATUS", " status = %e", BT_CHARACTER},
  44         tag_e_access    = {"ACCESS", " access = %e", BT_CHARACTER},
  45         tag_e_form      = {"FORM", " form = %e", BT_CHARACTER},
  46         tag_e_recl      = {"RECL", " recl = %e", BT_INTEGER},
  47         tag_e_blank     = {"BLANK", " blank = %e", BT_CHARACTER},
  48         tag_e_position  = {"POSITION", " position = %e", BT_CHARACTER},
  49         tag_e_action    = {"ACTION", " action = %e", BT_CHARACTER},
  50         tag_e_delim     = {"DELIM", " delim = %e", BT_CHARACTER},
  51         tag_e_pad       = {"PAD", " pad = %e", BT_CHARACTER},
  52         tag_unit        = {"UNIT", " unit = %e", BT_INTEGER},
  53         tag_advance     = {"ADVANCE", " advance = %e", BT_CHARACTER},
  54         tag_rec         = {"REC", " rec = %e", BT_INTEGER},
  55         tag_spos        = {"POSITION", " pos = %e", BT_INTEGER},
  56         tag_format      = {"FORMAT", NULL, BT_CHARACTER},
  57         tag_iomsg       = {"IOMSG", " iomsg = %e", BT_CHARACTER},
  58         tag_iostat      = {"IOSTAT", " iostat = %v", BT_INTEGER},
  59         tag_size        = {"SIZE", " size = %v", BT_INTEGER},
  60         tag_exist       = {"EXIST", " exist = %v", BT_LOGICAL},
  61         tag_opened      = {"OPENED", " opened = %v", BT_LOGICAL},
  62         tag_named       = {"NAMED", " named = %v", BT_LOGICAL},
  63         tag_name        = {"NAME", " name = %v", BT_CHARACTER},
  64         tag_number      = {"NUMBER", " number = %v", BT_INTEGER},
  65         tag_s_access    = {"ACCESS", " access = %v", BT_CHARACTER},
  66         tag_sequential  = {"SEQUENTIAL", " sequential = %v", BT_CHARACTER},
  67         tag_direct      = {"DIRECT", " direct = %v", BT_CHARACTER},
  68         tag_s_form      = {"FORM", " form = %v", BT_CHARACTER},
  69         tag_formatted   = {"FORMATTED", " formatted = %v", BT_CHARACTER},
  70         tag_unformatted = {"UNFORMATTED", " unformatted = %v", BT_CHARACTER},
  71         tag_s_recl      = {"RECL", " recl = %v", BT_INTEGER},
  72         tag_nextrec     = {"NEXTREC", " nextrec = %v", BT_INTEGER},
  73         tag_s_blank     = {"BLANK", " blank = %v", BT_CHARACTER},
  74         tag_s_position  = {"POSITION", " position = %v", BT_CHARACTER},
  75         tag_s_action    = {"ACTION", " action = %v", BT_CHARACTER},
  76         tag_read        = {"READ", " read = %v", BT_CHARACTER},
  77         tag_write       = {"WRITE", " write = %v", BT_CHARACTER},
  78         tag_readwrite   = {"READWRITE", " readwrite = %v", BT_CHARACTER},
  79         tag_s_delim     = {"DELIM", " delim = %v", BT_CHARACTER},
  80         tag_s_pad       = {"PAD", " pad = %v", BT_CHARACTER},
  81         tag_iolength    = {"IOLENGTH", " iolength = %v", BT_INTEGER},
  82         tag_convert     = {"CONVERT", " convert = %e", BT_CHARACTER},
  83         tag_strm_out    = {"POS", " pos = %v", BT_INTEGER},
  84         tag_err         = {"ERR", " err = %l", BT_UNKNOWN},
  85         tag_end         = {"END", " end = %l", BT_UNKNOWN},
  86         tag_eor         = {"EOR", " eor = %l", BT_UNKNOWN};
  87
  88 static gfc_dt *current_dt;
  89
  90 #define RESOLVE_TAG(x, y) if (resolve_tag(x, y) == FAILURE) return FAILURE;
  91
  92
  93 /**************** Fortran 95 FORMAT parser  *****************/
  94
  95 /* FORMAT tokens returned by format_lex().  */
  96 typedef enum
  97 {
  98   FMT_NONE, FMT_UNKNOWN, FMT_SIGNED_INT, FMT_ZERO, FMT_POSINT, FMT_PERIOD,
  99   FMT_COMMA, FMT_COLON, FMT_SLASH, FMT_DOLLAR, FMT_POS, FMT_LPAREN,
 100   FMT_RPAREN, FMT_X, FMT_SIGN, FMT_BLANK, FMT_CHAR, FMT_P, FMT_IBOZ, FMT_F,
 101   FMT_E, FMT_EXT, FMT_G, FMT_L, FMT_A, FMT_D, FMT_H, FMT_END
 102 }
 103 format_token;
 104
 105 /* Local variables for checking format strings.  The saved_token is
 106    used to back up by a single format token during the parsing
 107    process.  */
 108 static char *format_string;
 109 static int format_length, use_last_char;
 110
 111 static format_token saved_token;
 112
 113 static enum
 114 { MODE_STRING, MODE_FORMAT, MODE_COPY }
 115 mode;
 116
 117
 118 /* Return the next character in the format string.  */
 119
 120 static char
 121 next_char (int in_string)
 122 {
 123   static char c;
 124
 125   if (use_last_char)
 126     {
 127       use_last_char = 0;
 128       return c;
 129     }
 130
 131   format_length++;
 132
 133   if (mode == MODE_STRING)
 134     c = *format_string++;
 135   else
 136     {
 137       c = gfc_next_char_literal (in_string);
 138       if (c == '\n')
 139         c = '\0';
 140
 141       if (mode == MODE_COPY)
 142         *format_string++ = c;
 143     }
 144
 145   c = TOUPPER (c);
 146   return c;
 147 }
 148
 149
 150 /* Back up one character position.  Only works once.  */
 151
 152 static void
 153 unget_char (void)
 154 {
 155
 156   use_last_char = 1;
 157 }
 158
 159 /* Eat up the spaces and return a character. */
 160
 161 static char
 162 next_char_not_space(void)
 163 {
 164   char c;
 165   do
 166     {
 167       c = next_char (0);
 168     }
 169   while (gfc_is_whitespace (c));
 170   return c;
 171 }
 172
 173 static int value = 0;
 174
 175 /* Simple lexical analyzer for getting the next token in a FORMAT
 176    statement.  */
 177
 178 static format_token
 179 format_lex (void)
 180 {
 181   format_token token;
 182   char c, delim;
 183   int zflag;
 184   int negative_flag;
 185
 186   if (saved_token != FMT_NONE)
 187     {
 188       token = saved_token;
 189       saved_token = FMT_NONE;
 190       return token;
 191     }
 192
 193   c = next_char_not_space ();
 194
 195   negative_flag = 0;
 196   switch (c)
 197     {
 198     case '-':
 199       negative_flag = 1;
 200     case '+':
 201       c = next_char_not_space ();
 202       if (!ISDIGIT (c))
 203         {
 204           token = FMT_UNKNOWN;
 205           break;
 206         }
 207
 208       value = c - '0';
 209
 210       do
 211         {
 212           c = next_char_not_space ();
 213           if(ISDIGIT (c))
 214             value = 10 * value + c - '0';
 215         }
 216       while (ISDIGIT (c));
 217
 218       unget_char ();
 219
 220       if (negative_flag)
 221         value = -value;
 222
 223       token = FMT_SIGNED_INT;
 224       break;
 225
 226     case '0':
 227     case '1':
 228     case '2':
 229     case '3':
 230     case '4':
 231     case '5':
 232     case '6':
 233     case '7':
 234     case '8':
 235     case '9':
 236       zflag = (c == '0');
 237
 238       value = c - '0';
 239
 240       do
 241         {
 242           c = next_char_not_space ();
 243           if (c != '0')
 244             zflag = 0;
 245           if (ISDIGIT (c))
 246             value = 10 * value + c - '0';
 247         }
 248       while (ISDIGIT (c));
 249
 250       unget_char ();
 251       token = zflag ? FMT_ZERO : FMT_POSINT;
 252       break;
 253
 254     case '.':
 255       token = FMT_PERIOD;
 256       break;
 257
 258     case ',':
 259       token = FMT_COMMA;
 260       break;
 261
 262     case ':':
 263       token = FMT_COLON;
 264       break;
 265
 266     case '/':
 267       token = FMT_SLASH;
 268       break;
 269
 270     case '$':
 271       token = FMT_DOLLAR;
 272       break;
 273
 274     case 'T':
 275       c = next_char_not_space ();
 276       if (c != 'L' && c != 'R')
 277         unget_char ();
 278
 279       token = FMT_POS;
 280       break;
 281
 282     case '(':
 283       token = FMT_LPAREN;
 284       break;
 285
 286     case ')':
 287       token = FMT_RPAREN;
 288       break;
 289
 290     case 'X':
 291       token = FMT_X;
 292       break;
 293
 294     case 'S':
 295       c = next_char_not_space ();
 296       if (c != 'P' && c != 'S')
 297         unget_char ();
 298
 299       token = FMT_SIGN;
 300       break;
 301
 302     case 'B':
 303       c = next_char_not_space ();
 304       if (c == 'N' || c == 'Z')
 305         token = FMT_BLANK;
 306       else
 307         {
 308           unget_char ();
 309           token = FMT_IBOZ;
 310         }
 311
 312       break;
 313
 314     case '\'':
 315     case '"':
 316       delim = c;
 317
 318       value = 0;
 319
 320       for (;;)
 321         {
 322           c = next_char (1);
 323           if (c == '\0')
 324             {
 325               token = FMT_END;
 326               break;
 327             }
 328
 329           if (c == delim)
 330             {
 331               c = next_char (1);
 332
 333               if (c == '\0')
 334                 {
 335                   token = FMT_END;
 336                   break;
 337                 }
 338
 339               if (c != delim)
 340                 {
 341                   unget_char ();
 342                   token = FMT_CHAR;
 343                   break;
 344                 }
 345             }
 346           value++;
 347         }
 348       break;
 349
 350     case 'P':
 351       token = FMT_P;
 352       break;
 353
 354     case 'I':
 355     case 'O':
 356     case 'Z':
 357       token = FMT_IBOZ;
 358       break;
 359
 360     case 'F':
 361       token = FMT_F;
 362       break;
 363
 364     case 'E':
 365       c = next_char_not_space ();
 366       if (c == 'N' || c == 'S')
 367         token = FMT_EXT;
 368       else
 369         {
 370           token = FMT_E;
 371           unget_char ();
 372         }
 373
 374       break;
 375
 376     case 'G':
 377       token = FMT_G;
 378       break;
 379
 380     case 'H':
 381       token = FMT_H;
 382       break;
 383
 384     case 'L':
 385       token = FMT_L;
 386       break;
 387
 388     case 'A':
 389       token = FMT_A;
 390       break;
 391
 392     case 'D':
 393       token = FMT_D;
 394       break;
 395
 396     case '\0':
 397       token = FMT_END;
 398       break;
 399
 400     default:
 401       token = FMT_UNKNOWN;
 402       break;
 403     }
 404
 405   return token;
 406 }
 407
 408
 409 /* Check a format statement.  The format string, either from a FORMAT
 410    statement or a constant in an I/O statement has already been parsed
 411    by itself, and we are checking it for validity.  The dual origin
 412    means that the warning message is a little less than great.  */
 413
 414 static try
 415 check_format (void)
 416 {
 417   const char *posint_required     = _("Positive width required");
 418   const char *nonneg_required     = _("Nonnegative width required");
 419   const char *unexpected_element  = _("Unexpected element");
 420   const char *unexpected_end      = _("Unexpected end of format string");
 421
 422   const char *error;
 423   format_token t, u;
 424   int level;
 425   int repeat;
 426   try rv;
 427
 428   use_last_char = 0;
 429   saved_token = FMT_NONE;
 430   level = 0;
 431   repeat = 0;
 432   rv = SUCCESS;
 433
 434   t = format_lex ();
 435   if (t != FMT_LPAREN)
 436     {
 437       error = _("Missing leading left parenthesis");
 438       goto syntax;
 439     }
 440
 441   t = format_lex ();
 442   if (t == FMT_RPAREN)
 443     goto finished;              /* Empty format is legal */
 444   saved_token = t;
 445
 446 format_item:
 447   /* In this state, the next thing has to be a format item.  */
 448   t = format_lex ();
 449 format_item_1:
 450   switch (t)
 451     {
 452     case FMT_POSINT:
 453       repeat = value;
 454       t = format_lex ();
 455       if (t == FMT_LPAREN)
 456         {
 457           level++;
 458           goto format_item;
 459         }
 460
 461       if (t == FMT_SLASH)
 462         goto optional_comma;
 463
 464       goto data_desc;
 465
 466     case FMT_LPAREN:
 467       level++;
 468       goto format_item;
 469
 470     case FMT_SIGNED_INT:
 471       /* Signed integer can only precede a P format.  */
 472       t = format_lex ();
 473       if (t != FMT_P)
 474         {
 475           error = _("Expected P edit descriptor");
 476           goto syntax;
 477         }
 478
 479       goto data_desc;
 480
 481     case FMT_P:
 482       /* P requires a prior number.  */
 483       error = _("P descriptor requires leading scale factor");
 484       goto syntax;
 485
 486     case FMT_X:
 487       /* X requires a prior number if we're being pedantic.  */
 488       if (gfc_notify_std (GFC_STD_GNU, "Extension: X descriptor "
 489                           "requires leading space count at %C")
 490           == FAILURE)
 491         return FAILURE;
 492       goto between_desc;
 493
 494     case FMT_SIGN:
 495     case FMT_BLANK:
 496       goto between_desc;
 497
 498     case FMT_CHAR:
 499       goto extension_optional_comma;
 500
 501     case FMT_COLON:
 502     case FMT_SLASH:
 503       goto optional_comma;
 504
 505     case FMT_DOLLAR:
 506       t = format_lex ();
 507
 508       if (gfc_notify_std (GFC_STD_GNU, "Extension: $ descriptor at %C")
 509           == FAILURE)
 510         return FAILURE;
 511       if (t != FMT_RPAREN || level > 0)
 512         {
 513           error = _("$ must be the last specifier");
 514           goto syntax;
 515         }
 516
 517       goto finished;
 518
 519     case FMT_POS:
 520     case FMT_IBOZ:
 521     case FMT_F:
 522     case FMT_E:
 523     case FMT_EXT:
 524     case FMT_G:
 525     case FMT_L:
 526     case FMT_A:
 527     case FMT_D:
 528       goto data_desc;
 529
 530     case FMT_H:
 531       goto data_desc;
 532
 533     case FMT_END:
 534       error = unexpected_end;
 535       goto syntax;
 536
 537     default:
 538       error = unexpected_element;
 539       goto syntax;
 540     }
 541
 542 data_desc:
 543   /* In this state, t must currently be a data descriptor.
 544      Deal with things that can/must follow the descriptor.  */
 545   switch (t)
 546     {
 547     case FMT_SIGN:
 548     case FMT_BLANK:
 549     case FMT_X:
 550       break;
 551
 552     case FMT_P:
 553       if (pedantic)
 554         {
 555           t = format_lex ();
 556           if (t == FMT_POSINT)
 557             {
 558               error = _("Repeat count cannot follow P descriptor");
 559               goto syntax;
 560             }
 561
 562           saved_token = t;
 563         }
 564
 565       goto optional_comma;
 566
 567     case FMT_POS:
 568     case FMT_L:
 569       t = format_lex ();
 570       if (t == FMT_POSINT)
 571         break;
 572
 573       switch (gfc_notification_std (GFC_STD_GNU))
 574         {
 575           case WARNING:
 576             gfc_warning
 577               ("Extension: Missing positive width after L descriptor at %C");
 578             saved_token = t;
 579             break;
 580
 581           case ERROR:
 582             error = posint_required;
 583             goto syntax;
 584
 585           case SILENT:
 586             saved_token = t;
 587             break;
 588
 589           default:
 590             gcc_unreachable ();
 591         }
 592       break;
 593
 594     case FMT_A:
 595       t = format_lex ();
 596       if (t != FMT_POSINT)
 597         saved_token = t;
 598       break;
 599
 600     case FMT_D:
 601     case FMT_E:
 602     case FMT_G:
 603     case FMT_EXT:
 604       u = format_lex ();
 605       if (u != FMT_POSINT)
 606         {
 607           error = posint_required;
 608           goto syntax;
 609         }
 610
 611       u = format_lex ();
 612       if (u != FMT_PERIOD)
 613         {
 614           /* Warn if -std=legacy, otherwise error.  */
 615           if (gfc_option.warn_std != 0)
 616             gfc_error_now ("Period required in format specifier at %C");
 617           else
 618             gfc_warning ("Period required in format specifier at %C");
 619           saved_token = u;
 620           break;
 621         }
 622
 623       u = format_lex ();
 624       if (u != FMT_ZERO && u != FMT_POSINT)
 625         {
 626           error = nonneg_required;
 627           goto syntax;
 628         }
 629
 630       if (t == FMT_D)
 631         break;
 632
 633       /* Look for optional exponent.  */
 634       u = format_lex ();
 635       if (u != FMT_E)
 636         {
 637           saved_token = u;
 638         }
 639       else
 640         {
 641           u = format_lex ();
 642           if (u != FMT_POSINT)
 643             {
 644               error = _("Positive exponent width required");
 645               goto syntax;
 646             }
 647         }
 648
 649       break;
 650
 651     case FMT_F:
 652       t = format_lex ();
 653       if (t != FMT_ZERO && t != FMT_POSINT)
 654         {
 655           error = nonneg_required;
 656           goto syntax;
 657         }
 658
 659       t = format_lex ();
 660       if (t != FMT_PERIOD)
 661         {
 662           /* Warn if -std=legacy, otherwise error.  */
 663           if (gfc_option.warn_std != 0)
 664             gfc_error_now ("Period required in format specifier at %C");
 665           else
 666             gfc_warning ("Period required in format specifier at %C");
 667           saved_token = t;
 668           break;
 669         }
 670
 671       t = format_lex ();
 672       if (t != FMT_ZERO && t != FMT_POSINT)
 673         {
 674           error = nonneg_required;
 675           goto syntax;
 676         }
 677
 678       break;
 679
 680     case FMT_H:
 681       if(mode == MODE_STRING)
 682       {
 683         format_string += value;
 684         format_length -= value;
 685       }
 686       else
 687       {
 688         while(repeat >0)
 689          {
 690           next_char(1);
 691           repeat -- ;
 692          }
 693       }
 694      break;
 695
 696     case FMT_IBOZ:
 697       t = format_lex ();
 698       if (t != FMT_ZERO && t != FMT_POSINT)
 699         {
 700           error = nonneg_required;
 701           goto syntax;
 702         }
 703
 704       t = format_lex ();
 705       if (t != FMT_PERIOD)
 706         {
 707           saved_token = t;
 708         }
 709       else
 710         {
 711           t = format_lex ();
 712           if (t != FMT_ZERO && t != FMT_POSINT)
 713             {
 714               error = nonneg_required;
 715               goto syntax;
 716             }
 717         }
 718
 719       break;
 720
 721     default:
 722       error = unexpected_element;
 723       goto syntax;
 724     }
 725
 726 between_desc:
 727   /* Between a descriptor and what comes next.  */
 728   t = format_lex ();
 729   switch (t)
 730     {
 731
 732     case FMT_COMMA:
 733       goto format_item;
 734
 735     case FMT_RPAREN:
 736       level--;
 737       if (level < 0)
 738         goto finished;
 739       goto between_desc;
 740
 741     case FMT_COLON:
 742     case FMT_SLASH:
 743       goto optional_comma;
 744
 745     case FMT_END:
 746       error = unexpected_end;
 747       goto syntax;
 748
 749     default:
 750       if (gfc_notify_std (GFC_STD_GNU, "Extension: Missing comma at %C")
 751           == FAILURE)
 752         return FAILURE;
 753       goto format_item_1;
 754     }
 755
 756 optional_comma:
 757   /* Optional comma is a weird between state where we've just finished
 758      reading a colon, slash or P descriptor.  */
 759   t = format_lex ();
 760   switch (t)
 761     {
 762     case FMT_COMMA:
 763       break;
 764
 765     case FMT_RPAREN:
 766       level--;
 767       if (level < 0)
 768         goto finished;
 769       goto between_desc;
 770
 771     default:
 772       /* Assume that we have another format item.  */
 773       saved_token = t;
 774       break;
 775     }
 776
 777   goto format_item;
 778
 779 extension_optional_comma:
 780   /* As a GNU extension, permit a missing comma after a string literal.  */
 781   t = format_lex ();
 782   switch (t)
 783     {
 784     case FMT_COMMA:
 785       break;
 786
 787     case FMT_RPAREN:
 788       level--;
 789       if (level < 0)
 790         goto finished;
 791       goto between_desc;
 792
 793     case FMT_COLON:
 794     case FMT_SLASH:
 795       goto optional_comma;
 796
 797     case FMT_END:
 798       error = unexpected_end;
 799       goto syntax;
 800
 801     default:
 802       if (gfc_notify_std (GFC_STD_GNU, "Extension: Missing comma at %C")
 803           == FAILURE)
 804         return FAILURE;
 805       saved_token = t;
 806       break;
 807     }
 808
 809   goto format_item;
 810
 811 syntax:
 812   /* Something went wrong.  If the format we're checking is a string,
 813      generate a warning, since the program is correct.  If the format
 814      is in a FORMAT statement, this messes up parsing, which is an
 815      error.  */
 816   if (mode != MODE_STRING)
 817     gfc_error ("%s in format string at %C", error);
 818   else
 819     {
 820       gfc_warning ("%s in format string at %C", error);
 821
 822       /* TODO: More elaborate measures are needed to show where a problem
 823          is within a format string that has been calculated.  */
 824     }
 825
 826   rv = FAILURE;
 827
 828 finished:
 829   return rv;
 830 }
 831
 832
 833 /* Given an expression node that is a constant string, see if it looks
 834    like a format string.  */
 835
 836 static void
 837 check_format_string (gfc_expr * e)
 838 {
 839
 840   mode = MODE_STRING;
 841   format_string = e->value.character.string;
 842   check_format ();
 843 }
 844
 845
 846 /************ Fortran 95 I/O statement matchers *************/
 847
 848 /* Match a FORMAT statement.  This amounts to actually parsing the
 849    format descriptors in order to correctly locate the end of the
 850    format string.  */
 851
 852 match
 853 gfc_match_format (void)
 854 {
 855   gfc_expr *e;
 856   locus start;
 857
 858   if (gfc_current_ns->proc_name
 859         && gfc_current_ns->proc_name->attr.flavor == FL_MODULE)
 860     {
 861       gfc_error ("Format statement in module main block at %C.");
 862       return MATCH_ERROR;
 863     }
 864
 865   if (gfc_statement_label == NULL)
 866     {
 867       gfc_error ("Missing format label at %C");
 868       return MATCH_ERROR;
 869     }
 870   gfc_gobble_whitespace ();
 871
 872   mode = MODE_FORMAT;
 873   format_length = 0;
 874
 875   start = gfc_current_locus;
 876
 877   if (check_format () == FAILURE)
 878     return MATCH_ERROR;
 879
 880   if (gfc_match_eos () != MATCH_YES)
 881     {
 882       gfc_syntax_error (ST_FORMAT);
 883       return MATCH_ERROR;
 884     }
 885
 886   /* The label doesn't get created until after the statement is done
 887      being matched, so we have to leave the string for later.  */
 888
 889   gfc_current_locus = start;    /* Back to the beginning */
 890
 891   new_st.loc = start;
 892   new_st.op = EXEC_NOP;
 893
 894   e = gfc_get_expr();
 895   e->expr_type = EXPR_CONSTANT;
 896   e->ts.type = BT_CHARACTER;
 897   e->ts.kind = gfc_default_character_kind;
 898   e->where = start;
 899   e->value.character.string = format_string = gfc_getmem(format_length+1);
 900   e->value.character.length = format_length;
 901   gfc_statement_label->format = e;
 902
 903   mode = MODE_COPY;
 904   check_format ();              /* Guaranteed to succeed */
 905   gfc_match_eos ();             /* Guaranteed to succeed */
 906
 907   return MATCH_YES;
 908 }
 909
 910
 911 /* Match an expression I/O tag of some sort.  */
 912
 913 static match
 914 match_etag (const io_tag * tag, gfc_expr ** v)
 915 {
 916   gfc_expr *result;
 917   match m;
 918
 919   m = gfc_match (tag->spec, &result);
 920   if (m != MATCH_YES)
 921     return m;
 922
 923   if (*v != NULL)
 924     {
 925       gfc_error ("Duplicate %s specification at %C", tag->name);
 926       gfc_free_expr (result);
 927       return MATCH_ERROR;
 928     }
 929
 930   *v = result;
 931   return MATCH_YES;
 932 }
 933
 934
 935 /* Match a variable I/O tag of some sort.  */
 936
 937 static match
 938 match_vtag (const io_tag * tag, gfc_expr ** v)
 939 {
 940   gfc_expr *result;
 941   match m;
 942
 943   m = gfc_match (tag->spec, &result);
 944   if (m != MATCH_YES)
 945     return m;
 946
 947   if (*v != NULL)
 948     {
 949       gfc_error ("Duplicate %s specification at %C", tag->name);
 950       gfc_free_expr (result);
 951       return MATCH_ERROR;
 952     }
 953
 954   if (result->symtree->n.sym->attr.intent == INTENT_IN)
 955     {
 956       gfc_error ("Variable tag cannot be INTENT(IN) at %C");
 957       gfc_free_expr (result);
 958       return MATCH_ERROR;
 959     }
 960
 961   if (gfc_pure (NULL) && gfc_impure_variable (result->symtree->n.sym))
 962     {
 963       gfc_error ("Variable tag cannot be assigned in PURE procedure at %C");
 964       gfc_free_expr (result);
 965       return MATCH_ERROR;
 966     }
 967
 968   *v = result;
 969   return MATCH_YES;
 970 }
 971
 972
 973 /* Match I/O tags that cause variables to become redefined.  */
 974
 975 static match
 976 match_out_tag(const io_tag *tag, gfc_expr **result)
 977 {
 978   match m;
 979
 980   m = match_vtag(tag, result);
 981   if (m == MATCH_YES)
 982     gfc_check_do_variable((*result)->symtree);
 983
 984   return m;
 985 }
 986
 987
 988 /* Match a label I/O tag.  */
 989
 990 static match
 991 match_ltag (const io_tag * tag, gfc_st_label ** label)
 992 {
 993   match m;
 994   gfc_st_label *old;
 995
 996   old = *label;
 997   m = gfc_match (tag->spec, label);
 998   if (m == MATCH_YES && old != 0)
 999     {
1000       gfc_error ("Duplicate %s label specification at %C", tag->name);
1001       return MATCH_ERROR;
1002     }
1003
1004   if (m == MATCH_YES
1005       && gfc_reference_st_label (*label, ST_LABEL_TARGET) == FAILURE)
1006     return MATCH_ERROR;
1007
1008   return m;
1009 }
1010
1011
1012 /* Do expression resolution and type-checking on an expression tag.  */
1013
1014 static try
1015 resolve_tag (const io_tag * tag, gfc_expr * e)
1016 {
1017
1018   if (e == NULL)
1019     return SUCCESS;
1020
1021   if (gfc_resolve_expr (e) == FAILURE)
1022     return FAILURE;
1023
1024   if (e->ts.type != tag->type && tag != &tag_format)
1025     {
1026       gfc_error ("%s tag at %L must be of type %s", tag->name,
1027                 &e->where, gfc_basic_typename (tag->type));
1028       return FAILURE;
1029     }
1030
1031   if (tag == &tag_format)
1032     {
1033       if (e->expr_type == EXPR_CONSTANT
1034           && (e->ts.type != BT_CHARACTER
1035               || e->ts.kind != gfc_default_character_kind))
1036         {
1037           gfc_error ("Constant expression in FORMAT tag at %L must be "
1038                      "of type default CHARACTER", &e->where);
1039           return FAILURE;
1040         }
1041
1042       /* If e's rank is zero and e is not an element of an array, it should be
1043          of integer or character type.  The integer variable should be
1044          ASSIGNED.  */
1045       if (e->symtree == NULL || e->symtree->n.sym->as == NULL
1046                 || e->symtree->n.sym->as->rank == 0)
1047         {
1048           if (e->ts.type != BT_CHARACTER && e->ts.type != BT_INTEGER)
1049             {
1050               gfc_error ("%s tag at %L must be of type %s or %s", tag->name,
1051                         &e->where, gfc_basic_typename (BT_CHARACTER),
1052                         gfc_basic_typename (BT_INTEGER));
1053               return FAILURE;
1054             }
1055           else if (e->ts.type == BT_INTEGER && e->expr_type == EXPR_VARIABLE)
1056             {
1057               if (gfc_notify_std (GFC_STD_F95_DEL,
1058                         "Obsolete: ASSIGNED variable in FORMAT tag at %L",
1059                         &e->where) == FAILURE)
1060                 return FAILURE;
1061               if (e->symtree->n.sym->attr.assign != 1)
1062                 {
1063                   gfc_error ("Variable '%s' at %L has not been assigned a "
1064                         "format label", e->symtree->n.sym->name, &e->where);
1065                   return FAILURE;
1066                 }
1067             }
1068           else if (e->ts.type == BT_INTEGER)
1069             {
1070               gfc_error ("scalar '%s' FORMAT tag at %L is not an ASSIGNED "
1071                          "variable", gfc_basic_typename (e->ts.type), &e->where);
1072               return FAILURE;
1073             }
1074
1075           return SUCCESS;
1076         }
1077       else
1078         {
1079           /* if rank is nonzero, we allow the type to be character under
1080              GFC_STD_GNU and other type under GFC_STD_LEGACY. It may be
1081              assigned an Hollerith constant.  */
1082           if (e->ts.type == BT_CHARACTER)
1083             {
1084               if (gfc_notify_std (GFC_STD_GNU,
1085                         "Extension: Character array in FORMAT tag at %L",
1086                         &e->where) == FAILURE)
1087                 return FAILURE;
1088             }
1089           else
1090             {
1091               if (gfc_notify_std (GFC_STD_LEGACY,
1092                         "Extension: Non-character in FORMAT tag at %L",
1093                         &e->where) == FAILURE)
1094                 return FAILURE;
1095             }
1096           return SUCCESS;
1097         }
1098     }
1099   else
1100     {
1101       if (e->rank != 0)
1102         {
1103           gfc_error ("%s tag at %L must be scalar", tag->name, &e->where);
1104           return FAILURE;
1105         }
1106
1107       if (tag == &tag_iomsg)
1108         {
1109           if (gfc_notify_std (GFC_STD_F2003, "Fortran 2003: IOMSG tag at %L",
1110                               &e->where) == FAILURE)
1111             return FAILURE;
1112         }
1113
1114       if (tag == &tag_iostat && e->ts.kind != gfc_default_integer_kind)
1115         {
1116           if (gfc_notify_std (GFC_STD_GNU, "Fortran 95 requires default "
1117                               "INTEGER in IOSTAT tag at %L",
1118                               &e->where) == FAILURE)
1119             return FAILURE;
1120         }
1121
1122       if (tag == &tag_size && e->ts.kind != gfc_default_integer_kind)
1123         {
1124           if (gfc_notify_std (GFC_STD_GNU, "Fortran 95 requires default "
1125                               "INTEGER in SIZE tag at %L",
1126                               &e->where) == FAILURE)
1127             return FAILURE;
1128         }
1129
1130       if (tag == &tag_convert)
1131         {
1132           if (gfc_notify_std (GFC_STD_GNU, "Extension: CONVERT tag at %L",
1133                               &e->where) == FAILURE)
1134             return FAILURE;
1135         }
1136     }
1137
1138   return SUCCESS;
1139 }
1140
1141
1142 /* Match a single tag of an OPEN statement.  */
1143
1144 static match
1145 match_open_element (gfc_open * open)
1146 {
1147   match m;
1148
1149   m = match_etag (&tag_unit, &open->unit);
1150   if (m != MATCH_NO)
1151     return m;
1152   m = match_out_tag (&tag_iomsg, &open->iomsg);
1153   if (m != MATCH_NO)
1154     return m;
1155   m = match_out_tag (&tag_iostat, &open->iostat);
1156   if (m != MATCH_NO)
1157     return m;
1158   m = match_etag (&tag_file, &open->file);
1159   if (m != MATCH_NO)
1160     return m;
1161   m = match_etag (&tag_status, &open->status);
1162   if (m != MATCH_NO)
1163     return m;
1164   m = match_etag (&tag_e_access, &open->access);
1165   if (m != MATCH_NO)
1166     return m;
1167   m = match_etag (&tag_e_form, &open->form);
1168   if (m != MATCH_NO)
1169     return m;
1170   m = match_etag (&tag_e_recl, &open->recl);
1171   if (m != MATCH_NO)
1172     return m;
1173   m = match_etag (&tag_e_blank, &open->blank);
1174   if (m != MATCH_NO)
1175     return m;
1176   m = match_etag (&tag_e_position, &open->position);
1177   if (m != MATCH_NO)
1178     return m;
1179   m = match_etag (&tag_e_action, &open->action);
1180   if (m != MATCH_NO)
1181     return m;
1182   m = match_etag (&tag_e_delim, &open->delim);
1183   if (m != MATCH_NO)
1184     return m;
1185   m = match_etag (&tag_e_pad, &open->pad);
1186   if (m != MATCH_NO)
1187     return m;
1188   m = match_ltag (&tag_err, &open->err);
1189   if (m != MATCH_NO)
1190     return m;
1191   m = match_etag (&tag_convert, &open->convert);
1192   if (m != MATCH_NO)
1193     return m;
1194
1195   return MATCH_NO;
1196 }
1197
1198
1199 /* Free the gfc_open structure and all the expressions it contains.  */
1200
1201 void
1202 gfc_free_open (gfc_open * open)
1203 {
1204
1205   if (open == NULL)
1206     return;
1207
1208   gfc_free_expr (open->unit);
1209   gfc_free_expr (open->iomsg);
1210   gfc_free_expr (open->iostat);
1211   gfc_free_expr (open->file);
1212   gfc_free_expr (open->status);
1213   gfc_free_expr (open->access);
1214   gfc_free_expr (open->form);
1215   gfc_free_expr (open->recl);
1216   gfc_free_expr (open->blank);
1217   gfc_free_expr (open->position);
1218   gfc_free_expr (open->action);
1219   gfc_free_expr (open->delim);
1220   gfc_free_expr (open->pad);
1221   gfc_free_expr (open->convert);
1222
1223   gfc_free (open);
1224 }
1225
1226
1227 /* Resolve everything in a gfc_open structure.  */
1228
1229 try
1230 gfc_resolve_open (gfc_open * open)
1231 {
1232
1233   RESOLVE_TAG (&tag_unit, open->unit);
1234   RESOLVE_TAG (&tag_iomsg, open->iomsg);
1235   RESOLVE_TAG (&tag_iostat, open->iostat);
1236   RESOLVE_TAG (&tag_file, open->file);
1237   RESOLVE_TAG (&tag_status, open->status);
1238   RESOLVE_TAG (&tag_e_access, open->access);
1239   RESOLVE_TAG (&tag_e_form, open->form);
1240   RESOLVE_TAG (&tag_e_recl, open->recl);
1241
1242   RESOLVE_TAG (&tag_e_blank, open->blank);
1243   RESOLVE_TAG (&tag_e_position, open->position);
1244   RESOLVE_TAG (&tag_e_action, open->action);
1245   RESOLVE_TAG (&tag_e_delim, open->delim);
1246   RESOLVE_TAG (&tag_e_pad, open->pad);
1247   RESOLVE_TAG (&tag_convert, open->convert);
1248
1249   if (gfc_reference_st_label (open->err, ST_LABEL_TARGET) == FAILURE)
1250     return FAILURE;
1251
1252   return SUCCESS;
1253 }
1254
1255
1256 /* Match an OPEN statement.  */
1257
1258 match
1259 gfc_match_open (void)
1260 {
1261   gfc_open *open;
1262   match m;
1263
1264   m = gfc_match_char ('(');
1265   if (m == MATCH_NO)
1266     return m;
1267
1268   open = gfc_getmem (sizeof (gfc_open));
1269
1270   m = match_open_element (open);
1271
1272   if (m == MATCH_ERROR)
1273     goto cleanup;
1274   if (m == MATCH_NO)
1275     {
1276       m = gfc_match_expr (&open->unit);
1277       if (m == MATCH_NO)
1278         goto syntax;
1279       if (m == MATCH_ERROR)
1280         goto cleanup;
1281     }
1282
1283   for (;;)
1284     {
1285       if (gfc_match_char (')') == MATCH_YES)
1286         break;
1287       if (gfc_match_char (',') != MATCH_YES)
1288         goto syntax;
1289
1290       m = match_open_element (open);
1291       if (m == MATCH_ERROR)
1292         goto cleanup;
1293       if (m == MATCH_NO)
1294         goto syntax;
1295     }
1296
1297   if (gfc_match_eos () == MATCH_NO)
1298     goto syntax;
1299
1300   if (gfc_pure (NULL))
1301     {
1302       gfc_error ("OPEN statement not allowed in PURE procedure at %C");
1303       goto cleanup;
1304     }
1305
1306   new_st.op = EXEC_OPEN;
1307   new_st.ext.open = open;
1308   return MATCH_YES;
1309
1310 syntax:
1311   gfc_syntax_error (ST_OPEN);
1312
1313 cleanup:
1314   gfc_free_open (open);
1315   return MATCH_ERROR;
1316 }
1317
1318
1319 /* Free a gfc_close structure an all its expressions.  */
1320
1321 void
1322 gfc_free_close (gfc_close * close)
1323 {
1324
1325   if (close == NULL)
1326     return;
1327
1328   gfc_free_expr (close->unit);
1329   gfc_free_expr (close->iomsg);
1330   gfc_free_expr (close->iostat);
1331   gfc_free_expr (close->status);
1332
1333   gfc_free (close);
1334 }
1335
1336
1337 /* Match elements of a CLOSE statement.  */
1338
1339 static match
1340 match_close_element (gfc_close * close)
1341 {
1342   match m;
1343
1344   m = match_etag (&tag_unit, &close->unit);
1345   if (m != MATCH_NO)
1346     return m;
1347   m = match_etag (&tag_status, &close->status);
1348   if (m != MATCH_NO)
1349     return m;
1350   m = match_out_tag (&tag_iomsg, &close->iomsg);
1351   if (m != MATCH_NO)
1352     return m;
1353   m = match_out_tag (&tag_iostat, &close->iostat);
1354   if (m != MATCH_NO)
1355     return m;
1356   m = match_ltag (&tag_err, &close->err);
1357   if (m != MATCH_NO)
1358     return m;
1359
1360   return MATCH_NO;
1361 }
1362
1363
1364 /* Match a CLOSE statement.  */
1365
1366 match
1367 gfc_match_close (void)
1368 {
1369   gfc_close *close;
1370   match m;
1371
1372   m = gfc_match_char ('(');
1373   if (m == MATCH_NO)
1374     return m;
1375
1376   close = gfc_getmem (sizeof (gfc_close));
1377
1378   m = match_close_element (close);
1379
1380   if (m == MATCH_ERROR)
1381     goto cleanup;
1382   if (m == MATCH_NO)
1383     {
1384       m = gfc_match_expr (&close->unit);
1385       if (m == MATCH_NO)
1386         goto syntax;
1387       if (m == MATCH_ERROR)
1388         goto cleanup;
1389     }
1390
1391   for (;;)
1392     {
1393       if (gfc_match_char (')') == MATCH_YES)
1394         break;
1395       if (gfc_match_char (',') != MATCH_YES)
1396         goto syntax;
1397
1398       m = match_close_element (close);
1399       if (m == MATCH_ERROR)
1400         goto cleanup;
1401       if (m == MATCH_NO)
1402         goto syntax;
1403     }
1404
1405   if (gfc_match_eos () == MATCH_NO)
1406     goto syntax;
1407
1408   if (gfc_pure (NULL))
1409     {
1410       gfc_error ("CLOSE statement not allowed in PURE procedure at %C");
1411       goto cleanup;
1412     }
1413
1414   new_st.op = EXEC_CLOSE;
1415   new_st.ext.close = close;
1416   return MATCH_YES;
1417
1418 syntax:
1419   gfc_syntax_error (ST_CLOSE);
1420
1421 cleanup:
1422   gfc_free_close (close);
1423   return MATCH_ERROR;
1424 }
1425
1426
1427 /* Resolve everything in a gfc_close structure.  */
1428
1429 try
1430 gfc_resolve_close (gfc_close * close)
1431 {
1432
1433   RESOLVE_TAG (&tag_unit, close->unit);
1434   RESOLVE_TAG (&tag_iomsg, close->iomsg);
1435   RESOLVE_TAG (&tag_iostat, close->iostat);
1436   RESOLVE_TAG (&tag_status, close->status);
1437
1438   if (gfc_reference_st_label (close->err, ST_LABEL_TARGET) == FAILURE)
1439     return FAILURE;
1440
1441   return SUCCESS;
1442 }
1443
1444
1445 /* Free a gfc_filepos structure.  */
1446
1447 void
1448 gfc_free_filepos (gfc_filepos * fp)
1449 {
1450
1451   gfc_free_expr (fp->unit);
1452   gfc_free_expr (fp->iomsg);
1453   gfc_free_expr (fp->iostat);
1454   gfc_free (fp);
1455 }
1456
1457
1458 /* Match elements of a REWIND, BACKSPACE, ENDFILE, or FLUSH statement.  */
1459
1460 static match
1461 match_file_element (gfc_filepos * fp)
1462 {
1463   match m;
1464
1465   m = match_etag (&tag_unit, &fp->unit);
1466   if (m != MATCH_NO)
1467     return m;
1468   m = match_out_tag (&tag_iomsg, &fp->iomsg);
1469   if (m != MATCH_NO)
1470     return m;
1471   m = match_out_tag (&tag_iostat, &fp->iostat);
1472   if (m != MATCH_NO)
1473     return m;
1474   m = match_ltag (&tag_err, &fp->err);
1475   if (m != MATCH_NO)
1476     return m;
1477
1478   return MATCH_NO;
1479 }
1480
1481
1482 /* Match the second half of the file-positioning statements, REWIND,
1483    BACKSPACE, ENDFILE, or the FLUSH statement.  */
1484
1485 static match
1486 match_filepos (gfc_statement st, gfc_exec_op op)
1487 {
1488   gfc_filepos *fp;
1489   match m;
1490
1491   fp = gfc_getmem (sizeof (gfc_filepos));
1492
1493   if (gfc_match_char ('(') == MATCH_NO)
1494     {
1495       m = gfc_match_expr (&fp->unit);
1496       if (m == MATCH_ERROR)
1497         goto cleanup;
1498       if (m == MATCH_NO)
1499         goto syntax;
1500
1501       goto done;
1502     }
1503
1504   m = match_file_element (fp);
1505   if (m == MATCH_ERROR)
1506     goto done;
1507   if (m == MATCH_NO)
1508     {
1509       m = gfc_match_expr (&fp->unit);
1510       if (m == MATCH_ERROR)
1511         goto done;
1512       if (m == MATCH_NO)
1513         goto syntax;
1514     }
1515
1516   for (;;)
1517     {
1518       if (gfc_match_char (')') == MATCH_YES)
1519         break;
1520       if (gfc_match_char (',') != MATCH_YES)
1521         goto syntax;
1522
1523       m = match_file_element (fp);
1524       if (m == MATCH_ERROR)
1525         goto cleanup;
1526       if (m == MATCH_NO)
1527         goto syntax;
1528     }
1529
1530 done:
1531   if (gfc_match_eos () != MATCH_YES)
1532     goto syntax;
1533
1534   if (gfc_pure (NULL))
1535     {
1536       gfc_error ("%s statement not allowed in PURE procedure at %C",
1537                  gfc_ascii_statement (st));
1538
1539       goto cleanup;
1540     }
1541
1542   new_st.op = op;
1543   new_st.ext.filepos = fp;
1544   return MATCH_YES;
1545
1546 syntax:
1547   gfc_syntax_error (st);
1548
1549 cleanup:
1550   gfc_free_filepos (fp);
1551   return MATCH_ERROR;
1552 }
1553
1554
1555 try
1556 gfc_resolve_filepos (gfc_filepos * fp)
1557 {
1558
1559   RESOLVE_TAG (&tag_unit, fp->unit);
1560   RESOLVE_TAG (&tag_iostat, fp->iostat);
1561   RESOLVE_TAG (&tag_iomsg, fp->iomsg);
1562   if (gfc_reference_st_label (fp->err, ST_LABEL_TARGET) == FAILURE)
1563     return FAILURE;
1564
1565   return SUCCESS;
1566 }
1567
1568
1569 /* Match the file positioning statements: ENDFILE, BACKSPACE, REWIND,
1570    and the FLUSH statement.  */
1571
1572 match
1573 gfc_match_endfile (void)
1574 {
1575
1576   return match_filepos (ST_END_FILE, EXEC_ENDFILE);
1577 }
1578
1579 match
1580 gfc_match_backspace (void)
1581 {
1582
1583   return match_filepos (ST_BACKSPACE, EXEC_BACKSPACE);
1584 }
1585
1586 match
1587 gfc_match_rewind (void)
1588 {
1589
1590   return match_filepos (ST_REWIND, EXEC_REWIND);
1591 }
1592
1593 match
1594 gfc_match_flush (void)
1595 {
1596   if (gfc_notify_std (GFC_STD_F2003, "Fortran 2003: FLUSH statement at %C") == FAILURE)
1597     return MATCH_ERROR;
1598
1599   return match_filepos (ST_FLUSH, EXEC_FLUSH);
1600 }
1601
1602 /******************** Data Transfer Statements *********************/
1603
1604 typedef enum
1605 { M_READ, M_WRITE, M_PRINT, M_INQUIRE }
1606 io_kind;
1607
1608
1609 /* Return a default unit number.  */
1610
1611 static gfc_expr *
1612 default_unit (io_kind k)
1613 {
1614   int unit;
1615
1616   if (k == M_READ)
1617     unit = 5;
1618   else
1619     unit = 6;
1620
1621   return gfc_int_expr (unit);
1622 }
1623
1624
1625 /* Match a unit specification for a data transfer statement.  */
1626
1627 static match
1628 match_dt_unit (io_kind k, gfc_dt * dt)
1629 {
1630   gfc_expr *e;
1631
1632   if (gfc_match_char ('*') == MATCH_YES)
1633     {
1634       if (dt->io_unit != NULL)
1635         goto conflict;
1636
1637       dt->io_unit = default_unit (k);
1638       return MATCH_YES;
1639     }
1640
1641   if (gfc_match_expr (&e) == MATCH_YES)
1642     {
1643       if (dt->io_unit != NULL)
1644         {
1645           gfc_free_expr (e);
1646           goto conflict;
1647         }
1648
1649       dt->io_unit = e;
1650       return MATCH_YES;
1651     }
1652
1653   return MATCH_NO;
1654
1655 conflict:
1656   gfc_error ("Duplicate UNIT specification at %C");
1657   return MATCH_ERROR;
1658 }
1659
1660
1661 /* Match a format specification.  */
1662
1663 static match
1664 match_dt_format (gfc_dt * dt)
1665 {
1666   locus where;
1667   gfc_expr *e;
1668   gfc_st_label *label;
1669
1670   where = gfc_current_locus;
1671
1672   if (gfc_match_char ('*') == MATCH_YES)
1673     {
1674       if (dt->format_expr != NULL || dt->format_label != NULL)
1675         goto conflict;
1676
1677       dt->format_label = &format_asterisk;
1678       return MATCH_YES;
1679     }
1680
1681   if (gfc_match_st_label (&label) == MATCH_YES)
1682     {
1683       if (dt->format_expr != NULL || dt->format_label != NULL)
1684         {
1685           gfc_free_st_label (label);
1686           goto conflict;
1687         }
1688
1689       if (gfc_reference_st_label (label, ST_LABEL_FORMAT) == FAILURE)
1690         return MATCH_ERROR;
1691
1692       dt->format_label = label;
1693       return MATCH_YES;
1694     }
1695
1696   if (gfc_match_expr (&e) == MATCH_YES)
1697     {
1698       if (dt->format_expr != NULL || dt->format_label != NULL)
1699         {
1700           gfc_free_expr (e);
1701           goto conflict;
1702         }
1703       dt->format_expr = e;
1704       return MATCH_YES;
1705     }
1706
1707   gfc_current_locus = where;    /* The only case where we have to restore */
1708
1709   return MATCH_NO;
1710
1711 conflict:
1712   gfc_error ("Duplicate format specification at %C");
1713   return MATCH_ERROR;
1714 }
1715
1716
1717 /* Traverse a namelist that is part of a READ statement to make sure
1718    that none of the variables in the namelist are INTENT(IN).  Returns
1719    nonzero if we find such a variable.  */
1720
1721 static int
1722 check_namelist (gfc_symbol * sym)
1723 {
1724   gfc_namelist *p;
1725
1726   for (p = sym->namelist; p; p = p->next)
1727     if (p->sym->attr.intent == INTENT_IN)
1728       {
1729         gfc_error ("Symbol '%s' in namelist '%s' is INTENT(IN) at %C",
1730                    p->sym->name, sym->name);
1731         return 1;
1732       }
1733
1734   return 0;
1735 }
1736
1737
1738 /* Match a single data transfer element.  */
1739
1740 static match
1741 match_dt_element (io_kind k, gfc_dt * dt)
1742 {
1743   char name[GFC_MAX_SYMBOL_LEN + 1];
1744   gfc_symbol *sym;
1745   match m;
1746
1747   if (gfc_match (" unit =") == MATCH_YES)
1748     {
1749       m = match_dt_unit (k, dt);
1750       if (m != MATCH_NO)
1751         return m;
1752     }
1753
1754   if (gfc_match (" fmt =") == MATCH_YES)
1755     {
1756       m = match_dt_format (dt);
1757       if (m != MATCH_NO)
1758         return m;
1759     }
1760
1761   if (gfc_match (" nml = %n", name) == MATCH_YES)
1762     {
1763       if (dt->namelist != NULL)
1764         {
1765           gfc_error ("Duplicate NML specification at %C");
1766           return MATCH_ERROR;
1767         }
1768
1769       if (gfc_find_symbol (name, NULL, 1, &sym))
1770         return MATCH_ERROR;
1771
1772       if (sym == NULL || sym->attr.flavor != FL_NAMELIST)
1773         {
1774           gfc_error ("Symbol '%s' at %C must be a NAMELIST group name",
1775                      sym != NULL ? sym->name : name);
1776           return MATCH_ERROR;
1777         }
1778
1779       dt->namelist = sym;
1780       if (k == M_READ && check_namelist (sym))
1781         return MATCH_ERROR;
1782
1783       return MATCH_YES;
1784     }
1785
1786   m = match_etag (&tag_rec, &dt->rec);
1787   if (m != MATCH_NO)
1788     return m;
1789   m = match_etag (&tag_spos, &dt->rec);
1790   if (m != MATCH_NO)
1791     return m;
1792   m = match_out_tag (&tag_iomsg, &dt->iomsg);
1793   if (m != MATCH_NO)
1794     return m;
1795   m = match_out_tag (&tag_iostat, &dt->iostat);
1796   if (m != MATCH_NO)
1797     return m;
1798   m = match_ltag (&tag_err, &dt->err);
1799   if (m == MATCH_YES)
1800     dt->err_where = gfc_current_locus;
1801   if (m != MATCH_NO)
1802     return m;
1803   m = match_etag (&tag_advance, &dt->advance);
1804   if (m != MATCH_NO)
1805     return m;
1806   m = match_out_tag (&tag_size, &dt->size);
1807   if (m != MATCH_NO)
1808     return m;
1809
1810   m = match_ltag (&tag_end, &dt->end);
1811   if (m == MATCH_YES)
1812     {
1813       if (k == M_WRITE)
1814        {
1815          gfc_error ("END tag at %C not allowed in output statement");
1816          return MATCH_ERROR;
1817        }
1818       dt->end_where = gfc_current_locus;
1819     }
1820   if (m != MATCH_NO)
1821     return m;
1822
1823   m = match_ltag (&tag_eor, &dt->eor);
1824   if (m == MATCH_YES)
1825     dt->eor_where = gfc_current_locus;
1826   if (m != MATCH_NO)
1827     return m;
1828
1829   return MATCH_NO;
1830 }
1831
1832
1833 /* Free a data transfer structure and everything below it.  */
1834
1835 void
1836 gfc_free_dt (gfc_dt * dt)
1837 {
1838
1839   if (dt == NULL)
1840     return;
1841
1842   gfc_free_expr (dt->io_unit);
1843   gfc_free_expr (dt->format_expr);
1844   gfc_free_expr (dt->rec);
1845   gfc_free_expr (dt->advance);
1846   gfc_free_expr (dt->iomsg);
1847   gfc_free_expr (dt->iostat);
1848   gfc_free_expr (dt->size);
1849
1850   gfc_free (dt);
1851 }
1852
1853
1854 /* Resolve everything in a gfc_dt structure.  */
1855
1856 try
1857 gfc_resolve_dt (gfc_dt * dt)
1858 {
1859   gfc_expr *e;
1860
1861   RESOLVE_TAG (&tag_format, dt->format_expr);
1862   RESOLVE_TAG (&tag_rec, dt->rec);
1863   RESOLVE_TAG (&tag_spos, dt->rec);
1864   RESOLVE_TAG (&tag_advance, dt->advance);
1865   RESOLVE_TAG (&tag_iomsg, dt->iomsg);
1866   RESOLVE_TAG (&tag_iostat, dt->iostat);
1867   RESOLVE_TAG (&tag_size, dt->size);
1868
1869   e = dt->io_unit;
1870   if (gfc_resolve_expr (e) == SUCCESS
1871       && (e->ts.type != BT_INTEGER
1872           && (e->ts.type != BT_CHARACTER
1873               || e->expr_type != EXPR_VARIABLE)))
1874     {
1875       gfc_error
1876         ("UNIT specification at %L must be an INTEGER expression or a "
1877          "CHARACTER variable", &e->where);
1878       return FAILURE;
1879     }
1880
1881   if (e->ts.type == BT_CHARACTER)
1882     {
1883       if (gfc_has_vector_index (e))
1884         {
1885           gfc_error ("Internal unit with vector subscript at %L",
1886                      &e->where);
1887           return FAILURE;
1888         }
1889     }
1890
1891   if (e->rank && e->ts.type != BT_CHARACTER)
1892     {
1893       gfc_error ("External IO UNIT cannot be an array at %L", &e->where);
1894       return FAILURE;
1895     }
1896
1897   if (dt->err)
1898     {
1899       if (gfc_reference_st_label (dt->err, ST_LABEL_TARGET) == FAILURE)
1900         return FAILURE;
1901       if (dt->err->defined == ST_LABEL_UNKNOWN)
1902         {
1903           gfc_error ("ERR tag label %d at %L not defined",
1904                       dt->err->value, &dt->err_where);
1905           return FAILURE;
1906         }
1907     }
1908
1909   if (dt->end)
1910     {
1911       if (gfc_reference_st_label (dt->end, ST_LABEL_TARGET) == FAILURE)
1912         return FAILURE;
1913       if (dt->end->defined == ST_LABEL_UNKNOWN)
1914         {
1915           gfc_error ("END tag label %d at %L not defined",
1916                       dt->end->value, &dt->end_where);
1917           return FAILURE;
1918         }
1919     }
1920
1921   if (dt->eor)
1922     {
1923       if (gfc_reference_st_label (dt->eor, ST_LABEL_TARGET) == FAILURE)
1924         return FAILURE;
1925       if (dt->eor->defined == ST_LABEL_UNKNOWN)
1926         {
1927           gfc_error ("EOR tag label %d at %L not defined",
1928                       dt->eor->value, &dt->eor_where);
1929           return FAILURE;
1930         }
1931     }
1932
1933   /* Check the format label actually exists.  */
1934   if (dt->format_label && dt->format_label != &format_asterisk
1935       && dt->format_label->defined == ST_LABEL_UNKNOWN)
1936     {
1937       gfc_error ("FORMAT label %d at %L not defined", dt->format_label->value,
1938                  &dt->format_label->where);
1939       return FAILURE;
1940     }
1941   return SUCCESS;
1942 }
1943
1944
1945 /* Given an io_kind, return its name.  */
1946
1947 static const char *
1948 io_kind_name (io_kind k)
1949 {
1950   const char *name;
1951
1952   switch (k)
1953     {
1954     case M_READ:
1955       name = "READ";
1956       break;
1957     case M_WRITE:
1958       name = "WRITE";
1959       break;
1960     case M_PRINT:
1961       name = "PRINT";
1962       break;
1963     case M_INQUIRE:
1964       name = "INQUIRE";
1965       break;
1966     default:
1967       gfc_internal_error ("io_kind_name(): bad I/O-kind");
1968     }
1969
1970   return name;
1971 }
1972
1973
1974 /* Match an IO iteration statement of the form:
1975
1976    ( [<IO element> ,] <IO element>, I = <expr>, <expr> [, <expr> ] )
1977
1978    which is equivalent to a single IO element.  This function is
1979    mutually recursive with match_io_element().  */
1980
1981 static match match_io_element (io_kind k, gfc_code **);
1982
1983 static match
1984 match_io_iterator (io_kind k, gfc_code ** result)
1985 {
1986   gfc_code *head, *tail, *new;
1987   gfc_iterator *iter;
1988   locus old_loc;
1989   match m;
1990   int n;
1991
1992   iter = NULL;
1993   head = NULL;
1994   old_loc = gfc_current_locus;
1995
1996   if (gfc_match_char ('(') != MATCH_YES)
1997     return MATCH_NO;
1998
1999   m = match_io_element (k, &head);
2000   tail = head;
2001
2002   if (m != MATCH_YES || gfc_match_char (',') != MATCH_YES)
2003     {
2004       m = MATCH_NO;
2005       goto cleanup;
2006     }
2007
2008   /* Can't be anything but an IO iterator.  Build a list.  */
2009   iter = gfc_get_iterator ();
2010
2011   for (n = 1;; n++)
2012     {
2013       m = gfc_match_iterator (iter, 0);
2014       if (m == MATCH_ERROR)
2015         goto cleanup;
2016       if (m == MATCH_YES)
2017         {
2018           gfc_check_do_variable (iter->var->symtree);
2019           break;
2020         }
2021
2022       m = match_io_element (k, &new);
2023       if (m == MATCH_ERROR)
2024         goto cleanup;
2025       if (m == MATCH_NO)
2026         {
2027           if (n > 2)
2028             goto syntax;
2029           goto cleanup;
2030         }
2031
2032       tail = gfc_append_code (tail, new);
2033
2034       if (gfc_match_char (',') != MATCH_YES)
2035         {
2036           if (n > 2)
2037             goto syntax;
2038           m = MATCH_NO;
2039           goto cleanup;
2040         }
2041     }
2042
2043   if (gfc_match_char (')') != MATCH_YES)
2044     goto syntax;
2045
2046   new = gfc_get_code ();
2047   new->op = EXEC_DO;
2048   new->ext.iterator = iter;
2049
2050   new->block = gfc_get_code ();
2051   new->block->op = EXEC_DO;
2052   new->block->next = head;
2053
2054   *result = new;
2055   return MATCH_YES;
2056
2057 syntax:
2058   gfc_error ("Syntax error in I/O iterator at %C");
2059   m = MATCH_ERROR;
2060
2061 cleanup:
2062   gfc_free_iterator (iter, 1);
2063   gfc_free_statements (head);
2064   gfc_current_locus = old_loc;
2065   return m;
2066 }
2067
2068
2069 /* Match a single element of an IO list, which is either a single
2070    expression or an IO Iterator.  */
2071
2072 static match
2073 match_io_element (io_kind k, gfc_code ** cpp)
2074 {
2075   gfc_expr *expr;
2076   gfc_code *cp;
2077   match m;
2078
2079   expr = NULL;
2080
2081   m = match_io_iterator (k, cpp);
2082   if (m == MATCH_YES)
2083     return MATCH_YES;
2084
2085   if (k == M_READ)
2086     {
2087       m = gfc_match_variable (&expr, 0);
2088       if (m == MATCH_NO)
2089         gfc_error ("Expected variable in READ statement at %C");
2090     }
2091   else
2092     {
2093       m = gfc_match_expr (&expr);
2094       if (m == MATCH_NO)
2095         gfc_error ("Expected expression in %s statement at %C",
2096                    io_kind_name (k));
2097     }
2098
2099   if (m == MATCH_YES)
2100     switch (k)
2101       {
2102       case M_READ:
2103         if (expr->symtree->n.sym->attr.intent == INTENT_IN)
2104           {
2105             gfc_error
2106               ("Variable '%s' in input list at %C cannot be INTENT(IN)",
2107                expr->symtree->n.sym->name);
2108             m = MATCH_ERROR;
2109           }
2110
2111         if (gfc_pure (NULL)
2112             && gfc_impure_variable (expr->symtree->n.sym)
2113             && current_dt->io_unit->ts.type == BT_CHARACTER)
2114           {
2115             gfc_error ("Cannot read to variable '%s' in PURE procedure at %C",
2116                        expr->symtree->n.sym->name);
2117             m = MATCH_ERROR;
2118           }
2119
2120         if (gfc_check_do_variable (expr->symtree))
2121           m = MATCH_ERROR;
2122
2123         break;
2124
2125       case M_WRITE:
2126         if (current_dt->io_unit->ts.type == BT_CHARACTER
2127             && gfc_pure (NULL)
2128             && current_dt->io_unit->expr_type == EXPR_VARIABLE
2129             && gfc_impure_variable (current_dt->io_unit->symtree->n.sym))
2130           {
2131             gfc_error
2132               ("Cannot write to internal file unit '%s' at %C inside a "
2133                "PURE procedure", current_dt->io_unit->symtree->n.sym->name);
2134             m = MATCH_ERROR;
2135           }
2136
2137         break;
2138
2139       default:
2140         break;
2141       }
2142
2143   if (m != MATCH_YES)
2144     {
2145       gfc_free_expr (expr);
2146       return MATCH_ERROR;
2147     }
2148
2149   cp = gfc_get_code ();
2150   cp->op = EXEC_TRANSFER;
2151   cp->expr = expr;
2152
2153   *cpp = cp;
2154   return MATCH_YES;
2155 }
2156
2157
2158 /* Match an I/O list, building gfc_code structures as we go.  */
2159
2160 static match
2161 match_io_list (io_kind k, gfc_code ** head_p)
2162 {
2163   gfc_code *head, *tail, *new;
2164   match m;
2165
2166   *head_p = head = tail = NULL;
2167   if (gfc_match_eos () == MATCH_YES)
2168     return MATCH_YES;
2169
2170   for (;;)
2171     {
2172       m = match_io_element (k, &new);
2173       if (m == MATCH_ERROR)
2174         goto cleanup;
2175       if (m == MATCH_NO)
2176         goto syntax;
2177
2178       tail = gfc_append_code (tail, new);
2179       if (head == NULL)
2180         head = new;
2181
2182       if (gfc_match_eos () == MATCH_YES)
2183         break;
2184       if (gfc_match_char (',') != MATCH_YES)
2185         goto syntax;
2186     }
2187
2188   *head_p = head;
2189   return MATCH_YES;
2190
2191 syntax:
2192   gfc_error ("Syntax error in %s statement at %C", io_kind_name (k));
2193
2194 cleanup:
2195   gfc_free_statements (head);
2196   return MATCH_ERROR;
2197 }
2198
2199
2200 /* Attach the data transfer end node.  */
2201
2202 static void
2203 terminate_io (gfc_code * io_code)
2204 {
2205   gfc_code *c;
2206
2207   if (io_code == NULL)
2208     io_code = new_st.block;
2209
2210   c = gfc_get_code ();
2211   c->op = EXEC_DT_END;
2212
2213   /* Point to structure that is already there */
2214   c->ext.dt = new_st.ext.dt;
2215   gfc_append_code (io_code, c);
2216 }
2217
2218
2219 /* Check the constraints for a data transfer statement.  The majority of the
2220    constraints appearing in 9.4 of the standard appear here.  Some are handled
2221    in resolve_tag and others in gfc_resolve_dt.  */
2222
2223 static match
2224 check_io_constraints (io_kind k, gfc_dt *dt, gfc_code * io_code, locus * spec_end)
2225 {
2226 #define io_constraint(condition,msg,arg)\
2227 if (condition) \
2228   {\
2229     gfc_error(msg,arg);\
2230     m = MATCH_ERROR;\
2231   }
2232
2233   match m;
2234   gfc_expr * expr;
2235   gfc_symbol * sym = NULL;
2236
2237   m = MATCH_YES;
2238
2239   expr = dt->io_unit;
2240   if (expr && expr->expr_type == EXPR_VARIABLE
2241         && expr->ts.type == BT_CHARACTER)
2242     {
2243       sym = expr->symtree->n.sym;
2244
2245       io_constraint (k == M_WRITE && sym->attr.intent == INTENT_IN,
2246                      "Internal file at %L must not be INTENT(IN)",
2247                      &expr->where);
2248
2249       io_constraint (gfc_has_vector_index (dt->io_unit),
2250                      "Internal file incompatible with vector subscript at %L",
2251                      &expr->where);
2252
2253       io_constraint (dt->rec != NULL,
2254                      "REC tag at %L is incompatible with internal file",
2255                      &dt->rec->where);
2256
2257       io_constraint (dt->namelist != NULL,
2258                      "Internal file at %L is incompatible with namelist",
2259                      &expr->where);
2260
2261       io_constraint (dt->advance != NULL,
2262                      "ADVANCE tag at %L is incompatible with internal file",
2263                      &dt->advance->where);
2264     }
2265
2266   if (expr && expr->ts.type != BT_CHARACTER)
2267     {
2268
2269       io_constraint (gfc_pure (NULL)
2270                        && (k == M_READ || k == M_WRITE),
2271                      "IO UNIT in %s statement at %C must be "
2272                      "an internal file in a PURE procedure",
2273                      io_kind_name (k));
2274     }
2275
2276
2277   if (k != M_READ)
2278     {
2279       io_constraint (dt->end,
2280                      "END tag not allowed with output at %L",
2281                      &dt->end_where);
2282
2283       io_constraint (dt->eor,
2284                      "EOR tag not allowed with output at %L",
2285                      &dt->eor_where);
2286
2287       io_constraint (k != M_READ && dt->size,
2288                      "SIZE=specifier not allowed with output at %L",
2289                      &dt->size->where);
2290     }
2291   else
2292     {
2293       io_constraint (dt->size && dt->advance == NULL,
2294                      "SIZE tag at %L requires an ADVANCE tag",
2295                      &dt->size->where);
2296
2297       io_constraint (dt->eor && dt->advance == NULL,
2298                      "EOR tag at %L requires an ADVANCE tag",
2299                      &dt->eor_where);
2300     }
2301
2302
2303
2304   if (dt->namelist)
2305     {
2306       io_constraint (io_code && dt->namelist,
2307                      "NAMELIST cannot be followed by IO-list at %L",
2308                      &io_code->loc);
2309
2310       io_constraint (dt->format_expr,
2311                      "IO spec-list cannot contain both NAMELIST group name "
2312                      "and format specification at %L.",
2313                      &dt->format_expr->where);
2314
2315       io_constraint (dt->format_label,
2316                      "IO spec-list cannot contain both NAMELIST group name "
2317                      "and format label at %L", spec_end);
2318
2319       io_constraint (dt->rec,
2320                      "NAMELIST IO is not allowed with a REC=specifier "
2321                      "at %L.", &dt->rec->where);
2322
2323       io_constraint (dt->advance,
2324                      "NAMELIST IO is not allowed with a ADVANCE=specifier "
2325                      "at %L.", &dt->advance->where);
2326     }
2327
2328   if (dt->rec)
2329     {
2330       io_constraint (dt->end,
2331                      "An END tag is not allowed with a "
2332                      "REC=specifier at %L.", &dt->end_where);
2333
2334
2335       io_constraint (dt->format_label == &format_asterisk,
2336                      "FMT=* is not allowed with a REC=specifier "
2337                      "at %L.", spec_end);
2338     }
2339
2340   if (dt->advance)
2341     {
2342       int not_yes, not_no;
2343       expr = dt->advance;
2344
2345       io_constraint (dt->format_label == &format_asterisk,
2346                      "List directed format(*) is not allowed with a "
2347                      "ADVANCE=specifier at %L.", &expr->where);
2348
2349       io_constraint (dt->format_expr == NULL
2350                        && dt->format_label == NULL
2351                        && dt->namelist == NULL,
2352                      "the ADVANCE=specifier at %L must appear with an "
2353                      "explicit format expression", &expr->where);
2354
2355       if (expr->expr_type == EXPR_CONSTANT && expr->ts.type == BT_CHARACTER)
2356         {
2357           const char * advance = expr->value.character.string;
2358           not_no = strncasecmp (advance, "no", 2) != 0;
2359           not_yes = strncasecmp (advance, "yes", 2) != 0;
2360         }
2361       else
2362         {
2363           not_no = 0;
2364           not_yes = 0;
2365         }
2366
2367       io_constraint (not_no && not_yes,
2368                      "ADVANCE=specifier at %L must have value = "
2369                      "YES or NO.", &expr->where);
2370
2371       io_constraint (dt->size && not_no && k == M_READ,
2372                      "SIZE tag at %L requires an ADVANCE = 'NO'",
2373                      &dt->size->where);
2374
2375       io_constraint (dt->eor && not_no && k == M_READ,
2376                      "EOR tag at %L requires an ADVANCE = 'NO'",
2377                      &dt->eor_where);
2378     }
2379
2380   expr = dt->format_expr;
2381   if (expr != NULL && expr->expr_type == EXPR_CONSTANT)
2382     check_format_string (expr);
2383
2384   return m;
2385 }
2386 #undef io_constraint
2387
2388 /* Match a READ, WRITE or PRINT statement.  */
2389
2390 static match
2391 match_io (io_kind k)
2392 {
2393   char name[GFC_MAX_SYMBOL_LEN + 1];
2394   gfc_code *io_code;
2395   gfc_symbol *sym;
2396   int comma_flag, c;
2397   locus where;
2398   locus spec_end;
2399   gfc_dt *dt;
2400   match m;
2401
2402   where = gfc_current_locus;
2403   comma_flag = 0;
2404   current_dt = dt = gfc_getmem (sizeof (gfc_dt));
2405   if (gfc_match_char ('(') == MATCH_NO)
2406     {
2407       where = gfc_current_locus;
2408       if (k == M_WRITE)
2409         goto syntax;
2410       else if (k == M_PRINT)
2411         {
2412           /* Treat the non-standard case of PRINT namelist.  */
2413           if ((gfc_current_form == FORM_FIXED || gfc_peek_char () == ' ')
2414               && gfc_match_name (name) == MATCH_YES)
2415             {
2416               gfc_find_symbol (name, NULL, 1, &sym);
2417               if (sym && sym->attr.flavor == FL_NAMELIST)
2418                 {
2419                   if (gfc_notify_std (GFC_STD_GNU, "PRINT namelist at "
2420                                       "%C is an extension") == FAILURE)
2421                     {
2422                       m = MATCH_ERROR;
2423                       goto cleanup;
2424                     }
2425
2426                   dt->io_unit = default_unit (k);
2427                   dt->namelist = sym;
2428                   goto get_io_list;
2429                 }
2430               else
2431                 gfc_current_locus = where;
2432             }
2433         }
2434
2435       if (gfc_current_form == FORM_FREE)
2436         {
2437           c = gfc_peek_char();
2438           if (c != ' ' && c != '*' && c != '\'' && c != '"')
2439             {
2440               m = MATCH_NO;
2441               goto cleanup;
2442             }
2443         }
2444
2445       m = match_dt_format (dt);
2446       if (m == MATCH_ERROR)
2447         goto cleanup;
2448       if (m == MATCH_NO)
2449         goto syntax;
2450
2451       comma_flag = 1;
2452       dt->io_unit = default_unit (k);
2453       goto get_io_list;
2454     }
2455   else
2456     {
2457       /* Error for constructs like print (1,*).   */
2458       if (k == M_PRINT)
2459         goto  syntax;
2460     }
2461
2462   /* Match a control list */
2463   if (match_dt_element (k, dt) == MATCH_YES)
2464     goto next;
2465   if (match_dt_unit (k, dt) != MATCH_YES)
2466     goto loop;
2467
2468   if (gfc_match_char (')') == MATCH_YES)
2469     goto get_io_list;
2470   if (gfc_match_char (',') != MATCH_YES)
2471     goto syntax;
2472
2473   m = match_dt_element (k, dt);
2474   if (m == MATCH_YES)
2475     goto next;
2476   if (m == MATCH_ERROR)
2477     goto cleanup;
2478
2479   m = match_dt_format (dt);
2480   if (m == MATCH_YES)
2481     goto next;
2482   if (m == MATCH_ERROR)
2483     goto cleanup;
2484
2485   where = gfc_current_locus;
2486
2487   m = gfc_match_name (name);
2488   if (m == MATCH_YES)
2489     {
2490       gfc_find_symbol (name, NULL, 1, &sym);
2491       if (sym && sym->attr.flavor == FL_NAMELIST)
2492         {
2493           dt->namelist = sym;
2494           if (k == M_READ && check_namelist (sym))
2495             {
2496               m = MATCH_ERROR;
2497               goto cleanup;
2498             }
2499           goto next;
2500         }
2501     }
2502
2503   gfc_current_locus = where;
2504
2505   goto loop;                    /* No matches, try regular elements */
2506
2507 next:
2508   if (gfc_match_char (')') == MATCH_YES)
2509     goto get_io_list;
2510   if (gfc_match_char (',') != MATCH_YES)
2511     goto syntax;
2512
2513 loop:
2514   for (;;)
2515     {
2516       m = match_dt_element (k, dt);
2517       if (m == MATCH_NO)
2518         goto syntax;
2519       if (m == MATCH_ERROR)
2520         goto cleanup;
2521
2522       if (gfc_match_char (')') == MATCH_YES)
2523         break;
2524       if (gfc_match_char (',') != MATCH_YES)
2525         goto syntax;
2526     }
2527
2528 get_io_list:
2529
2530   /* Used in check_io_constraints, where no locus is available.  */
2531   spec_end = gfc_current_locus;
2532
2533   /* Optional leading comma (non-standard).  */
2534   if (!comma_flag
2535       && gfc_match_char (',') == MATCH_YES
2536       && k == M_WRITE
2537       && gfc_notify_std (GFC_STD_GNU, "Extension: Comma before output "
2538                          "item list at %C is an extension") == FAILURE)
2539     return MATCH_ERROR;
2540
2541   io_code = NULL;
2542   if (gfc_match_eos () != MATCH_YES)
2543     {
2544       if (comma_flag && gfc_match_char (',') != MATCH_YES)
2545         {
2546           gfc_error ("Expected comma in I/O list at %C");
2547           m = MATCH_ERROR;
2548           goto cleanup;
2549         }
2550
2551       m = match_io_list (k, &io_code);
2552       if (m == MATCH_ERROR)
2553         goto cleanup;
2554       if (m == MATCH_NO)
2555         goto syntax;
2556     }
2557
2558   /* A full IO statement has been matched.  Check the constraints.  spec_end is
2559      supplied for cases where no locus is supplied.  */
2560   m = check_io_constraints (k, dt, io_code, &spec_end);
2561
2562   if (m == MATCH_ERROR)
2563     goto cleanup;
2564
2565   new_st.op = (k == M_READ) ? EXEC_READ : EXEC_WRITE;
2566   new_st.ext.dt = dt;
2567   new_st.block = gfc_get_code ();
2568   new_st.block->op = new_st.op;
2569   new_st.block->next = io_code;
2570
2571   terminate_io (io_code);
2572
2573   return MATCH_YES;
2574
2575 syntax:
2576   gfc_error ("Syntax error in %s statement at %C", io_kind_name (k));
2577   m = MATCH_ERROR;
2578
2579 cleanup:
2580   gfc_free_dt (dt);
2581   return m;
2582 }
2583
2584
2585 match
2586 gfc_match_read (void)
2587 {
2588   return match_io (M_READ);
2589 }
2590
2591 match
2592 gfc_match_write (void)
2593 {
2594   return match_io (M_WRITE);
2595 }
2596
2597 match
2598 gfc_match_print (void)
2599 {
2600   match m;
2601
2602   m = match_io (M_PRINT);
2603   if (m != MATCH_YES)
2604     return m;
2605
2606   if (gfc_pure (NULL))
2607     {
2608       gfc_error ("PRINT statement at %C not allowed within PURE procedure");
2609       return MATCH_ERROR;
2610     }
2611
2612   return MATCH_YES;
2613 }
2614
2615
2616 /* Free a gfc_inquire structure.  */
2617
2618 void
2619 gfc_free_inquire (gfc_inquire * inquire)
2620 {
2621
2622   if (inquire == NULL)
2623     return;
2624
2625   gfc_free_expr (inquire->unit);
2626   gfc_free_expr (inquire->file);
2627   gfc_free_expr (inquire->iomsg);
2628   gfc_free_expr (inquire->iostat);
2629   gfc_free_expr (inquire->exist);
2630   gfc_free_expr (inquire->opened);
2631   gfc_free_expr (inquire->number);
2632   gfc_free_expr (inquire->named);
2633   gfc_free_expr (inquire->name);
2634   gfc_free_expr (inquire->access);
2635   gfc_free_expr (inquire->sequential);
2636   gfc_free_expr (inquire->direct);
2637   gfc_free_expr (inquire->form);
2638   gfc_free_expr (inquire->formatted);
2639   gfc_free_expr (inquire->unformatted);
2640   gfc_free_expr (inquire->recl);
2641   gfc_free_expr (inquire->nextrec);
2642   gfc_free_expr (inquire->blank);
2643   gfc_free_expr (inquire->position);
2644   gfc_free_expr (inquire->action);
2645   gfc_free_expr (inquire->read);
2646   gfc_free_expr (inquire->write);
2647   gfc_free_expr (inquire->readwrite);
2648   gfc_free_expr (inquire->delim);
2649   gfc_free_expr (inquire->pad);
2650   gfc_free_expr (inquire->iolength);
2651   gfc_free_expr (inquire->convert);
2652   gfc_free_expr (inquire->strm_pos);
2653
2654   gfc_free (inquire);
2655 }
2656
2657
2658 /* Match an element of an INQUIRE statement.  */
2659
2660 #define RETM   if (m != MATCH_NO) return m;
2661
2662 static match
2663 match_inquire_element (gfc_inquire * inquire)
2664 {
2665   match m;
2666
2667   m = match_etag (&tag_unit, &inquire->unit);
2668   RETM m = match_etag (&tag_file, &inquire->file);
2669   RETM m = match_ltag (&tag_err, &inquire->err);
2670   RETM m = match_out_tag (&tag_iomsg, &inquire->iomsg);
2671   RETM m = match_out_tag (&tag_iostat, &inquire->iostat);
2672   RETM m = match_vtag (&tag_exist, &inquire->exist);
2673   RETM m = match_vtag (&tag_opened, &inquire->opened);
2674   RETM m = match_vtag (&tag_named, &inquire->named);
2675   RETM m = match_vtag (&tag_name, &inquire->name);
2676   RETM m = match_out_tag (&tag_number, &inquire->number);
2677   RETM m = match_vtag (&tag_s_access, &inquire->access);
2678   RETM m = match_vtag (&tag_sequential, &inquire->sequential);
2679   RETM m = match_vtag (&tag_direct, &inquire->direct);
2680   RETM m = match_vtag (&tag_s_form, &inquire->form);
2681   RETM m = match_vtag (&tag_formatted, &inquire->formatted);
2682   RETM m = match_vtag (&tag_unformatted, &inquire->unformatted);
2683   RETM m = match_out_tag (&tag_s_recl, &inquire->recl);
2684   RETM m = match_out_tag (&tag_nextrec, &inquire->nextrec);
2685   RETM m = match_vtag (&tag_s_blank, &inquire->blank);
2686   RETM m = match_vtag (&tag_s_position, &inquire->position);
2687   RETM m = match_vtag (&tag_s_action, &inquire->action);
2688   RETM m = match_vtag (&tag_read, &inquire->read);
2689   RETM m = match_vtag (&tag_write, &inquire->write);
2690   RETM m = match_vtag (&tag_readwrite, &inquire->readwrite);
2691   RETM m = match_vtag (&tag_s_delim, &inquire->delim);
2692   RETM m = match_vtag (&tag_s_pad, &inquire->pad);
2693   RETM m = match_vtag (&tag_iolength, &inquire->iolength);
2694   RETM m = match_vtag (&tag_convert, &inquire->convert);
2695   RETM m = match_out_tag (&tag_strm_out, &inquire->strm_pos);
2696   RETM return MATCH_NO;
2697 }
2698
2699 #undef RETM
2700
2701
2702 match
2703 gfc_match_inquire (void)
2704 {
2705   gfc_inquire *inquire;
2706   gfc_code *code;
2707   match m;
2708   locus loc;
2709
2710   m = gfc_match_char ('(');
2711   if (m == MATCH_NO)
2712     return m;
2713
2714   inquire = gfc_getmem (sizeof (gfc_inquire));
2715
2716   loc = gfc_current_locus;
2717
2718   m = match_inquire_element (inquire);
2719   if (m == MATCH_ERROR)
2720     goto cleanup;
2721   if (m == MATCH_NO)
2722     {
2723       m = gfc_match_expr (&inquire->unit);
2724       if (m == MATCH_ERROR)
2725         goto cleanup;
2726       if (m == MATCH_NO)
2727         goto syntax;
2728     }
2729
2730   /* See if we have the IOLENGTH form of the inquire statement.  */
2731   if (inquire->iolength != NULL)
2732     {
2733       if (gfc_match_char (')') != MATCH_YES)
2734         goto syntax;
2735
2736       m = match_io_list (M_INQUIRE, &code);
2737       if (m == MATCH_ERROR)
2738         goto cleanup;
2739       if (m == MATCH_NO)
2740         goto syntax;
2741
2742       new_st.op = EXEC_IOLENGTH;
2743       new_st.expr = inquire->iolength;
2744       new_st.ext.inquire = inquire;
2745
2746       if (gfc_pure (NULL))
2747         {
2748           gfc_free_statements (code);
2749           gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
2750           return MATCH_ERROR;
2751         }
2752
2753       new_st.block = gfc_get_code ();
2754       new_st.block->op = EXEC_IOLENGTH;
2755       terminate_io (code);
2756       new_st.block->next = code;
2757       return MATCH_YES;
2758     }
2759
2760   /* At this point, we have the non-IOLENGTH inquire statement.  */
2761   for (;;)
2762     {
2763       if (gfc_match_char (')') == MATCH_YES)
2764         break;
2765       if (gfc_match_char (',') != MATCH_YES)
2766         goto syntax;
2767
2768       m = match_inquire_element (inquire);
2769       if (m == MATCH_ERROR)
2770         goto cleanup;
2771       if (m == MATCH_NO)
2772         goto syntax;
2773
2774       if (inquire->iolength != NULL)
2775         {
2776           gfc_error ("IOLENGTH tag invalid in INQUIRE statement at %C");
2777           goto cleanup;
2778         }
2779     }
2780
2781   if (gfc_match_eos () != MATCH_YES)
2782     goto syntax;
2783
2784   if (inquire->unit != NULL && inquire->file != NULL)
2785     {
2786       gfc_error ("INQUIRE statement at %L cannot contain both FILE and"
2787                  " UNIT specifiers", &loc);
2788       goto cleanup;
2789     }
2790
2791   if (inquire->unit == NULL && inquire->file == NULL)
2792     {
2793       gfc_error ("INQUIRE statement at %L requires either FILE or"
2794                      " UNIT specifier", &loc);
2795       goto cleanup;
2796     }
2797
2798   if (gfc_pure (NULL))
2799     {
2800       gfc_error ("INQUIRE statement not allowed in PURE procedure at %C");
2801       goto cleanup;
2802     }
2803
2804   new_st.op = EXEC_INQUIRE;
2805   new_st.ext.inquire = inquire;
2806   return MATCH_YES;
2807
2808 syntax:
2809   gfc_syntax_error (ST_INQUIRE);
2810
2811 cleanup:
2812   gfc_free_inquire (inquire);
2813   return MATCH_ERROR;
2814 }
2815
2816
2817 /* Resolve everything in a gfc_inquire structure.  */
2818
2819 try
2820 gfc_resolve_inquire (gfc_inquire * inquire)
2821 {
2822
2823   RESOLVE_TAG (&tag_unit, inquire->unit);
2824   RESOLVE_TAG (&tag_file, inquire->file);
2825   RESOLVE_TAG (&tag_iomsg, inquire->iomsg);
2826   RESOLVE_TAG (&tag_iostat, inquire->iostat);
2827   RESOLVE_TAG (&tag_exist, inquire->exist);
2828   RESOLVE_TAG (&tag_opened, inquire->opened);
2829   RESOLVE_TAG (&tag_number, inquire->number);
2830   RESOLVE_TAG (&tag_named, inquire->named);
2831   RESOLVE_TAG (&tag_name, inquire->name);
2832   RESOLVE_TAG (&tag_s_access, inquire->access);
2833   RESOLVE_TAG (&tag_sequential, inquire->sequential);
2834   RESOLVE_TAG (&tag_direct, inquire->direct);
2835   RESOLVE_TAG (&tag_s_form, inquire->form);
2836   RESOLVE_TAG (&tag_formatted, inquire->formatted);
2837   RESOLVE_TAG (&tag_unformatted, inquire->unformatted);
2838   RESOLVE_TAG (&tag_s_recl, inquire->recl);
2839   RESOLVE_TAG (&tag_nextrec, inquire->nextrec);
2840   RESOLVE_TAG (&tag_s_blank, inquire->blank);
2841   RESOLVE_TAG (&tag_s_position, inquire->position);
2842   RESOLVE_TAG (&tag_s_action, inquire->action);
2843   RESOLVE_TAG (&tag_read, inquire->read);
2844   RESOLVE_TAG (&tag_write, inquire->write);
2845   RESOLVE_TAG (&tag_readwrite, inquire->readwrite);
2846   RESOLVE_TAG (&tag_s_delim, inquire->delim);
2847   RESOLVE_TAG (&tag_s_pad, inquire->pad);
2848   RESOLVE_TAG (&tag_iolength, inquire->iolength);
2849   RESOLVE_TAG (&tag_convert, inquire->convert);
2850   RESOLVE_TAG (&tag_strm_out, inquire->strm_pos);
2851
2852   if (gfc_reference_st_label (inquire->err, ST_LABEL_TARGET) == FAILURE)
2853     return FAILURE;
2854
2855   return SUCCESS;
2856 }