freebsd-nq/contrib/gcc/f/ste.c

/* ste.c -- Implementation File (module.c template V1.0)
   Copyright (C) 1995, 1996 Free Software Foundation, Inc.
   Contributed by James Craig Burley.

This file is part of GNU Fortran.

GNU Fortran is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Fortran is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Fortran; see the file COPYING.  If not, write to
the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.

   Related Modules:
      ste.c

   Description:
      Implements the various statements and such like.

   Modifications:
*/

/* Include files. */

#include "proj.h"

#if FFECOM_targetCURRENT == FFECOM_targetGCC
#include "rtl.j"
#include "toplev.j"
#endif

#include "ste.h"
#include "bld.h"
#include "com.h"
#include "expr.h"
#include "lab.h"
#include "lex.h"
#include "sta.h"
#include "stp.h"
#include "str.h"
#include "sts.h"
#include "stt.h"
#include "stv.h"
#include "stw.h"
#include "symbol.h"

/* Externals defined here. */


/* Simple definitions and enumerations. */

typedef enum
  {
    FFESTE_stateletSIMPLE_,	/* Expecting simple/start. */
    FFESTE_stateletATTRIB_,	/* Expecting attrib/item/itemstart. */
    FFESTE_stateletITEM_,	/* Expecting item/itemstart/finish. */
    FFESTE_stateletITEMVALS_,	/* Expecting itemvalue/itemendvals. */
    FFESTE_
  } ffesteStatelet_;

/* Internal typedefs. */


/* Private include files. */


/* Internal structure definitions. */


/* Static objects accessed by functions in this module. */

static ffesteStatelet_ ffeste_statelet_ = FFESTE_stateletSIMPLE_;
#if FFECOM_targetCURRENT == FFECOM_targetGCC
static ffelab ffeste_label_formatdef_ = NULL;
static tree (*ffeste_io_driver_) (ffebld expr);	/* do?io. */
static ffecomGfrt ffeste_io_endgfrt_;	/* end function to call. */
static tree ffeste_io_abort_;	/* abort-io label or NULL_TREE. */
static bool ffeste_io_abort_is_temp_;	/* abort-io label is a temp. */
static tree ffeste_io_end_;	/* END= label or NULL_TREE. */
static tree ffeste_io_err_;	/* ERR= label or NULL_TREE. */
static tree ffeste_io_iostat_;	/* IOSTAT= var or NULL_TREE. */
static bool ffeste_io_iostat_is_temp_;	/* IOSTAT= var is a temp. */
#endif

/* Static functions (internal). */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void ffeste_begin_iterdo_ (ffestw block, tree *tvar, tree *tincr,
				  tree *xitersvar, ffebld var,
				  ffebld start, ffelexToken start_token,
				  ffebld end, ffelexToken end_token,
				  ffebld incr, ffelexToken incr_token,
				  const char *msg);
static void ffeste_end_iterdo_ (ffestw block, tree tvar, tree tincr,
				tree itersvar);
static void ffeste_io_call_ (tree call, bool do_check);
static void ffeste_io_impdo_ (ffebld impdo, ffelexToken impdo_token);
static tree ffeste_io_dofio_ (ffebld expr);
static tree ffeste_io_dolio_ (ffebld expr);
static tree ffeste_io_douio_ (ffebld expr);
static tree ffeste_io_ialist_ (bool have_err, ffestvUnit unit,
			       ffebld unit_expr, int unit_dflt);
static tree ffeste_io_cilist_ (bool have_err, ffestvUnit unit,
			       ffebld unit_expr, int unit_dflt,
			       bool have_end, ffestvFormat format,
			       ffestpFile *format_spec, bool rec,
			       ffebld rec_expr);
static tree ffeste_io_cllist_ (bool have_err, ffebld unit_expr,
			       ffestpFile *stat_spec);
static tree ffeste_io_icilist_ (bool have_err, ffebld unit_expr,
				bool have_end, ffestvFormat format,
				ffestpFile *format_spec);
static tree ffeste_io_inlist_ (bool have_err,
			       ffestpFile *unit_spec,
			       ffestpFile *file_spec,
			       ffestpFile *exist_spec,
			       ffestpFile *open_spec,
			       ffestpFile *number_spec,
			       ffestpFile *named_spec,
			       ffestpFile *name_spec,
			       ffestpFile *access_spec,
			       ffestpFile *sequential_spec,
			       ffestpFile *direct_spec,
			       ffestpFile *form_spec,
			       ffestpFile *formatted_spec,
			       ffestpFile *unformatted_spec,
			       ffestpFile *recl_spec,
			       ffestpFile *nextrec_spec,
			       ffestpFile *blank_spec);
static tree ffeste_io_olist_ (bool have_err, ffebld unit_expr,
			      ffestpFile *file_spec,
			      ffestpFile *stat_spec,
			      ffestpFile *access_spec,
			      ffestpFile *form_spec,
			      ffestpFile *recl_spec,
			      ffestpFile *blank_spec);
static void ffeste_subr_beru_ (ffestpBeruStmt *info, ffecomGfrt rt);
#elif FFECOM_targetCURRENT == FFECOM_targetFFE
static void ffeste_subr_file_ (const char *kw, ffestpFile *spec);
#else
#error
#endif

/* Internal macros. */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
#define ffeste_emit_line_note_() \
  emit_line_note (input_filename, lineno)
#endif
#define ffeste_check_simple_() \
  assert(ffeste_statelet_ == FFESTE_stateletSIMPLE_)
#define ffeste_check_start_() \
  assert(ffeste_statelet_ == FFESTE_stateletSIMPLE_); \
  ffeste_statelet_ = FFESTE_stateletATTRIB_
#define ffeste_check_attrib_() \
  assert(ffeste_statelet_ == FFESTE_stateletATTRIB_)
#define ffeste_check_item_() \
  assert(ffeste_statelet_ == FFESTE_stateletATTRIB_	 \
	 || ffeste_statelet_ == FFESTE_stateletITEM_); \
  ffeste_statelet_ = FFESTE_stateletITEM_
#define ffeste_check_item_startvals_() \
  assert(ffeste_statelet_ == FFESTE_stateletATTRIB_	 \
	 || ffeste_statelet_ == FFESTE_stateletITEM_); \
  ffeste_statelet_ = FFESTE_stateletITEMVALS_
#define ffeste_check_item_value_() \
  assert(ffeste_statelet_ == FFESTE_stateletITEMVALS_)
#define ffeste_check_item_endvals_() \
  assert(ffeste_statelet_ == FFESTE_stateletITEMVALS_); \
  ffeste_statelet_ = FFESTE_stateletITEM_
#define ffeste_check_finish_() \
  assert(ffeste_statelet_ == FFESTE_stateletATTRIB_	 \
	 || ffeste_statelet_ == FFESTE_stateletITEM_); \
  ffeste_statelet_ = FFESTE_stateletSIMPLE_

#define ffeste_f2c_init_charnolen_(Exp,Init,Spec)			      \
  do									      \
    {									      \
      if ((Spec)->kw_or_val_present)					      \
	Exp = ffecom_arg_ptr_to_const_expr ((Spec)->u.expr, &ignore);	      \
      else								      \
	Exp = null_pointer_node;					      \
      if (Exp)								      \
	Init = Exp;							      \
      else								      \
	{								      \
	  Init = null_pointer_node;					      \
	  constantp = FALSE;						      \
	}								      \
    } while(0)

#define ffeste_f2c_init_char_(Exp,Init,Lenexp,Leninit,Spec)		      \
  do									      \
    {									      \
      if ((Spec)->kw_or_val_present)					      \
	Exp = ffecom_arg_ptr_to_const_expr ((Spec)->u.expr, &Lenexp);	      \
      else								      \
	{								      \
	  Exp = null_pointer_node;					      \
	  Lenexp = ffecom_f2c_ftnlen_zero_node;				      \
	}								      \
      if (Exp)								      \
	Init = Exp;							      \
      else								      \
	{								      \
	  Init = null_pointer_node;					      \
	  constantp = FALSE;						      \
	}								      \
      if (Lenexp)							      \
	Leninit = Lenexp;						      \
      else								      \
	{								      \
	  Leninit = ffecom_f2c_ftnlen_zero_node;			      \
	  constantp = FALSE;						      \
	}								      \
    } while(0)

#define ffeste_f2c_init_flag_(Flag,Init)				      \
  do									      \
    {									      \
      Init = convert (ffecom_f2c_flag_type_node,			      \
		      (Flag) ? integer_one_node : integer_zero_node);	      \
    } while(0)

#define ffeste_f2c_init_format_(Exp,Init,Spec)				      \
  do									      \
    {									      \
      Exp = ffecom_arg_ptr_to_const_expr ((Spec)->u.expr, NULL);	      \
      if (Exp)								      \
	Init = Exp;							      \
      else								      \
	{								      \
	  Init = null_pointer_node;					      \
	  constantp = FALSE;						      \
	}								      \
    } while(0)

#define ffeste_f2c_init_int_(Exp,Init,Spec)				      \
  do									      \
    {									      \
      if ((Spec)->kw_or_val_present)					      \
	Exp = ffecom_const_expr ((Spec)->u.expr);			      \
      else								      \
	Exp = ffecom_integer_zero_node;					      \
      if (Exp)								      \
	Init = Exp;							      \
      else								      \
	{								      \
	  Init = ffecom_integer_zero_node;				      \
	  constantp = FALSE;						      \
	}								      \
    } while(0)

#define ffeste_f2c_init_ptrtoint_(Exp,Init,Spec)			      \
  do									      \
    {									      \
      if ((Spec)->kw_or_val_present)					      \
	Exp = ffecom_ptr_to_const_expr ((Spec)->u.expr);		      \
      else								      \
	Exp = null_pointer_node;					      \
      if (Exp)								      \
	Init = Exp;							      \
      else								      \
	{								      \
	  Init = null_pointer_node;					      \
	  constantp = FALSE;						      \
	}								      \
    } while(0)

#define ffeste_f2c_init_next_(Init)					      \
  do									      \
    {									      \
      TREE_CHAIN (initn) = build_tree_list ((field = TREE_CHAIN (field)),     \
					    (Init));			      \
      initn = TREE_CHAIN(initn);					      \
    } while(0)

#define ffeste_f2c_prepare_charnolen_(Spec,Exp)				      \
  do									      \
    {									      \
      if (! (Exp))							      \
        ffecom_prepare_arg_ptr_to_expr ((Spec)->u.expr);		      \
    } while(0)

#define ffeste_f2c_prepare_char_(Spec,Exp)				      \
  do									      \
    {									      \
      if (! (Exp))							      \
        ffecom_prepare_arg_ptr_to_expr ((Spec)->u.expr);		      \
    } while(0)

#define ffeste_f2c_prepare_format_(Spec,Exp)				      \
  do									      \
    {									      \
      if (! (Exp))							      \
        ffecom_prepare_arg_ptr_to_expr ((Spec)->u.expr);		      \
    } while(0)

#define ffeste_f2c_prepare_int_(Spec,Exp)				      \
  do									      \
    {									      \
      if (! (Exp))							      \
        ffecom_prepare_expr ((Spec)->u.expr);				      \
    } while(0)

#define ffeste_f2c_prepare_ptrtoint_(Spec,Exp)				      \
  do									      \
    {									      \
      if (! (Exp))							      \
        ffecom_prepare_ptr_to_expr ((Spec)->u.expr);			      \
    } while(0)

#define ffeste_f2c_compile_(Field,Exp)					      \
  do									      \
    {									      \
      tree exz;								      \
      if ((Exp))							      \
	{								      \
	  exz = ffecom_modify (void_type_node,				      \
			       ffecom_2 (COMPONENT_REF, TREE_TYPE (Field),    \
					 t, (Field)),			      \
			       (Exp));					      \
	  expand_expr_stmt (exz);					      \
	}								      \
    } while(0)

#define ffeste_f2c_compile_charnolen_(Field,Spec,Exp)			      \
  do									      \
    {									      \
      tree exq;								      \
      if (! (Exp))							      \
	{								      \
	  exq = ffecom_arg_ptr_to_expr ((Spec)->u.expr, &ignore);	      \
	  ffeste_f2c_compile_ ((Field), exq);				      \
	}								      \
    } while(0)

#define ffeste_f2c_compile_char_(Field,Lenfield,Spec,Exp,Lenexp)	      \
  do									      \
    {									      \
      tree exq = (Exp);							      \
      tree lenexq = (Lenexp);						      \
      int need_exq = (! exq);						      \
      int need_lenexq = (! lenexq); 					      \
      if (need_exq || need_lenexq)					      \
	{								      \
	  exq = ffecom_arg_ptr_to_expr ((Spec)->u.expr, &lenexq);	      \
	  if (need_exq)							      \
	    ffeste_f2c_compile_ ((Field), exq);				      \
	  if (need_lenexq)						      \
	    ffeste_f2c_compile_ ((Lenfield), lenexq);			      \
	}								      \
    } while(0)

#define ffeste_f2c_compile_format_(Field,Spec,Exp)			      \
  do									      \
    {									      \
      tree exq;								      \
      if (! (Exp))							      \
	{								      \
	  exq = ffecom_arg_ptr_to_expr ((Spec)->u.expr, NULL);		      \
	  ffeste_f2c_compile_ ((Field), exq);				      \
	}								      \
    } while(0)

#define ffeste_f2c_compile_int_(Field,Spec,Exp)				      \
  do									      \
    {									      \
      tree exq;								      \
      if (! (Exp))							      \
	{								      \
	  exq = ffecom_expr ((Spec)->u.expr);				      \
	  ffeste_f2c_compile_ ((Field), exq);				      \
	}								      \
    } while(0)

#define ffeste_f2c_compile_ptrtoint_(Field,Spec,Exp)			      \
  do									      \
    {									      \
      tree exq;								      \
      if (! (Exp))							      \
	{								      \
	  exq = ffecom_ptr_to_expr ((Spec)->u.expr);			      \
	  ffeste_f2c_compile_ ((Field), exq);				      \
	}								      \
    } while(0)

/* Start a Fortran block.  */

#ifdef ENABLE_CHECKING

typedef struct gbe_block
{
  struct gbe_block *outer;
  ffestw block;
  int lineno;
  char *input_filename;
  bool is_stmt;
} *gbe_block;

gbe_block ffeste_top_block_ = NULL;

static void
ffeste_start_block_ (ffestw block)
{
  gbe_block b = xmalloc (sizeof (*b));

  b->outer = ffeste_top_block_;
  b->block = block;
  b->lineno = lineno;
  b->input_filename = input_filename;
  b->is_stmt = FALSE;

  ffeste_top_block_ = b;

  ffecom_start_compstmt ();
}

/* End a Fortran block.  */

static void
ffeste_end_block_ (ffestw block)
{
  gbe_block b = ffeste_top_block_;

  assert (b);
  assert (! b->is_stmt);
  assert (b->block == block);
  assert (! b->is_stmt);

  ffeste_top_block_ = b->outer;

  free (b);

  clear_momentary ();

  ffecom_end_compstmt ();
}

/* Start a Fortran statement.

   Starts a back-end block, so temporaries can be managed, clean-ups
   properly handled, etc.  Nesting of statements *is* allowed -- the
   handling of I/O items, even implied-DO I/O lists, within a READ,
   PRINT, or WRITE statement is one example.  */

static void
ffeste_start_stmt_(void)
{
  gbe_block b = xmalloc (sizeof (*b));

  b->outer = ffeste_top_block_;
  b->block = NULL;
  b->lineno = lineno;
  b->input_filename = input_filename;
  b->is_stmt = TRUE;

  ffeste_top_block_ = b;

  ffecom_start_compstmt ();
}

/* End a Fortran statement.  */

static void
ffeste_end_stmt_(void)
{
  gbe_block b = ffeste_top_block_;

  assert (b);
  assert (b->is_stmt);

  ffeste_top_block_ = b->outer;

  free (b);

  clear_momentary ();

  ffecom_end_compstmt ();
}

#else  /* ! defined (ENABLE_CHECKING) */

#define ffeste_start_block_(b) ffecom_start_compstmt ()
#define ffeste_end_block_(b)	\
  do				\
    {				\
      clear_momentary ();	\
      ffecom_end_compstmt ();	\
    } while(0)
#define ffeste_start_stmt_() ffeste_start_block_(NULL)
#define ffeste_end_stmt_() ffeste_end_block_(NULL)

#endif  /* ! defined (ENABLE_CHECKING) */

/* Begin an iterative DO loop.  Pass the block to start if applicable.

   NOTE: Does _two_ push_momentary () calls, which the caller must
   undo (by calling ffeste_end_iterdo_).  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void
ffeste_begin_iterdo_ (ffestw block, tree *xtvar, tree *xtincr,
		      tree *xitersvar, ffebld var,
		      ffebld start, ffelexToken start_token,
		      ffebld end, ffelexToken end_token,
		      ffebld incr, ffelexToken incr_token,
		      const char *msg)
{
  tree tvar;
  tree expr;
  tree tstart;
  tree tend;
  tree tincr;
  tree tincr_saved;
  tree niters;
  struct nesting *expanded_loop;

  /* Want to have tvar, tincr, and niters for the whole loop body. */

  if (block)
    ffeste_start_block_ (block);
  else
    ffeste_start_stmt_ ();

  niters = ffecom_make_tempvar (block ? "do" : "impdo",
				ffecom_integer_type_node,
				FFETARGET_charactersizeNONE, -1);

  ffecom_prepare_expr (incr);
  ffecom_prepare_expr_rw (NULL_TREE, var);

  ffecom_prepare_end ();

  tvar = ffecom_expr_rw (NULL_TREE, var);
  tincr = ffecom_expr (incr);

  if (TREE_CODE (tvar) == ERROR_MARK
      || TREE_CODE (tincr) == ERROR_MARK)
    {
      if (block)
	{
	  ffeste_end_block_ (block);
	  ffestw_set_do_tvar (block, error_mark_node);
	}
      else
	{
	  ffeste_end_stmt_ ();
	  *xtvar = error_mark_node;
	}
      return;
    }

  /* Check whether incr is known to be zero, complain and fix.  */

  if (integer_zerop (tincr) || real_zerop (tincr))
    {
      ffebad_start (FFEBAD_DO_STEP_ZERO);
      ffebad_here (0, ffelex_token_where_line (incr_token),
		   ffelex_token_where_column (incr_token));
      ffebad_string (msg);
      ffebad_finish ();
      tincr = convert (TREE_TYPE (tvar), integer_one_node);
    }

  tincr_saved = ffecom_save_tree (tincr);

  preserve_momentary ();

  /* Want to have tstart, tend for just this statement. */

  ffeste_start_stmt_ ();

  ffecom_prepare_expr (start);
  ffecom_prepare_expr (end);

  ffecom_prepare_end ();

  tstart = ffecom_expr (start);
  tend = ffecom_expr (end);

  if (TREE_CODE (tstart) == ERROR_MARK
      || TREE_CODE (tend) == ERROR_MARK)
    {
      ffeste_end_stmt_ ();

      if (block)
	{
	  ffeste_end_block_ (block);
	  ffestw_set_do_tvar (block, error_mark_node);
	}
      else
	{
	  ffeste_end_stmt_ ();
	  *xtvar = error_mark_node;
	}
      return;
    }

  /* For warnings only, nothing else happens here.  */
  {
    tree try;

    if (! ffe_is_onetrip ())
      {
	try = ffecom_2 (MINUS_EXPR, TREE_TYPE (tvar),
			tend,
			tstart);

	try = ffecom_2 (PLUS_EXPR, TREE_TYPE (tvar),
			try,
			tincr);

	if (TREE_CODE (TREE_TYPE (tvar)) != REAL_TYPE)
	  try = ffecom_2 (TRUNC_DIV_EXPR, integer_type_node, try,
			  tincr);
	else
	  try = convert (integer_type_node,
			 ffecom_2 (RDIV_EXPR, TREE_TYPE (tvar),
				   try,
				   tincr));

	/* Warn if loop never executed, since we've done the evaluation
	   of the unofficial iteration count already.  */

	try = ffecom_truth_value (ffecom_2 (LE_EXPR, integer_type_node,
					    try,
					    convert (TREE_TYPE (tvar),
						     integer_zero_node)));

	if (integer_onep (try))
	  {
	    ffebad_start (FFEBAD_DO_NULL);
	    ffebad_here (0, ffelex_token_where_line (start_token),
			 ffelex_token_where_column (start_token));
	    ffebad_string (msg);
	    ffebad_finish ();
	  }
      }

    /* Warn if end plus incr would overflow.  */

    try = ffecom_2 (PLUS_EXPR, TREE_TYPE (tvar),
		    tend,
		    tincr);

    if ((TREE_CODE_CLASS (TREE_CODE (try)) == 'c')
	&& TREE_CONSTANT_OVERFLOW (try))
      {
	ffebad_start (FFEBAD_DO_END_OVERFLOW);
	ffebad_here (0, ffelex_token_where_line (end_token),
		     ffelex_token_where_column (end_token));
	ffebad_string (msg);
	ffebad_finish ();
      }
  }

  /* Do the initial assignment into the DO var.  */

  tstart = ffecom_save_tree (tstart);

  expr = ffecom_2 (MINUS_EXPR, TREE_TYPE (tvar),
		   tend,
		   tstart);

  if (! ffe_is_onetrip ())
    {
      expr = ffecom_2 (PLUS_EXPR, TREE_TYPE (expr),
		       expr,
		       convert (TREE_TYPE (expr), tincr_saved));
    }

  if (TREE_CODE (TREE_TYPE (tvar)) != REAL_TYPE)
    expr = ffecom_2 (TRUNC_DIV_EXPR, TREE_TYPE (expr),
		     expr,
		     tincr_saved);
  else
    expr = ffecom_2 (RDIV_EXPR, TREE_TYPE (expr),
		     expr,
		     tincr_saved);

#if 1	/* New, F90-approved approach: convert to default INTEGER. */
  if (TREE_TYPE (tvar) != error_mark_node)
    expr = convert (ffecom_integer_type_node, expr);
#else	/* Old approach; convert to INTEGER unless that's a narrowing. */
  if ((TREE_TYPE (tvar) != error_mark_node)
      && ((TREE_CODE (TREE_TYPE (tvar)) != INTEGER_TYPE)
	  || ((TYPE_SIZE (TREE_TYPE (tvar)) != NULL_TREE)
	      && ((TREE_CODE (TYPE_SIZE (TREE_TYPE (tvar)))
		   != INTEGER_CST)
		  || (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (tvar)))
		      <= TREE_INT_CST_LOW (TYPE_SIZE (ffecom_integer_type_node)))))))
    /* Convert unless promoting INTEGER type of any kind downward to
       default INTEGER; else leave as, say, INTEGER*8 (long long int).  */
    expr = convert (ffecom_integer_type_node, expr);
#endif

  assert (TYPE_MAIN_VARIANT (TREE_TYPE (niters))
	  == TYPE_MAIN_VARIANT (TREE_TYPE (expr)));

  expr = ffecom_modify (void_type_node, niters, expr);
  expand_expr_stmt (expr);

  expr = ffecom_modify (void_type_node, tvar, tstart);
  expand_expr_stmt (expr);

  ffeste_end_stmt_ ();

  expanded_loop = expand_start_loop_continue_elsewhere (!! block);
  if (block)
    ffestw_set_do_hook (block, expanded_loop);

  if (! ffe_is_onetrip ())
    {
      expr = ffecom_truth_value
	(ffecom_2 (GE_EXPR, integer_type_node,
		   ffecom_2 (PREDECREMENT_EXPR,
			     TREE_TYPE (niters),
			     niters,
			     convert (TREE_TYPE (niters),
				      ffecom_integer_one_node)),
		   convert (TREE_TYPE (niters),
			    ffecom_integer_zero_node)));

      expand_exit_loop_if_false (0, expr);
    }

  if (block)
    {
      ffestw_set_do_tvar (block, tvar);
      ffestw_set_do_incr_saved (block, tincr_saved);
      ffestw_set_do_count_var (block, niters);
    }
  else
    {
      *xtvar = tvar;
      *xtincr = tincr_saved;
      *xitersvar = niters;
    }
}

#endif

/* End an iterative DO loop.  Pass the same iteration variable and increment
   value trees that were generated in the paired _begin_ call.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void
ffeste_end_iterdo_ (ffestw block, tree tvar, tree tincr, tree itersvar)
{
  tree expr;
  tree niters = itersvar;

  if (tvar == error_mark_node)
    return;

  expand_loop_continue_here ();

  ffeste_start_stmt_ ();

  if (ffe_is_onetrip ())
    {
      expr = ffecom_truth_value
	(ffecom_2 (GE_EXPR, integer_type_node,
		   ffecom_2 (PREDECREMENT_EXPR,
			     TREE_TYPE (niters),
			     niters,
			     convert (TREE_TYPE (niters),
				      ffecom_integer_one_node)),
		   convert (TREE_TYPE (niters),
			    ffecom_integer_zero_node)));

      expand_exit_loop_if_false (0, expr);
    }

  expr = ffecom_modify (void_type_node, tvar,
			ffecom_2 (PLUS_EXPR, TREE_TYPE (tvar),
				  tvar,
				  tincr));
  expand_expr_stmt (expr);

  /* Lose the stuff we just built. */
  ffeste_end_stmt_ ();

  expand_end_loop ();

  /* Lose the tvar and incr_saved trees. */
  if (block)
    ffeste_end_block_ (block);
  else
    ffeste_end_stmt_ ();
}
#endif

/* Generate call to run-time I/O routine.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void
ffeste_io_call_ (tree call, bool do_check)
{
  /* Generate the call and optional assignment into iostat var. */

  TREE_SIDE_EFFECTS (call) = 1;
  if (ffeste_io_iostat_ != NULL_TREE)
    call = ffecom_modify (do_check ? NULL_TREE : void_type_node,
			  ffeste_io_iostat_, call);
  expand_expr_stmt (call);

  if (! do_check
      || ffeste_io_abort_ == NULL_TREE
      || TREE_CODE (ffeste_io_abort_) == ERROR_MARK)
    return;

  /* Generate optional test. */

  expand_start_cond (ffecom_truth_value (ffeste_io_iostat_), 0);
  expand_goto (ffeste_io_abort_);
  expand_end_cond ();
}
#endif

/* Handle implied-DO in I/O list.

   Expands code to start up the DO loop.  Then for each item in the
   DO loop, handles appropriately (possibly including recursively calling
   itself).  Then expands code to end the DO loop.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void
ffeste_io_impdo_ (ffebld impdo, ffelexToken impdo_token)
{
  ffebld var = ffebld_head (ffebld_right (impdo));
  ffebld start = ffebld_head (ffebld_trail (ffebld_right (impdo)));
  ffebld end = ffebld_head (ffebld_trail (ffebld_trail
					  (ffebld_right (impdo))));
  ffebld incr = ffebld_head (ffebld_trail (ffebld_trail
				    (ffebld_trail (ffebld_right (impdo)))));
  ffebld list;
  ffebld item;
  tree tvar;
  tree tincr;
  tree titervar;

  if (incr == NULL)
    {
      incr = ffebld_new_conter (ffebld_constant_new_integerdefault_val (1));
      ffebld_set_info (incr, ffeinfo_new
		       (FFEINFO_basictypeINTEGER,
			FFEINFO_kindtypeINTEGERDEFAULT,
			0,
			FFEINFO_kindENTITY,
			FFEINFO_whereCONSTANT,
			FFETARGET_charactersizeNONE));
    }

  /* Start the DO loop.  */

  start = ffeexpr_convert_expr (start, impdo_token, var, impdo_token,
				FFEEXPR_contextLET);
  end = ffeexpr_convert_expr (end, impdo_token, var, impdo_token,
			      FFEEXPR_contextLET);
  incr = ffeexpr_convert_expr (incr, impdo_token, var, impdo_token,
			       FFEEXPR_contextLET);

  ffeste_begin_iterdo_ (NULL, &tvar, &tincr, &titervar, var,
			start, impdo_token,
			end, impdo_token,
			incr, impdo_token,
			"Implied DO loop");

  /* Handle the list of items.  */

  for (list = ffebld_left (impdo); list != NULL; list = ffebld_trail (list))
    {
      item = ffebld_head (list);
      if (item == NULL)
	continue;

      /* Strip parens off items such as in "READ *,(A)".  This is really a bug
	 in the user's code, but I've been told lots of code does this.  */
      while (ffebld_op (item) == FFEBLD_opPAREN)
	item = ffebld_left (item);

      if (ffebld_op (item) == FFEBLD_opANY)
	continue;

      if (ffebld_op (item) == FFEBLD_opIMPDO)
	ffeste_io_impdo_ (item, impdo_token);
      else
	{
	  ffeste_start_stmt_ ();

	  ffecom_prepare_arg_ptr_to_expr (item);

	  ffecom_prepare_end ();

	  ffeste_io_call_ ((*ffeste_io_driver_) (item), TRUE);

	  ffeste_end_stmt_ ();
	}
    }

  /* Generate end of implied-do construct. */

  ffeste_end_iterdo_ (NULL, tvar, tincr, titervar);
}
#endif

/* I/O driver for formatted I/O item (do_fio)

   Returns a tree for a CALL_EXPR to the do_fio function, which handles
   a formatted I/O list item, along with the appropriate arguments for
   the function.  It is up to the caller to set the TREE_SIDE_EFFECTS flag
   for the CALL_EXPR, expand (emit) the expression, emit any assignment
   of the result to an IOSTAT= variable, and emit any checking of the
   result for errors.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_dofio_ (ffebld expr)
{
  tree num_elements;
  tree variable;
  tree size;
  tree arglist;
  ffeinfoBasictype bt;
  ffeinfoKindtype kt;
  bool is_complex;

  bt = ffeinfo_basictype (ffebld_info (expr));
  kt = ffeinfo_kindtype (ffebld_info (expr));

  if ((bt == FFEINFO_basictypeANY)
      || (kt == FFEINFO_kindtypeANY))
    return error_mark_node;

  if (bt == FFEINFO_basictypeCOMPLEX)
    {
      is_complex = TRUE;
      bt = FFEINFO_basictypeREAL;
    }
  else
    is_complex = FALSE;

  variable = ffecom_arg_ptr_to_expr (expr, &size);

  if ((variable == error_mark_node)
      || (size == error_mark_node))
    return error_mark_node;

  if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
    {				/* "(ftnlen) sizeof(type)" */
      size = size_binop (CEIL_DIV_EXPR,
			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
			 size_int (TYPE_PRECISION (char_type_node)));
#if 0	/* Assume that while it is possible that char * is wider than
	   ftnlen, no object in Fortran space can get big enough for its
	   size to be wider than ftnlen.  I really hope nobody wastes
	   time debugging a case where it can!  */
      assert (TYPE_PRECISION (ffecom_f2c_ftnlen_type_node)
	      >= TYPE_PRECISION (TREE_TYPE (size)));
#endif
      size = convert (ffecom_f2c_ftnlen_type_node, size);
    }

  if (ffeinfo_rank (ffebld_info (expr)) == 0
      || TREE_CODE (TREE_TYPE (TREE_TYPE (variable))) != ARRAY_TYPE)
    num_elements
      = is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
  else
    {
      num_elements = size_binop (CEIL_DIV_EXPR,
				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
				 size);
      num_elements = size_binop (CEIL_DIV_EXPR,
				 num_elements,
				 size_int (TYPE_PRECISION
					   (char_type_node)));
      num_elements = convert (ffecom_f2c_ftnlen_type_node,
			      num_elements);
    }

  num_elements
    = ffecom_1 (ADDR_EXPR, ffecom_f2c_ptr_to_ftnlen_type_node,
		num_elements);

  variable = convert (string_type_node, variable);

  arglist = build_tree_list (NULL_TREE, num_elements);
  TREE_CHAIN (arglist) = build_tree_list (NULL_TREE, variable);
  TREE_CHAIN (TREE_CHAIN (arglist)) = build_tree_list (NULL_TREE, size);

  return ffecom_call_gfrt (FFECOM_gfrtDOFIO, arglist, NULL_TREE);
}

#endif
/* I/O driver for list-directed I/O item (do_lio)

   Returns a tree for a CALL_EXPR to the do_lio function, which handles
   a list-directed I/O list item, along with the appropriate arguments for
   the function.  It is up to the caller to set the TREE_SIDE_EFFECTS flag
   for the CALL_EXPR, expand (emit) the expression, emit any assignment
   of the result to an IOSTAT= variable, and emit any checking of the
   result for errors.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_dolio_ (ffebld expr)
{
  tree type_id;
  tree num_elements;
  tree variable;
  tree size;
  tree arglist;
  ffeinfoBasictype bt;
  ffeinfoKindtype kt;
  int tc;

  bt = ffeinfo_basictype (ffebld_info (expr));
  kt = ffeinfo_kindtype (ffebld_info (expr));

  if ((bt == FFEINFO_basictypeANY)
      || (kt == FFEINFO_kindtypeANY))
    return error_mark_node;

  tc = ffecom_f2c_typecode (bt, kt);
  assert (tc != -1);
  type_id = build_int_2 (tc, 0);

  type_id
    = ffecom_1 (ADDR_EXPR, ffecom_f2c_ptr_to_ftnint_type_node,
		convert (ffecom_f2c_ftnint_type_node,
			 type_id));

  variable = ffecom_arg_ptr_to_expr (expr, &size);

  if ((type_id == error_mark_node)
      || (variable == error_mark_node)
      || (size == error_mark_node))
    return error_mark_node;

  if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
    {				/* "(ftnlen) sizeof(type)" */
      size = size_binop (CEIL_DIV_EXPR,
			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
			 size_int (TYPE_PRECISION (char_type_node)));
#if 0	/* Assume that while it is possible that char * is wider than
	   ftnlen, no object in Fortran space can get big enough for its
	   size to be wider than ftnlen.  I really hope nobody wastes
	   time debugging a case where it can!  */
      assert (TYPE_PRECISION (ffecom_f2c_ftnlen_type_node)
	      >= TYPE_PRECISION (TREE_TYPE (size)));
#endif
      size = convert (ffecom_f2c_ftnlen_type_node, size);
    }

  if (ffeinfo_rank (ffebld_info (expr)) == 0
      || TREE_CODE (TREE_TYPE (TREE_TYPE (variable))) != ARRAY_TYPE)
    num_elements = ffecom_integer_one_node;
  else
    {
      num_elements = size_binop (CEIL_DIV_EXPR,
				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
				 size);
      num_elements = size_binop (CEIL_DIV_EXPR,
				 num_elements,
				 size_int (TYPE_PRECISION
					   (char_type_node)));
      num_elements = convert (ffecom_f2c_ftnlen_type_node,
			      num_elements);
    }

  num_elements
    = ffecom_1 (ADDR_EXPR, ffecom_f2c_ptr_to_ftnlen_type_node,
		num_elements);

  variable = convert (string_type_node, variable);

  arglist = build_tree_list (NULL_TREE, type_id);
  TREE_CHAIN (arglist) = build_tree_list (NULL_TREE, num_elements);
  TREE_CHAIN (TREE_CHAIN (arglist)) = build_tree_list (NULL_TREE, variable);
  TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (arglist)))
    = build_tree_list (NULL_TREE, size);

  return ffecom_call_gfrt (FFECOM_gfrtDOLIO, arglist, NULL_TREE);
}

#endif
/* I/O driver for unformatted I/O item (do_uio)

   Returns a tree for a CALL_EXPR to the do_uio function, which handles
   an unformatted I/O list item, along with the appropriate arguments for
   the function.  It is up to the caller to set the TREE_SIDE_EFFECTS flag
   for the CALL_EXPR, expand (emit) the expression, emit any assignment
   of the result to an IOSTAT= variable, and emit any checking of the
   result for errors.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_douio_ (ffebld expr)
{
  tree num_elements;
  tree variable;
  tree size;
  tree arglist;
  ffeinfoBasictype bt;
  ffeinfoKindtype kt;
  bool is_complex;

  bt = ffeinfo_basictype (ffebld_info (expr));
  kt = ffeinfo_kindtype (ffebld_info (expr));

  if ((bt == FFEINFO_basictypeANY)
      || (kt == FFEINFO_kindtypeANY))
    return error_mark_node;

  if (bt == FFEINFO_basictypeCOMPLEX)
    {
      is_complex = TRUE;
      bt = FFEINFO_basictypeREAL;
    }
  else
    is_complex = FALSE;

  variable = ffecom_arg_ptr_to_expr (expr, &size);

  if ((variable == error_mark_node)
      || (size == error_mark_node))
    return error_mark_node;

  if (size == NULL_TREE)	/* Already filled in for CHARACTER type. */
    {				/* "(ftnlen) sizeof(type)" */
      size = size_binop (CEIL_DIV_EXPR,
			 TYPE_SIZE (ffecom_tree_type[bt][kt]),
			 size_int (TYPE_PRECISION (char_type_node)));
#if 0	/* Assume that while it is possible that char * is wider than
	   ftnlen, no object in Fortran space can get big enough for its
	   size to be wider than ftnlen.  I really hope nobody wastes
	   time debugging a case where it can!  */
      assert (TYPE_PRECISION (ffecom_f2c_ftnlen_type_node)
	      >= TYPE_PRECISION (TREE_TYPE (size)));
#endif
      size = convert (ffecom_f2c_ftnlen_type_node, size);
    }

  if (ffeinfo_rank (ffebld_info (expr)) == 0
      || TREE_CODE (TREE_TYPE (TREE_TYPE (variable))) != ARRAY_TYPE)
    num_elements
      = is_complex ? ffecom_f2c_ftnlen_two_node : ffecom_f2c_ftnlen_one_node;
  else
    {
      num_elements = size_binop (CEIL_DIV_EXPR,
				 TYPE_SIZE (TREE_TYPE (TREE_TYPE (variable))),
				 size);
      num_elements = size_binop (CEIL_DIV_EXPR, num_elements,
				 size_int (TYPE_PRECISION
					   (char_type_node)));
      num_elements = convert (ffecom_f2c_ftnlen_type_node,
			      num_elements);
    }

  num_elements
    = ffecom_1 (ADDR_EXPR, ffecom_f2c_ptr_to_ftnlen_type_node,
		num_elements);

  variable = convert (string_type_node, variable);

  arglist = build_tree_list (NULL_TREE, num_elements);
  TREE_CHAIN (arglist) = build_tree_list (NULL_TREE, variable);
  TREE_CHAIN (TREE_CHAIN (arglist)) = build_tree_list (NULL_TREE, size);

  return ffecom_call_gfrt (FFECOM_gfrtDOUIO, arglist, NULL_TREE);
}

#endif
/* Make arglist with ptr to BACKSPACE/ENDFILE/REWIND control list.

   Returns a tree suitable as an argument list containing a pointer to
   a BACKSPACE/ENDFILE/REWIND control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_ialist_ (bool have_err,
		   ffestvUnit unit,
		   ffebld unit_expr,
		   int unit_dflt)
{
  static tree f2c_alist_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  bool constantp = TRUE;
  static tree errfield, unitfield;
  tree errinit, unitinit;
  tree unitexp;
  static int mynumber = 0;

  if (f2c_alist_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     ffecom_f2c_ftnint_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_alist_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);

  switch (unit)
    {
    case FFESTV_unitNONE:
    case FFESTV_unitASTERISK:
      unitinit = build_int_2 (unit_dflt, 0);
      unitexp = unitinit;
      break;

    case FFESTV_unitINTEXPR:
      unitexp = ffecom_const_expr (unit_expr);
      if (unitexp)
	unitinit = unitexp;
      else
	{
	  unitinit = ffecom_integer_zero_node;
	  constantp = FALSE;
	}
      break;

    default:
      assert ("bad unit spec" == NULL);
      unitinit = ffecom_integer_zero_node;
      unitexp = unitinit;
      break;
    }

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_alist_struct)), errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);

  inits = build (CONSTRUCTOR, f2c_alist_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_alist_%d", NULL,
						  mynumber++),
		  f2c_alist_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  if (! unitexp)
    ffecom_prepare_expr (unit_expr);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  if (! unitexp)
    {
      unitexp = ffecom_expr (unit_expr);
      ffeste_f2c_compile_ (unitfield, unitexp);
    }

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}

#endif
/* Make arglist with ptr to external-I/O control list.

   Returns a tree suitable as an argument list containing a pointer to
   an external-I/O control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_cilist_ (bool have_err,
		   ffestvUnit unit,
		   ffebld unit_expr,
		   int unit_dflt,
		   bool have_end,
		   ffestvFormat format,
		   ffestpFile *format_spec,
		   bool rec,
		   ffebld rec_expr)
{
  static tree f2c_cilist_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  bool constantp = TRUE;
  static tree errfield, unitfield, endfield, formatfield, recfield;
  tree errinit, unitinit, endinit, formatinit, recinit;
  tree unitexp, formatexp, recexp;
  static int mynumber = 0;

  if (f2c_cilist_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     ffecom_f2c_ftnint_type_node);
      endfield = ffecom_decl_field (ref, unitfield, "end",
				    ffecom_f2c_flag_type_node);
      formatfield = ffecom_decl_field (ref, endfield, "format",
				       string_type_node);
      recfield = ffecom_decl_field (ref, formatfield, "rec",
				    ffecom_f2c_ftnint_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_cilist_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);

  switch (unit)
    {
    case FFESTV_unitNONE:
    case FFESTV_unitASTERISK:
      unitinit = build_int_2 (unit_dflt, 0);
      unitexp = unitinit;
      break;

    case FFESTV_unitINTEXPR:
      unitexp = ffecom_const_expr (unit_expr);
      if (unitexp)
	unitinit = unitexp;
      else
	{
	  unitinit = ffecom_integer_zero_node;
	  constantp = FALSE;
	}
      break;

    default:
      assert ("bad unit spec" == NULL);
      unitinit = ffecom_integer_zero_node;
      unitexp = unitinit;
      break;
    }

  switch (format)
    {
    case FFESTV_formatNONE:
      formatinit = null_pointer_node;
      formatexp = formatinit;
      break;

    case FFESTV_formatLABEL:
      formatexp = error_mark_node;
      formatinit = ffecom_lookup_label (format_spec->u.label);
      if ((formatinit == NULL_TREE)
	  || (TREE_CODE (formatinit) == ERROR_MARK))
	break;
      formatinit = ffecom_1 (ADDR_EXPR,
			     build_pointer_type (void_type_node),
			     formatinit);
      TREE_CONSTANT (formatinit) = 1;
      break;

    case FFESTV_formatCHAREXPR:
      formatexp = ffecom_arg_ptr_to_const_expr (format_spec->u.expr, NULL);
      if (formatexp)
	formatinit = formatexp;
      else
	{
	  formatinit = null_pointer_node;
	  constantp = FALSE;
	}
      break;

    case FFESTV_formatASTERISK:
      formatinit = null_pointer_node;
      formatexp = formatinit;
      break;

    case FFESTV_formatINTEXPR:
      formatinit = null_pointer_node;
      formatexp = ffecom_expr_assign (format_spec->u.expr);
      if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (formatexp)))
	  < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (null_pointer_node))))
	error ("ASSIGNed FORMAT specifier is too small");
      formatexp = convert (string_type_node, formatexp);
      break;

    case FFESTV_formatNAMELIST:
      formatinit = ffecom_expr (format_spec->u.expr);
      formatexp = formatinit;
      break;

    default:
      assert ("bad format spec" == NULL);
      formatinit = integer_zero_node;
      formatexp = formatinit;
      break;
    }

  ffeste_f2c_init_flag_ (have_end, endinit);

  if (rec)
    recexp = ffecom_const_expr (rec_expr);
  else
    recexp = ffecom_integer_zero_node;
  if (recexp)
    recinit = recexp;
  else
    {
      recinit = ffecom_integer_zero_node;
      constantp = FALSE;
    }

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_cilist_struct)), errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);
  ffeste_f2c_init_next_ (endinit);
  ffeste_f2c_init_next_ (formatinit);
  ffeste_f2c_init_next_ (recinit);

  inits = build (CONSTRUCTOR, f2c_cilist_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_cilist_%d", NULL,
						  mynumber++),
		  f2c_cilist_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  if (! unitexp)
    ffecom_prepare_expr (unit_expr);

  if (! formatexp)
    ffecom_prepare_arg_ptr_to_expr (format_spec->u.expr);

  if (! recexp)
    ffecom_prepare_expr (rec_expr);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  if (! unitexp)
    {
      unitexp = ffecom_expr (unit_expr);
      ffeste_f2c_compile_ (unitfield, unitexp);
    }

  if (! formatexp)
    {
      formatexp = ffecom_arg_ptr_to_expr (format_spec->u.expr, NULL);
      ffeste_f2c_compile_ (formatfield, formatexp);
    }
  else if (format == FFESTV_formatINTEXPR)
    ffeste_f2c_compile_ (formatfield, formatexp);

  if (! recexp)
    {
      recexp = ffecom_expr (rec_expr);
      ffeste_f2c_compile_ (recfield, recexp);
    }

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}

#endif
/* Make arglist with ptr to CLOSE control list.

   Returns a tree suitable as an argument list containing a pointer to
   a CLOSE-statement control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_cllist_ (bool have_err,
		   ffebld unit_expr,
		   ffestpFile *stat_spec)
{
  static tree f2c_close_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  tree ignore;			/* Ignore length info for certain fields. */
  bool constantp = TRUE;
  static tree errfield, unitfield, statfield;
  tree errinit, unitinit, statinit;
  tree unitexp, statexp;
  static int mynumber = 0;

  if (f2c_close_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     ffecom_f2c_ftnint_type_node);
      statfield = ffecom_decl_field (ref, unitfield, "stat",
				     string_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_close_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);

  unitexp = ffecom_const_expr (unit_expr);
  if (unitexp)
    unitinit = unitexp;
  else
    {
      unitinit = ffecom_integer_zero_node;
      constantp = FALSE;
    }

  ffeste_f2c_init_charnolen_ (statexp, statinit, stat_spec);

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_close_struct)), errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);
  ffeste_f2c_init_next_ (statinit);

  inits = build (CONSTRUCTOR, f2c_close_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_cllist_%d", NULL,
						  mynumber++),
		  f2c_close_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  if (! unitexp)
    ffecom_prepare_expr (unit_expr);

  if (! statexp)
    ffecom_prepare_arg_ptr_to_expr (stat_spec->u.expr);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  if (! unitexp)
    {
      unitexp = ffecom_expr (unit_expr);
      ffeste_f2c_compile_ (unitfield, unitexp);
    }

  ffeste_f2c_compile_charnolen_ (statfield, stat_spec, statexp);

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}

#endif
/* Make arglist with ptr to internal-I/O control list.

   Returns a tree suitable as an argument list containing a pointer to
   an internal-I/O control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_icilist_ (bool have_err,
		    ffebld unit_expr,
		    bool have_end,
		    ffestvFormat format,
		    ffestpFile *format_spec)
{
  static tree f2c_icilist_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  bool constantp = TRUE;
  static tree errfield, unitfield, endfield, formatfield, unitlenfield,
    unitnumfield;
  tree errinit, unitinit, endinit, formatinit, unitleninit, unitnuminit;
  tree unitexp, formatexp, unitlenexp, unitnumexp;
  static int mynumber = 0;

  if (f2c_icilist_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     string_type_node);
      endfield = ffecom_decl_field (ref, unitfield, "end",
				    ffecom_f2c_flag_type_node);
      formatfield = ffecom_decl_field (ref, endfield, "format",
				       string_type_node);
      unitlenfield = ffecom_decl_field (ref, formatfield, "unitlen",
					ffecom_f2c_ftnint_type_node);
      unitnumfield = ffecom_decl_field (ref, unitlenfield, "unitnum",
					ffecom_f2c_ftnint_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_icilist_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);

  unitexp = ffecom_arg_ptr_to_const_expr (unit_expr, &unitlenexp);
  if (unitexp)
    unitinit = unitexp;
  else
    {
      unitinit = null_pointer_node;
      constantp = FALSE;
    }
  if (unitlenexp)
    unitleninit = unitlenexp;
  else
    {
      unitleninit = ffecom_integer_zero_node;
      constantp = FALSE;
    }

  /* Now see if we can fully initialize the number of elements, or
     if we have to compute that at run time.  */
  if (ffeinfo_rank (ffebld_info (unit_expr)) == 0
      || (unitexp
	  && TREE_CODE (TREE_TYPE (TREE_TYPE (unitexp))) != ARRAY_TYPE))
    {
      /* Not an array, so just one element.  */
      unitnuminit = ffecom_integer_one_node;
      unitnumexp = unitnuminit;
    }
  else if (unitexp && unitlenexp)
    {
      /* An array, but all the info is constant, so compute now.  */
      unitnuminit = size_binop (CEIL_DIV_EXPR,
				TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
				unitlenexp);
      unitnuminit = size_binop (CEIL_DIV_EXPR,
				unitnuminit,
				size_int (TYPE_PRECISION
					  (char_type_node)));
      unitnumexp = unitnuminit;
    }
  else
    {
      /* Put off computing until run time.  */
      unitnuminit = ffecom_integer_zero_node;
      unitnumexp = NULL_TREE;
      constantp = FALSE;
    }

  switch (format)
    {
    case FFESTV_formatNONE:
      formatinit = null_pointer_node;
      formatexp = formatinit;
      break;

    case FFESTV_formatLABEL:
      formatexp = error_mark_node;
      formatinit = ffecom_lookup_label (format_spec->u.label);
      if ((formatinit == NULL_TREE)
	  || (TREE_CODE (formatinit) == ERROR_MARK))
	break;
      formatinit = ffecom_1 (ADDR_EXPR,
			     build_pointer_type (void_type_node),
			     formatinit);
      TREE_CONSTANT (formatinit) = 1;
      break;

    case FFESTV_formatCHAREXPR:
      ffeste_f2c_init_format_ (formatexp, formatinit, format_spec);
      break;

    case FFESTV_formatASTERISK:
      formatinit = null_pointer_node;
      formatexp = formatinit;
      break;

    case FFESTV_formatINTEXPR:
      formatinit = null_pointer_node;
      formatexp = ffecom_expr_assign (format_spec->u.expr);
      if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (formatexp)))
	  < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (null_pointer_node))))
	error ("ASSIGNed FORMAT specifier is too small");
      formatexp = convert (string_type_node, formatexp);
      break;

    default:
      assert ("bad format spec" == NULL);
      formatinit = ffecom_integer_zero_node;
      formatexp = formatinit;
      break;
    }

  ffeste_f2c_init_flag_ (have_end, endinit);

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_icilist_struct)),
			   errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);
  ffeste_f2c_init_next_ (endinit);
  ffeste_f2c_init_next_ (formatinit);
  ffeste_f2c_init_next_ (unitleninit);
  ffeste_f2c_init_next_ (unitnuminit);

  inits = build (CONSTRUCTOR, f2c_icilist_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_icilist_%d", NULL,
						  mynumber++),
		  f2c_icilist_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  if (! unitexp)
    ffecom_prepare_arg_ptr_to_expr (unit_expr);

  ffeste_f2c_prepare_format_ (format_spec, formatexp);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  if (! unitexp || ! unitlenexp)
    {
      int need_unitexp = (! unitexp);
      int need_unitlenexp = (! unitlenexp);
 
      unitexp = ffecom_arg_ptr_to_expr (unit_expr, &unitlenexp);
      if (need_unitexp)
	ffeste_f2c_compile_ (unitfield, unitexp);
      if (need_unitlenexp)
	ffeste_f2c_compile_ (unitlenfield, unitlenexp);
    }

  if (! unitnumexp
      && unitexp != error_mark_node
      && unitlenexp != error_mark_node)
    {
      unitnumexp = size_binop (CEIL_DIV_EXPR,
			       TYPE_SIZE (TREE_TYPE (TREE_TYPE (unitexp))),
			       unitlenexp);
      unitnumexp = size_binop (CEIL_DIV_EXPR,
			       unitnumexp,
			       size_int (TYPE_PRECISION
					 (char_type_node)));
      ffeste_f2c_compile_ (unitnumfield, unitnumexp);
    }

  if (format == FFESTV_formatINTEXPR)
    ffeste_f2c_compile_ (formatfield, formatexp);
  else
    ffeste_f2c_compile_format_ (formatfield, format_spec, formatexp);

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}
#endif

/* Make arglist with ptr to INQUIRE control list

   Returns a tree suitable as an argument list containing a pointer to
   an INQUIRE-statement control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_inlist_ (bool have_err,
		   ffestpFile *unit_spec,
		   ffestpFile *file_spec,
		   ffestpFile *exist_spec,
		   ffestpFile *open_spec,
		   ffestpFile *number_spec,
		   ffestpFile *named_spec,
		   ffestpFile *name_spec,
		   ffestpFile *access_spec,
		   ffestpFile *sequential_spec,
		   ffestpFile *direct_spec,
		   ffestpFile *form_spec,
		   ffestpFile *formatted_spec,
		   ffestpFile *unformatted_spec,
		   ffestpFile *recl_spec,
		   ffestpFile *nextrec_spec,
		   ffestpFile *blank_spec)
{
  static tree f2c_inquire_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  bool constantp = TRUE;
  static tree errfield, unitfield, filefield, filelenfield, existfield,
    openfield, numberfield, namedfield, namefield, namelenfield, accessfield,
    accesslenfield, sequentialfield, sequentiallenfield, directfield, directlenfield,
    formfield, formlenfield, formattedfield, formattedlenfield, unformattedfield,
    unformattedlenfield, reclfield, nextrecfield, blankfield, blanklenfield;
  tree errinit, unitinit, fileinit, fileleninit, existinit, openinit, numberinit,
    namedinit, nameinit, nameleninit, accessinit, accessleninit, sequentialinit,
    sequentialleninit, directinit, directleninit, forminit, formleninit,
    formattedinit, formattedleninit, unformattedinit, unformattedleninit,
    reclinit, nextrecinit, blankinit, blankleninit;
  tree
    unitexp, fileexp, filelenexp, existexp, openexp, numberexp, namedexp,
    nameexp, namelenexp, accessexp, accesslenexp, sequentialexp, sequentiallenexp,
    directexp, directlenexp, formexp, formlenexp, formattedexp, formattedlenexp,
    unformattedexp, unformattedlenexp, reclexp, nextrecexp, blankexp, blanklenexp;
  static int mynumber = 0;

  if (f2c_inquire_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     ffecom_f2c_ftnint_type_node);
      filefield = ffecom_decl_field (ref, unitfield, "file",
				     string_type_node);
      filelenfield = ffecom_decl_field (ref, filefield, "filelen",
					ffecom_f2c_ftnlen_type_node);
      existfield = ffecom_decl_field (ref, filelenfield, "exist",
				      ffecom_f2c_ptr_to_ftnint_type_node);
      openfield = ffecom_decl_field (ref, existfield, "open",
				     ffecom_f2c_ptr_to_ftnint_type_node);
      numberfield = ffecom_decl_field (ref, openfield, "number",
				       ffecom_f2c_ptr_to_ftnint_type_node);
      namedfield = ffecom_decl_field (ref, numberfield, "named",
				      ffecom_f2c_ptr_to_ftnint_type_node);
      namefield = ffecom_decl_field (ref, namedfield, "name",
				     string_type_node);
      namelenfield = ffecom_decl_field (ref, namefield, "namelen",
					ffecom_f2c_ftnlen_type_node);
      accessfield = ffecom_decl_field (ref, namelenfield, "access",
				       string_type_node);
      accesslenfield = ffecom_decl_field (ref, accessfield, "accesslen",
					  ffecom_f2c_ftnlen_type_node);
      sequentialfield = ffecom_decl_field (ref, accesslenfield, "sequential",
					   string_type_node);
      sequentiallenfield = ffecom_decl_field (ref, sequentialfield,
					      "sequentiallen",
					      ffecom_f2c_ftnlen_type_node);
      directfield = ffecom_decl_field (ref, sequentiallenfield, "direct",
				       string_type_node);
      directlenfield = ffecom_decl_field (ref, directfield, "directlen",
					  ffecom_f2c_ftnlen_type_node);
      formfield = ffecom_decl_field (ref, directlenfield, "form",
				     string_type_node);
      formlenfield = ffecom_decl_field (ref, formfield, "formlen",
					ffecom_f2c_ftnlen_type_node);
      formattedfield = ffecom_decl_field (ref, formlenfield, "formatted",
					  string_type_node);
      formattedlenfield = ffecom_decl_field (ref, formattedfield,
					     "formattedlen",
					     ffecom_f2c_ftnlen_type_node);
      unformattedfield = ffecom_decl_field (ref, formattedlenfield,
					    "unformatted",
					    string_type_node);
      unformattedlenfield = ffecom_decl_field (ref, unformattedfield,
					       "unformattedlen",
					       ffecom_f2c_ftnlen_type_node);
      reclfield = ffecom_decl_field (ref, unformattedlenfield, "recl",
				     ffecom_f2c_ptr_to_ftnint_type_node);
      nextrecfield = ffecom_decl_field (ref, reclfield, "nextrec",
					ffecom_f2c_ptr_to_ftnint_type_node);
      blankfield = ffecom_decl_field (ref, nextrecfield, "blank",
				      string_type_node);
      blanklenfield = ffecom_decl_field (ref, blankfield, "blanklen",
					 ffecom_f2c_ftnlen_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_inquire_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);
  ffeste_f2c_init_int_ (unitexp, unitinit, unit_spec);
  ffeste_f2c_init_char_ (fileexp, fileinit, filelenexp, fileleninit,
			 file_spec);
  ffeste_f2c_init_ptrtoint_ (existexp, existinit, exist_spec);
  ffeste_f2c_init_ptrtoint_ (openexp, openinit, open_spec);
  ffeste_f2c_init_ptrtoint_ (numberexp, numberinit, number_spec);
  ffeste_f2c_init_ptrtoint_ (namedexp, namedinit, named_spec);
  ffeste_f2c_init_char_ (nameexp, nameinit, namelenexp, nameleninit,
			 name_spec);
  ffeste_f2c_init_char_ (accessexp, accessinit, accesslenexp,
			 accessleninit, access_spec);
  ffeste_f2c_init_char_ (sequentialexp, sequentialinit, sequentiallenexp,
			 sequentialleninit, sequential_spec);
  ffeste_f2c_init_char_ (directexp, directinit, directlenexp,
			 directleninit, direct_spec);
  ffeste_f2c_init_char_ (formexp, forminit, formlenexp, formleninit,
			 form_spec);
  ffeste_f2c_init_char_ (formattedexp, formattedinit,
			 formattedlenexp, formattedleninit, formatted_spec);
  ffeste_f2c_init_char_ (unformattedexp, unformattedinit, unformattedlenexp,
			 unformattedleninit, unformatted_spec);
  ffeste_f2c_init_ptrtoint_ (reclexp, reclinit, recl_spec);
  ffeste_f2c_init_ptrtoint_ (nextrecexp, nextrecinit, nextrec_spec);
  ffeste_f2c_init_char_ (blankexp, blankinit, blanklenexp,
			 blankleninit, blank_spec);

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_inquire_struct)),
			   errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);
  ffeste_f2c_init_next_ (fileinit);
  ffeste_f2c_init_next_ (fileleninit);
  ffeste_f2c_init_next_ (existinit);
  ffeste_f2c_init_next_ (openinit);
  ffeste_f2c_init_next_ (numberinit);
  ffeste_f2c_init_next_ (namedinit);
  ffeste_f2c_init_next_ (nameinit);
  ffeste_f2c_init_next_ (nameleninit);
  ffeste_f2c_init_next_ (accessinit);
  ffeste_f2c_init_next_ (accessleninit);
  ffeste_f2c_init_next_ (sequentialinit);
  ffeste_f2c_init_next_ (sequentialleninit);
  ffeste_f2c_init_next_ (directinit);
  ffeste_f2c_init_next_ (directleninit);
  ffeste_f2c_init_next_ (forminit);
  ffeste_f2c_init_next_ (formleninit);
  ffeste_f2c_init_next_ (formattedinit);
  ffeste_f2c_init_next_ (formattedleninit);
  ffeste_f2c_init_next_ (unformattedinit);
  ffeste_f2c_init_next_ (unformattedleninit);
  ffeste_f2c_init_next_ (reclinit);
  ffeste_f2c_init_next_ (nextrecinit);
  ffeste_f2c_init_next_ (blankinit);
  ffeste_f2c_init_next_ (blankleninit);

  inits = build (CONSTRUCTOR, f2c_inquire_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_inlist_%d", NULL,
						  mynumber++),
		  f2c_inquire_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  ffeste_f2c_prepare_int_ (unit_spec, unitexp);
  ffeste_f2c_prepare_char_ (file_spec, fileexp);
  ffeste_f2c_prepare_ptrtoint_ (exist_spec, existexp);
  ffeste_f2c_prepare_ptrtoint_ (open_spec, openexp);
  ffeste_f2c_prepare_ptrtoint_ (number_spec, numberexp);
  ffeste_f2c_prepare_ptrtoint_ (named_spec, namedexp);
  ffeste_f2c_prepare_char_ (name_spec, nameexp);
  ffeste_f2c_prepare_char_ (access_spec, accessexp);
  ffeste_f2c_prepare_char_ (sequential_spec, sequentialexp);
  ffeste_f2c_prepare_char_ (direct_spec, directexp);
  ffeste_f2c_prepare_char_ (form_spec, formexp);
  ffeste_f2c_prepare_char_ (formatted_spec, formattedexp);
  ffeste_f2c_prepare_char_ (unformatted_spec, unformattedexp);
  ffeste_f2c_prepare_ptrtoint_ (recl_spec, reclexp);
  ffeste_f2c_prepare_ptrtoint_ (nextrec_spec, nextrecexp);
  ffeste_f2c_prepare_char_ (blank_spec, blankexp);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  ffeste_f2c_compile_int_ (unitfield, unit_spec, unitexp);
  ffeste_f2c_compile_char_ (filefield, filelenfield, file_spec,
			    fileexp, filelenexp);
  ffeste_f2c_compile_ptrtoint_ (existfield, exist_spec, existexp);
  ffeste_f2c_compile_ptrtoint_ (openfield, open_spec, openexp);
  ffeste_f2c_compile_ptrtoint_ (numberfield, number_spec, numberexp);
  ffeste_f2c_compile_ptrtoint_ (namedfield, named_spec, namedexp);
  ffeste_f2c_compile_char_ (namefield, namelenfield, name_spec, nameexp,
			    namelenexp);
  ffeste_f2c_compile_char_ (accessfield, accesslenfield, access_spec,
			    accessexp, accesslenexp);
  ffeste_f2c_compile_char_ (sequentialfield, sequentiallenfield,
			    sequential_spec, sequentialexp,
			    sequentiallenexp);
  ffeste_f2c_compile_char_ (directfield, directlenfield, direct_spec,
			    directexp, directlenexp);
  ffeste_f2c_compile_char_ (formfield, formlenfield, form_spec, formexp,
			    formlenexp);
  ffeste_f2c_compile_char_ (formattedfield, formattedlenfield, formatted_spec,
			    formattedexp, formattedlenexp);
  ffeste_f2c_compile_char_ (unformattedfield, unformattedlenfield,
			    unformatted_spec, unformattedexp,
			    unformattedlenexp);
  ffeste_f2c_compile_ptrtoint_ (reclfield, recl_spec, reclexp);
  ffeste_f2c_compile_ptrtoint_ (nextrecfield, nextrec_spec, nextrecexp);
  ffeste_f2c_compile_char_ (blankfield, blanklenfield, blank_spec, blankexp,
			    blanklenexp);

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}

#endif
/* Make arglist with ptr to OPEN control list

   Returns a tree suitable as an argument list containing a pointer to
   an OPEN-statement control list.  First, generates that control
   list, if necessary, along with any static and run-time initializations
   that are needed as specified by the arguments to this function.

   Must ensure that all expressions are prepared before being evaluated,
   for any whose evaluation might result in the generation of temporaries.

   Note that this means this function causes a transition, within the
   current block being code-generated via the back end, from the
   declaration of variables (temporaries) to the expanding of expressions,
   statements, etc.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static tree
ffeste_io_olist_ (bool have_err,
		  ffebld unit_expr,
		  ffestpFile *file_spec,
		  ffestpFile *stat_spec,
		  ffestpFile *access_spec,
		  ffestpFile *form_spec,
		  ffestpFile *recl_spec,
		  ffestpFile *blank_spec)
{
  static tree f2c_open_struct = NULL_TREE;
  tree t;
  tree ttype;
  int yes;
  tree field;
  tree inits, initn;
  tree ignore;			/* Ignore length info for certain fields. */
  bool constantp = TRUE;
  static tree errfield, unitfield, filefield, filelenfield, statfield,
    accessfield, formfield, reclfield, blankfield;
  tree errinit, unitinit, fileinit, fileleninit, statinit, accessinit,
    forminit, reclinit, blankinit;
  tree
    unitexp, fileexp, filelenexp, statexp, accessexp, formexp, reclexp,
    blankexp;
  static int mynumber = 0;

  if (f2c_open_struct == NULL_TREE)
    {
      tree ref;

      push_obstacks_nochange ();
      end_temporary_allocation ();

      ref = make_node (RECORD_TYPE);

      errfield = ffecom_decl_field (ref, NULL_TREE, "err",
				    ffecom_f2c_flag_type_node);
      unitfield = ffecom_decl_field (ref, errfield, "unit",
				     ffecom_f2c_ftnint_type_node);
      filefield = ffecom_decl_field (ref, unitfield, "file",
				     string_type_node);
      filelenfield = ffecom_decl_field (ref, filefield, "filelen",
					ffecom_f2c_ftnlen_type_node);
      statfield = ffecom_decl_field (ref, filelenfield, "stat",
				     string_type_node);
      accessfield = ffecom_decl_field (ref, statfield, "access",
				       string_type_node);
      formfield = ffecom_decl_field (ref, accessfield, "form",
				     string_type_node);
      reclfield = ffecom_decl_field (ref, formfield, "recl",
				     ffecom_f2c_ftnint_type_node);
      blankfield = ffecom_decl_field (ref, reclfield, "blank",
				      string_type_node);

      TYPE_FIELDS (ref) = errfield;
      layout_type (ref);

      resume_temporary_allocation ();
      pop_obstacks ();

      f2c_open_struct = ref;
    }

  /* Try to do as much compile-time initialization of the structure
     as possible, to save run time.  */

  ffeste_f2c_init_flag_ (have_err, errinit);

  unitexp = ffecom_const_expr (unit_expr);
  if (unitexp)
    unitinit = unitexp;
  else
    {
      unitinit = ffecom_integer_zero_node;
      constantp = FALSE;
    }

  ffeste_f2c_init_char_ (fileexp, fileinit, filelenexp, fileleninit,
			 file_spec);
  ffeste_f2c_init_charnolen_ (statexp, statinit, stat_spec);
  ffeste_f2c_init_charnolen_ (accessexp, accessinit, access_spec);
  ffeste_f2c_init_charnolen_ (formexp, forminit, form_spec);
  ffeste_f2c_init_int_ (reclexp, reclinit, recl_spec);
  ffeste_f2c_init_charnolen_ (blankexp, blankinit, blank_spec);

  inits = build_tree_list ((field = TYPE_FIELDS (f2c_open_struct)), errinit);
  initn = inits;
  ffeste_f2c_init_next_ (unitinit);
  ffeste_f2c_init_next_ (fileinit);
  ffeste_f2c_init_next_ (fileleninit);
  ffeste_f2c_init_next_ (statinit);
  ffeste_f2c_init_next_ (accessinit);
  ffeste_f2c_init_next_ (forminit);
  ffeste_f2c_init_next_ (reclinit);
  ffeste_f2c_init_next_ (blankinit);

  inits = build (CONSTRUCTOR, f2c_open_struct, NULL_TREE, inits);
  TREE_CONSTANT (inits) = constantp ? 1 : 0;
  TREE_STATIC (inits) = 1;

  yes = suspend_momentary ();

  t = build_decl (VAR_DECL,
		  ffecom_get_invented_identifier ("__g77_olist_%d", NULL,
						  mynumber++),
		  f2c_open_struct);
  TREE_STATIC (t) = 1;
  t = ffecom_start_decl (t, 1);
  ffecom_finish_decl (t, inits, 0);

  resume_momentary (yes);

  /* Prepare run-time expressions.  */

  if (! unitexp)
    ffecom_prepare_expr (unit_expr);

  ffeste_f2c_prepare_char_ (file_spec, fileexp);
  ffeste_f2c_prepare_charnolen_ (stat_spec, statexp);
  ffeste_f2c_prepare_charnolen_ (access_spec, accessexp);
  ffeste_f2c_prepare_charnolen_ (form_spec, formexp);
  ffeste_f2c_prepare_int_ (recl_spec, reclexp);
  ffeste_f2c_prepare_charnolen_ (blank_spec, blankexp);

  ffecom_prepare_end ();

  /* Now evaluate run-time expressions as needed.  */

  if (! unitexp)
    {
      unitexp = ffecom_expr (unit_expr);
      ffeste_f2c_compile_ (unitfield, unitexp);
    }

  ffeste_f2c_compile_char_ (filefield, filelenfield, file_spec, fileexp,
			    filelenexp);
  ffeste_f2c_compile_charnolen_ (statfield, stat_spec, statexp);
  ffeste_f2c_compile_charnolen_ (accessfield, access_spec, accessexp);
  ffeste_f2c_compile_charnolen_ (formfield, form_spec, formexp);
  ffeste_f2c_compile_int_ (reclfield, recl_spec, reclexp);
  ffeste_f2c_compile_charnolen_ (blankfield, blank_spec, blankexp);

  ttype = build_pointer_type (TREE_TYPE (t));
  t = ffecom_1 (ADDR_EXPR, ttype, t);

  t = build_tree_list (NULL_TREE, t);

  return t;
}

#endif
/* Display file-statement specifier.  */

#if FFECOM_targetCURRENT == FFECOM_targetFFE
static void
ffeste_subr_file_ (const char *kw, ffestpFile *spec)
{
  if (!spec->kw_or_val_present)
    return;
  fputs (kw, dmpout);
  if (spec->value_present)
    {
      fputc ('=', dmpout);
      if (spec->value_is_label)
	{
	  assert (spec->value_is_label == 2);	/* Temporary checking only. */
	  fprintf (dmpout, "%" ffelabValue_f "u",
		   ffelab_value (spec->u.label));
	}
      else
	ffebld_dump (spec->u.expr);
    }
  fputc (',', dmpout);
}
#endif

/* Generate code for BACKSPACE/ENDFILE/REWIND.  */

#if FFECOM_targetCURRENT == FFECOM_targetGCC
static void
ffeste_subr_beru_ (ffestpBeruStmt *info, ffecomGfrt rt)
{
  tree alist;
  bool iostat;
  bool errl;

  ffeste_emit_line_note_ ();

#define specified(something) (info->beru_spec[something].kw_or_val_present)

  iostat = specified (FFESTP_beruixIOSTAT);
  errl = specified (FFESTP_beruixERR);

#undef specified

  /* ~~For now, we assume the unit number is specified and is not ASTERISK,
     because the FFE doesn't support BACKSPACE(*) and rejects a BACKSPACE
     without any unit specifier.  f2c, however, supports the former
     construct.	 When it is time to add this feature to the FFE, which
     probably is fairly easy, ffestc_R919 and company will want to pass an
     ffestvUnit indicator of FFESTV_unitINTEXPR or _unitASTERISK to
     ffeste_R919 and company, and they will want to pass that same value to
     this function, and that argument will replace the constant _unitINTEXPR_
     in the call below.	 Right now, the default unit number, 6, is ignored.  */

  ffeste_start_stmt_ ();

  if (errl)
    {
      /* Have ERR= specification.   */

      ffeste_io_err_
	= ffeste_io_abort_
	= ffecom_lookup_label
	(info->beru_spec[FFESTP_beruixERR].u.label);
      ffeste_io_abort_is_temp_ = FALSE;
    }
  else
    {
      /* No ERR= specification.  */

      ffeste_io_err_ = NULL_TREE;

      if ((ffeste_io_abort_is_temp_ = iostat))
	ffeste_io_abort_ = ffecom_temp_label ();
      else
	ffeste_io_abort_ = NULL_TREE;
    }

  if (iostat)
    {
      /* Have IOSTAT= specification.  */

      ffeste_io_iostat_is_temp_ = FALSE;
      ffeste_io_iostat_ = ffecom_expr
	(info->beru_spec[FFESTP_beruixIOSTAT].u.expr);
    }
  else if (ffeste_io_abort_ != NULL_TREE)
    {
      /* Have no IOSTAT= but have ERR=.  */

      ffeste_io_iostat_is_temp_ = TRUE;
      ffeste_io_iostat_
	= ffecom_make_tempvar ("beru", ffecom_integer_type_node,
			       FFETARGET_charactersizeNONE, -1);
    }
  else
    {
      /* No IOSTAT= or ERR= specification.  */

      ffeste_io_iostat_is_temp_ = FALSE;
      ffeste_io_iostat_ = NULL_TREE;
    }

  /* Now prescan, then convert, all the arguments.  */

  alist = ffeste_io_ialist_ (errl || iostat, FFESTV_unitINTEXPR,
			     info->beru_spec[FFESTP_beruixUNIT].u.expr, 6);

  /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
     label, since we're gonna fall through to there anyway. */

  ffeste_io_call_ (ffecom_call_gfrt (rt, alist, NULL_TREE),
		   ! ffeste_io_abort_is_temp_);

  /* If we've got a temp label, generate its code here. */

  if (ffeste_io_abort_is_temp_)
    {
      DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
      emit_nop ();
      expand_label (ffeste_io_abort_);

      assert (ffeste_io_err_ == NULL_TREE);
    }

  ffeste_end_stmt_ ();
}
#endif

/* END DO statement

   Also invoked by _labeldef_branch_finish_ (or, in cases
   of errors, other _labeldef_ functions) when the label definition is
   for a DO-target (LOOPEND) label, once per matching/outstanding DO
   block on the stack.  */

void
ffeste_do (ffestw block)
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_DO\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  if (ffestw_do_tvar (block) == 0)
    {
      expand_end_loop ();		/* DO WHILE and just DO. */

      ffeste_end_block_ (block);
    }
  else
    ffeste_end_iterdo_ (block,
			ffestw_do_tvar (block),
			ffestw_do_incr_saved (block),
			ffestw_do_count_var (block));
#else
#error
#endif
}

/* End of statement following logical IF.

   Applies to *only* logical IF, not to IF-THEN.  */

void
ffeste_end_R807 ()
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_IF\n", dmpout);	/* Also see ffeste_R806. */
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  expand_end_cond ();

  ffeste_end_block_ (NULL);
#else
#error
#endif
}

/* Generate "code" for branch label definition.  */

void
ffeste_labeldef_branch (ffelab label)
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ label %lu\n", ffelab_value (label));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree glabel;

    glabel = ffecom_lookup_label (label);
    assert (glabel != NULL_TREE);
    if (TREE_CODE (glabel) == ERROR_MARK)
      return;

    assert (DECL_INITIAL (glabel) == NULL_TREE);

    DECL_INITIAL (glabel) = error_mark_node;
    DECL_SOURCE_FILE (glabel) = ffelab_definition_filename (label);
    DECL_SOURCE_LINE (glabel) = ffelab_definition_filelinenum (label);

    emit_nop ();

    expand_label (glabel);
  }
#else
#error
#endif
}

/* Generate "code" for FORMAT label definition.  */

void
ffeste_labeldef_format (ffelab label)
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "$ label %lu\n", ffelab_value (label));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_label_formatdef_ = label;
#else
#error
#endif
}

/* Assignment statement (outside of WHERE).  */

void
ffeste_R737A (ffebld dest, ffebld source)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ let ", dmpout);
  ffebld_dump (dest);
  fputs ("=", dmpout);
  ffebld_dump (source);
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  ffeste_start_stmt_ ();

  ffecom_expand_let_stmt (dest, source);

  ffeste_end_stmt_ ();
#else
#error
#endif
}

/* Block IF (IF-THEN) statement.  */

void
ffeste_R803 (ffestw block, ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ IF_block (", dmpout);
  ffebld_dump (expr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree temp;

    ffeste_emit_line_note_ ();

    ffeste_start_block_ (block);

    temp = ffecom_make_tempvar ("ifthen", integer_type_node,
				FFETARGET_charactersizeNONE, -1);

    ffeste_start_stmt_ ();

    ffecom_prepare_expr (expr);

    if (ffecom_prepare_end ())
      {
	tree result;

	result = ffecom_modify (void_type_node,
				temp,
				ffecom_truth_value (ffecom_expr (expr)));

	expand_expr_stmt (result);

	ffeste_end_stmt_ ();
      }
    else
      {
	ffeste_end_stmt_ ();

	temp = ffecom_truth_value (ffecom_expr (expr));
      }

    expand_start_cond (temp, 0);

    /* No fake `else' constructs introduced (yet).  */
    ffestw_set_ifthen_fake_else (block, 0);
  }
#else
#error
#endif
}

/* ELSE IF statement.  */

void
ffeste_R804 (ffestw block, ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ ELSE_IF (", dmpout);
  ffebld_dump (expr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree temp;

    ffeste_emit_line_note_ ();

    /* Since ELSEIF(expr) might require preparations for expr,
       implement as ELSE; prepare-expr; IF (expr) THEN ...; ENDIF.  */

    expand_start_else ();

    ffeste_start_block_ (block);

    temp = ffecom_make_tempvar ("elseif", integer_type_node,
				FFETARGET_charactersizeNONE, -1);

    ffeste_start_stmt_ ();

    ffecom_prepare_expr (expr);

    if (ffecom_prepare_end ())
      {
	tree result;

	result = ffecom_modify (void_type_node,
				temp,
				ffecom_truth_value (ffecom_expr (expr)));

	expand_expr_stmt (result);

	ffeste_end_stmt_ ();
      }
    else
      {
	/* In this case, we could probably have used expand_start_elseif
	   instead, saving the need for a fake `else' construct.  But,
	   until it's clear that'd improve performance, it's easier this
	   way, since we have to expand_start_else before we get to this
	   test, given the current design.  */

	ffeste_end_stmt_ ();

	temp = ffecom_truth_value (ffecom_expr (expr));
      }

    expand_start_cond (temp, 0);

    /* Increment number of fake `else' constructs introduced.  */
    ffestw_set_ifthen_fake_else (block,
				 ffestw_ifthen_fake_else (block) + 1);
  }
#else
#error
#endif
}

/* ELSE statement.  */

void
ffeste_R805 (ffestw block UNUSED)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ ELSE\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  expand_start_else ();
#else
#error
#endif
}

/* END IF statement.  */

void
ffeste_R806 (ffestw block)
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_IF_then\n", dmpout);	/* Also see ffeste_shriek_if_. */
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    int i = ffestw_ifthen_fake_else (block) + 1;

    ffeste_emit_line_note_ ();

    for (; i; --i)
      {
	expand_end_cond ();

	ffeste_end_block_ (block);
      }
  }
#else
#error
#endif
}

/* Logical IF statement.  */

void
ffeste_R807 (ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ IF_logical (", dmpout);
  ffebld_dump (expr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree temp;

    ffeste_emit_line_note_ ();

    ffeste_start_block_ (NULL);

    temp = ffecom_make_tempvar ("if", integer_type_node,
				FFETARGET_charactersizeNONE, -1);

    ffeste_start_stmt_ ();

    ffecom_prepare_expr (expr);

    if (ffecom_prepare_end ())
      {
	tree result;

	result = ffecom_modify (void_type_node,
				temp,
				ffecom_truth_value (ffecom_expr (expr)));

	expand_expr_stmt (result);

	ffeste_end_stmt_ ();
      }
    else
      {
	ffeste_end_stmt_ ();

	temp = ffecom_truth_value (ffecom_expr (expr));
      }

    expand_start_cond (temp, 0);
  }
#else
#error
#endif
}

/* SELECT CASE statement.  */

void
ffeste_R809 (ffestw block, ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ SELECT_CASE (", dmpout);
  ffebld_dump (expr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  ffeste_start_block_ (block);

  if ((expr == NULL)
      || (ffeinfo_basictype (ffebld_info (expr))
	  == FFEINFO_basictypeANY))
    ffestw_set_select_texpr (block, error_mark_node);
  else if (ffeinfo_basictype (ffebld_info (expr))
	   == FFEINFO_basictypeCHARACTER)
    {
      /* ~~~Someday handle CHARACTER*1, CHARACTER*N */

      ffebad_start_msg ("SELECT CASE on CHARACTER type (at %0) not supported -- sorry",
			FFEBAD_severityFATAL);
      ffebad_here (0, ffestw_line (block), ffestw_col (block));
      ffebad_finish ();
      ffestw_set_select_texpr (block, error_mark_node);
    }
  else
    {
      tree result;
      tree texpr;

      result = ffecom_make_tempvar ("select", ffecom_type_expr (expr),
				    ffeinfo_size (ffebld_info (expr)),
				    -1);

      ffeste_start_stmt_ ();

      ffecom_prepare_expr (expr);

      ffecom_prepare_end ();

      texpr = ffecom_expr (expr);

      assert (TYPE_MAIN_VARIANT (TREE_TYPE (texpr))
	      == TYPE_MAIN_VARIANT (TREE_TYPE (result)));

      texpr = ffecom_modify (void_type_node,
			     result,
			     texpr);
      expand_expr_stmt (texpr);

      ffeste_end_stmt_ ();

      expand_start_case (1, result, TREE_TYPE (result),
			 "SELECT CASE statement");
      ffestw_set_select_texpr (block, texpr);
      ffestw_set_select_break (block, FALSE);
    }
#else
#error
#endif
}

/* CASE statement.

   If casenum is 0, it's CASE DEFAULT.	Else it's the case ranges at
   the start of the first_stmt list in the select object at the top of
   the stack that match casenum.  */

void
ffeste_R810 (ffestw block, unsigned long casenum)
{
  ffestwSelect s = ffestw_select (block);
  ffestwCase c;

  ffeste_check_simple_ ();

  if (s->first_stmt == (ffestwCase) &s->first_rel)
    c = NULL;
  else
    c = s->first_stmt;

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if ((c == NULL) || (casenum != c->casenum))
    {
      if (casenum == 0)		/* Intentional CASE DEFAULT. */
	fputs ("+ CASE_DEFAULT", dmpout);
    }
  else
    {
      bool comma = FALSE;

      fputs ("+ CASE (", dmpout);
      do
	{
	  if (comma)
	    fputc (',', dmpout);
	  else
	    comma = TRUE;
	  if (c->low != NULL)
	    ffebld_constant_dump (c->low);
	  if (c->low != c->high)
	    {
	      fputc (':', dmpout);
	      if (c->high != NULL)
		ffebld_constant_dump (c->high);
	    }
	  c = c->next_stmt;
	  /* Unlink prev.  */
	  c->previous_stmt->previous_stmt->next_stmt = c;
	  c->previous_stmt = c->previous_stmt->previous_stmt;
	}
      while ((c != (ffestwCase) &s->first_rel) && (casenum == c->casenum));
      fputc (')', dmpout);
    }

  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree texprlow;
    tree texprhigh;
    tree tlabel;
    int pushok;
    tree duplicate;

    ffeste_emit_line_note_ ();

    if (ffestw_select_texpr (block) == error_mark_node)
      return;

    /* ~~~Someday handle CHARACTER*1, CHARACTER*N */

    tlabel = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);

    if (ffestw_select_break (block))
      expand_exit_something ();
    else
      ffestw_set_select_break (block, TRUE);

    if ((c == NULL) || (casenum != c->casenum))
      {
	if (casenum == 0)	/* Intentional CASE DEFAULT. */
	  {
	    pushok = pushcase (NULL_TREE, 0, tlabel, &duplicate);
	    assert (pushok == 0);
	  }
      }
    else
      do
	{
	  texprlow = (c->low == NULL) ? NULL_TREE
	    : ffecom_constantunion (&ffebld_constant_union (c->low), s->type,
		       s->kindtype, ffecom_tree_type[s->type][s->kindtype]);
	  if (c->low != c->high)
	    {
	      texprhigh = (c->high == NULL) ? NULL_TREE
		: ffecom_constantunion (&ffebld_constant_union (c->high),
	      s->type, s->kindtype, ffecom_tree_type[s->type][s->kindtype]);
	      pushok = pushcase_range (texprlow, texprhigh, convert,
				       tlabel, &duplicate);
	    }
	  else
	    pushok = pushcase (texprlow, convert, tlabel, &duplicate);
	  assert (pushok == 0);
	  c = c->next_stmt;
	  /* Unlink prev.  */
	  c->previous_stmt->previous_stmt->next_stmt = c;
	  c->previous_stmt = c->previous_stmt->previous_stmt;
	}
      while ((c != (ffestwCase) &s->first_rel) && (casenum == c->casenum));

    clear_momentary ();
  }
#else
#error
#endif
}

/* END SELECT statement.  */

void
ffeste_R811 (ffestw block)
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_SELECT\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  /* ~~~Someday handle CHARACTER*1, CHARACTER*N */

  if (TREE_CODE (ffestw_select_texpr (block)) != ERROR_MARK)
    expand_end_case (ffestw_select_texpr (block));

  ffeste_end_block_ (block);
#else
#error
#endif
}

/* Iterative DO statement.  */

void
ffeste_R819A (ffestw block, ffelab label UNUSED, ffebld var,
	      ffebld start, ffelexToken start_token,
	      ffebld end, ffelexToken end_token,
	      ffebld incr, ffelexToken incr_token)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if ((ffebld_op (incr) == FFEBLD_opCONTER)
      && (ffebld_constant_is_zero (ffebld_conter (incr))))
    {
      ffebad_start (FFEBAD_DO_STEP_ZERO);
      ffebad_here (0, ffelex_token_where_line (incr_token),
		   ffelex_token_where_column (incr_token));
      ffebad_string ("Iterative DO loop");
      ffebad_finish ();
      /* Don't bother replacing it with 1 yet.  */
    }

  if (label == NULL)
    fputs ("+ DO_iterative_nonlabeled (", dmpout);
  else
    fprintf (dmpout, "+ DO_iterative_labeled %lu (", ffelab_value (label));
  ffebld_dump (var);
  fputc ('=', dmpout);
  ffebld_dump (start);
  fputc (',', dmpout);
  ffebld_dump (end);
  fputc (',', dmpout);
  ffebld_dump (incr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    ffeste_emit_line_note_ ();

    ffeste_begin_iterdo_ (block, NULL, NULL, NULL,
			  var,
			  start, start_token,
			  end, end_token,
			  incr, incr_token,
			  "Iterative DO loop");
  }
#else
#error
#endif
}

/* DO WHILE statement.  */

void
ffeste_R819B (ffestw block, ffelab label UNUSED, ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if (label == NULL)
    fputs ("+ DO_WHILE_nonlabeled (", dmpout);
  else
    fprintf (dmpout, "+ DO_WHILE_labeled %lu (", ffelab_value (label));
  ffebld_dump (expr);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree result;

    ffeste_emit_line_note_ ();

    ffeste_start_block_ (block);

    if (expr)
      {
	struct nesting *loop;
	tree mod;

	result = ffecom_make_tempvar ("dowhile", integer_type_node,
				      FFETARGET_charactersizeNONE, -1);
	loop = expand_start_loop (1);

	ffeste_start_stmt_ ();

	ffecom_prepare_expr (expr);

	ffecom_prepare_end ();

	mod = ffecom_modify (void_type_node,
			     result,
			     ffecom_truth_value (ffecom_expr (expr)));
	expand_expr_stmt (mod);

	ffeste_end_stmt_ ();

	ffestw_set_do_hook (block, loop);
	expand_exit_loop_if_false (0, result);
      }
    else
      ffestw_set_do_hook (block, expand_start_loop (1));

    ffestw_set_do_tvar (block, NULL_TREE);
  }
#else
#error
#endif
}

/* END DO statement.

   This is the MIL-STD 1753 END DO. It's syntactic sugar, similar to
   CONTINUE (except that it has to have a label that is the target of
   one or more iterative DO statement), not the Fortran-90 structured
   END DO, which is handled elsewhere, as is the actual mechanism of
   ending an iterative DO statement, even one that ends at a label.  */

void
ffeste_R825 ()
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_DO_sugar\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  emit_nop ();
#else
#error
#endif
}

/* CYCLE statement.  */

void
ffeste_R834 (ffestw block)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ CYCLE block #%lu\n", ffestw_blocknum (block));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  expand_continue_loop (ffestw_do_hook (block));
#else
#error
#endif
}

/* EXIT statement.  */

void
ffeste_R835 (ffestw block)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ EXIT block #%lu\n", ffestw_blocknum (block));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  expand_exit_loop (ffestw_do_hook (block));
#else
#error
#endif
}

/* GOTO statement.  */

void
ffeste_R836 (ffelab label)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ GOTO %lu\n", ffelab_value (label));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree glabel;

    ffeste_emit_line_note_ ();

    glabel = ffecom_lookup_label (label);
    if ((glabel != NULL_TREE)
	&& (TREE_CODE (glabel) != ERROR_MARK))
      {
	expand_goto (glabel);
	TREE_USED (glabel) = 1;
      }
  }
#else
#error
#endif
}

/* Computed GOTO statement.  */

void
ffeste_R837 (ffelab *labels, int count, ffebld expr)
{
  int i;

  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ CGOTO (", dmpout);
  for (i = 0; i < count; ++i)
    {
      if (i != 0)
	fputc (',', dmpout);
      fprintf (dmpout, "%" ffelabValue_f "u", ffelab_value (labels[i]));
    }
  fputs ("),", dmpout);
  ffebld_dump (expr);
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree texpr;
    tree value;
    tree tlabel;
    int pushok;
    tree duplicate;

    ffeste_emit_line_note_ ();

    ffeste_start_stmt_ ();

    ffecom_prepare_expr (expr);

    ffecom_prepare_end ();

    texpr = ffecom_expr (expr);

    expand_start_case (0, texpr, TREE_TYPE (texpr), "computed GOTO statement");

    for (i = 0; i < count; ++i)
      {
	value = build_int_2 (i + 1, 0);
	tlabel = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);

	pushok = pushcase (value, convert, tlabel, &duplicate);
	assert (pushok == 0);

	tlabel = ffecom_lookup_label (labels[i]);
	if ((tlabel == NULL_TREE)
	    || (TREE_CODE (tlabel) == ERROR_MARK))
	  continue;

	expand_goto (tlabel);
	TREE_USED (tlabel) = 1;
      }
    expand_end_case (texpr);

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* ASSIGN statement.  */

void
ffeste_R838 (ffelab label, ffebld target)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ ASSIGN %lu TO ", ffelab_value (label));
  ffebld_dump (target);
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree expr_tree;
    tree label_tree;
    tree target_tree;

    ffeste_emit_line_note_ ();

    /* No need to call ffeste_start_stmt_(), as the sorts of expressions
       seen here should never require use of temporaries.  */

    label_tree = ffecom_lookup_label (label);
    if ((label_tree != NULL_TREE)
	&& (TREE_CODE (label_tree) != ERROR_MARK))
      {
	label_tree = ffecom_1 (ADDR_EXPR,
			       build_pointer_type (void_type_node),
			       label_tree);
	TREE_CONSTANT (label_tree) = 1;

	target_tree = ffecom_expr_assign_w (target);
	if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (target_tree)))
	    < GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (label_tree))))
	  error ("ASSIGN to variable that is too small");

	label_tree = convert (TREE_TYPE (target_tree), label_tree);

	expr_tree = ffecom_modify (void_type_node,
				   target_tree,
				   label_tree);
	expand_expr_stmt (expr_tree);

	clear_momentary ();
      }
  }
#else
#error
#endif
}

/* Assigned GOTO statement.  */

void
ffeste_R839 (ffebld target)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ AGOTO ", dmpout);
  ffebld_dump (target);
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree t;

    ffeste_emit_line_note_ ();

    /* No need to call ffeste_start_stmt_(), as the sorts of expressions
       seen here should never require use of temporaries.  */

    t = ffecom_expr_assign (target);
    if (GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (t)))
	< GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (null_pointer_node))))
      error ("ASSIGNed GOTO target variable is too small");

    expand_computed_goto (convert (TREE_TYPE (null_pointer_node), t));

    clear_momentary ();
  }
#else
#error
#endif
}

/* Arithmetic IF statement.  */

void
ffeste_R840 (ffebld expr, ffelab neg, ffelab zero, ffelab pos)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ IF_arithmetic (", dmpout);
  ffebld_dump (expr);
  fprintf (dmpout, ") %" ffelabValue_f "u,%" ffelabValue_f "u,%" ffelabValue_f "u\n",
	   ffelab_value (neg), ffelab_value (zero), ffelab_value (pos));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree gneg = ffecom_lookup_label (neg);
    tree gzero = ffecom_lookup_label (zero);
    tree gpos = ffecom_lookup_label (pos);
    tree texpr;

    ffeste_emit_line_note_ ();

    if ((gneg == NULL_TREE) || (gzero == NULL_TREE) || (gpos == NULL_TREE))
      return;
    if ((TREE_CODE (gneg) == ERROR_MARK)
	|| (TREE_CODE (gzero) == ERROR_MARK)
	|| (TREE_CODE (gpos) == ERROR_MARK))
      return;

    ffeste_start_stmt_ ();

    ffecom_prepare_expr (expr);

    ffecom_prepare_end ();

    if (neg == zero)
      {
	if (neg == pos)
	  expand_goto (gzero);
	else
	  {
	    /* IF (expr.LE.0) THEN GOTO neg/zero ELSE GOTO pos.  */
	    texpr = ffecom_expr (expr);
	    texpr = ffecom_2 (LE_EXPR, integer_type_node,
			      texpr,
			      convert (TREE_TYPE (texpr),
				       integer_zero_node));
	    expand_start_cond (ffecom_truth_value (texpr), 0);
	    expand_goto (gzero);
	    expand_start_else ();
	    expand_goto (gpos);
	    expand_end_cond ();
	  }
      }
    else if (neg == pos)
      {
	/* IF (expr.NE.0) THEN GOTO neg/pos ELSE GOTO zero.  */
	texpr = ffecom_expr (expr);
	texpr = ffecom_2 (NE_EXPR, integer_type_node,
			  texpr,
			  convert (TREE_TYPE (texpr),
				   integer_zero_node));
	expand_start_cond (ffecom_truth_value (texpr), 0);
	expand_goto (gneg);
	expand_start_else ();
	expand_goto (gzero);
	expand_end_cond ();
      }
    else if (zero == pos)
      {
	/* IF (expr.GE.0) THEN GOTO zero/pos ELSE GOTO neg.  */
	texpr = ffecom_expr (expr);
	texpr = ffecom_2 (GE_EXPR, integer_type_node,
			  texpr,
			  convert (TREE_TYPE (texpr),
				   integer_zero_node));
	expand_start_cond (ffecom_truth_value (texpr), 0);
	expand_goto (gzero);
	expand_start_else ();
	expand_goto (gneg);
	expand_end_cond ();
      }
    else
      {
	/* Use a SAVE_EXPR in combo with:
	   IF (expr.LT.0) THEN GOTO neg
	   ELSEIF (expr.GT.0) THEN GOTO pos
	   ELSE GOTO zero.  */
	tree expr_saved = ffecom_save_tree (ffecom_expr (expr));

	texpr = ffecom_2 (LT_EXPR, integer_type_node,
			  expr_saved,
			  convert (TREE_TYPE (expr_saved),
				   integer_zero_node));
	expand_start_cond (ffecom_truth_value (texpr), 0);
	expand_goto (gneg);
	texpr = ffecom_2 (GT_EXPR, integer_type_node,
			  expr_saved,
			  convert (TREE_TYPE (expr_saved),
				   integer_zero_node));
	expand_start_elseif (ffecom_truth_value (texpr));
	expand_goto (gpos);
	expand_start_else ();
	expand_goto (gzero);
	expand_end_cond ();
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* CONTINUE statement.  */

void
ffeste_R841 ()
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ CONTINUE\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_emit_line_note_ ();

  emit_nop ();
#else
#error
#endif
}

/* STOP statement.  */

void
ffeste_R842 (ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if (expr == NULL)
    {
      fputs ("+ STOP\n", dmpout);
    }
  else
    {
      fputs ("+ STOP_coded ", dmpout);
      ffebld_dump (expr);
      fputc ('\n', dmpout);
    }
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree callit;
    ffelexToken msg;

    ffeste_emit_line_note_ ();

    if ((expr == NULL)
	|| (ffeinfo_basictype (ffebld_info (expr))
	    == FFEINFO_basictypeANY))
      {
	msg = ffelex_token_new_character ("", ffelex_token_where_line
			       (ffesta_tokens[0]), ffelex_token_where_column
					  (ffesta_tokens[0]));
	expr = ffebld_new_conter (ffebld_constant_new_characterdefault
				  (msg));
	ffelex_token_kill (msg);
	ffebld_set_info (expr, ffeinfo_new (FFEINFO_basictypeCHARACTER,
		    FFEINFO_kindtypeCHARACTERDEFAULT, 0, FFEINFO_kindENTITY,
					    FFEINFO_whereCONSTANT, 0));
      }
    else if (ffeinfo_basictype (ffebld_info (expr))
	     == FFEINFO_basictypeINTEGER)
      {
	char num[50];

	assert (ffebld_op (expr) == FFEBLD_opCONTER);
	assert (ffeinfo_kindtype (ffebld_info (expr))
		== FFEINFO_kindtypeINTEGERDEFAULT);
	sprintf (num, "%" ffetargetIntegerDefault_f "d",
		 ffebld_constant_integer1 (ffebld_conter (expr)));
	msg = ffelex_token_new_character (num, ffelex_token_where_line
			       (ffesta_tokens[0]), ffelex_token_where_column
					  (ffesta_tokens[0]));
	expr = ffebld_new_conter (ffebld_constant_new_characterdefault
				  (msg));
	ffelex_token_kill (msg);
	ffebld_set_info (expr, ffeinfo_new (FFEINFO_basictypeCHARACTER,
		    FFEINFO_kindtypeCHARACTERDEFAULT, 0, FFEINFO_kindENTITY,
					    FFEINFO_whereCONSTANT, 0));
      }
    else
      {
	assert (ffeinfo_basictype (ffebld_info (expr))
		== FFEINFO_basictypeCHARACTER);
	assert (ffebld_op (expr) == FFEBLD_opCONTER);
	assert (ffeinfo_kindtype (ffebld_info (expr))
		== FFEINFO_kindtypeCHARACTERDEFAULT);
      }

    /* No need to call ffeste_start_stmt_(), as the sorts of expressions
       seen here should never require use of temporaries.  */

    callit = ffecom_call_gfrt (FFECOM_gfrtSTOP,
		    ffecom_list_ptr_to_expr (ffebld_new_item (expr, NULL)),
			       NULL_TREE);
    TREE_SIDE_EFFECTS (callit) = 1;

    expand_expr_stmt (callit);

    clear_momentary ();
  }
#else
#error
#endif
}

/* PAUSE statement.  */

void
ffeste_R843 (ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if (expr == NULL)
    {
      fputs ("+ PAUSE\n", dmpout);
    }
  else
    {
      fputs ("+ PAUSE_coded ", dmpout);
      ffebld_dump (expr);
      fputc ('\n', dmpout);
    }
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree callit;
    ffelexToken msg;

    ffeste_emit_line_note_ ();

    if ((expr == NULL)
	|| (ffeinfo_basictype (ffebld_info (expr))
	    == FFEINFO_basictypeANY))
      {
	msg = ffelex_token_new_character ("", ffelex_token_where_line
			       (ffesta_tokens[0]), ffelex_token_where_column
					  (ffesta_tokens[0]));
	expr = ffebld_new_conter (ffebld_constant_new_characterdefault
				  (msg));
	ffelex_token_kill (msg);
	ffebld_set_info (expr, ffeinfo_new (FFEINFO_basictypeCHARACTER,
		    FFEINFO_kindtypeCHARACTERDEFAULT, 0, FFEINFO_kindENTITY,
					    FFEINFO_whereCONSTANT, 0));
      }
    else if (ffeinfo_basictype (ffebld_info (expr))
	     == FFEINFO_basictypeINTEGER)
      {
	char num[50];

	assert (ffebld_op (expr) == FFEBLD_opCONTER);
	assert (ffeinfo_kindtype (ffebld_info (expr))
		== FFEINFO_kindtypeINTEGERDEFAULT);
	sprintf (num, "%" ffetargetIntegerDefault_f "d",
		 ffebld_constant_integer1 (ffebld_conter (expr)));
	msg = ffelex_token_new_character (num, ffelex_token_where_line
			       (ffesta_tokens[0]), ffelex_token_where_column
					  (ffesta_tokens[0]));
	expr = ffebld_new_conter (ffebld_constant_new_characterdefault
				  (msg));
	ffelex_token_kill (msg);
	ffebld_set_info (expr, ffeinfo_new (FFEINFO_basictypeCHARACTER,
		    FFEINFO_kindtypeCHARACTERDEFAULT, 0, FFEINFO_kindENTITY,
					    FFEINFO_whereCONSTANT, 0));
      }
    else
      {
	assert (ffeinfo_basictype (ffebld_info (expr))
		== FFEINFO_basictypeCHARACTER);
	assert (ffebld_op (expr) == FFEBLD_opCONTER);
	assert (ffeinfo_kindtype (ffebld_info (expr))
		== FFEINFO_kindtypeCHARACTERDEFAULT);
      }

    /* No need to call ffeste_start_stmt_(), as the sorts of expressions
       seen here should never require use of temporaries.  */

    callit = ffecom_call_gfrt (FFECOM_gfrtPAUSE,
		    ffecom_list_ptr_to_expr (ffebld_new_item (expr, NULL)),
			       NULL_TREE);
    TREE_SIDE_EFFECTS (callit) = 1;

    expand_expr_stmt (callit);

    clear_momentary ();
  }
#if 0				/* Old approach for phantom g77 run-time
				   library. */
  {
    tree callit;

    ffeste_emit_line_note_ ();

    if (expr == NULL)
      callit = ffecom_call_gfrt (FFECOM_gfrtPAUSENIL, NULL_TREE, NULL_TREE);
    else if (ffeinfo_basictype (ffebld_info (expr))
	     == FFEINFO_basictypeINTEGER)
      callit = ffecom_call_gfrt (FFECOM_gfrtPAUSEINT,
		      ffecom_list_ptr_to_expr (ffebld_new_item (expr, NULL)),
				 NULL_TREE);
    else if (ffeinfo_basictype (ffebld_info (expr))
	     == FFEINFO_basictypeCHARACTER)
      callit = ffecom_call_gfrt (FFECOM_gfrtPAUSECHAR,
		      ffecom_list_ptr_to_expr (ffebld_new_item (expr, NULL)),
				 NULL_TREE);
    else
      abort ();
    TREE_SIDE_EFFECTS (callit) = 1;

    expand_expr_stmt (callit);

    clear_momentary ();
  }
#endif
#else
#error
#endif
}

/* OPEN statement.  */

void
ffeste_R904 (ffestpOpenStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ OPEN (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->open_spec[FFESTP_openixUNIT]);
  ffeste_subr_file_ ("ACCESS", &info->open_spec[FFESTP_openixACCESS]);
  ffeste_subr_file_ ("ACTION", &info->open_spec[FFESTP_openixACTION]);
  ffeste_subr_file_ ("ASSOCIATEVARIABLE", &info->open_spec[FFESTP_openixASSOCIATEVARIABLE]);
  ffeste_subr_file_ ("BLANK", &info->open_spec[FFESTP_openixBLANK]);
  ffeste_subr_file_ ("BLOCKSIZE", &info->open_spec[FFESTP_openixBLOCKSIZE]);
  ffeste_subr_file_ ("BUFFERCOUNT", &info->open_spec[FFESTP_openixBUFFERCOUNT]);
  ffeste_subr_file_ ("CARRIAGECONTROL", &info->open_spec[FFESTP_openixCARRIAGECONTROL]);
  ffeste_subr_file_ ("DEFAULTFILE", &info->open_spec[FFESTP_openixDEFAULTFILE]);
  ffeste_subr_file_ ("DELIM", &info->open_spec[FFESTP_openixDELIM]);
  ffeste_subr_file_ ("DISPOSE", &info->open_spec[FFESTP_openixDISPOSE]);
  ffeste_subr_file_ ("ERR", &info->open_spec[FFESTP_openixERR]);
  ffeste_subr_file_ ("EXTENDSIZE", &info->open_spec[FFESTP_openixEXTENDSIZE]);
  ffeste_subr_file_ ("FILE", &info->open_spec[FFESTP_openixFILE]);
  ffeste_subr_file_ ("FORM", &info->open_spec[FFESTP_openixFORM]);
  ffeste_subr_file_ ("INITIALSIZE", &info->open_spec[FFESTP_openixINITIALSIZE]);
  ffeste_subr_file_ ("IOSTAT", &info->open_spec[FFESTP_openixIOSTAT]);
  ffeste_subr_file_ ("KEY", &info->open_spec[FFESTP_openixKEY]);
  ffeste_subr_file_ ("MAXREC", &info->open_spec[FFESTP_openixMAXREC]);
  ffeste_subr_file_ ("NOSPANBLOCKS", &info->open_spec[FFESTP_openixNOSPANBLOCKS]);
  ffeste_subr_file_ ("ORGANIZATION", &info->open_spec[FFESTP_openixORGANIZATION]);
  ffeste_subr_file_ ("PAD", &info->open_spec[FFESTP_openixPAD]);
  ffeste_subr_file_ ("POSITION", &info->open_spec[FFESTP_openixPOSITION]);
  ffeste_subr_file_ ("READONLY", &info->open_spec[FFESTP_openixREADONLY]);
  ffeste_subr_file_ ("RECL", &info->open_spec[FFESTP_openixRECL]);
  ffeste_subr_file_ ("RECORDTYPE", &info->open_spec[FFESTP_openixRECORDTYPE]);
  ffeste_subr_file_ ("SHARED", &info->open_spec[FFESTP_openixSHARED]);
  ffeste_subr_file_ ("STATUS", &info->open_spec[FFESTP_openixSTATUS]);
  ffeste_subr_file_ ("USEROPEN", &info->open_spec[FFESTP_openixUSEROPEN]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree args;
    bool iostat;
    bool errl;

    ffeste_emit_line_note_ ();

#define specified(something) (info->open_spec[something].kw_or_val_present)

    iostat = specified (FFESTP_openixIOSTAT);
    errl = specified (FFESTP_openixERR);

#undef specified

    ffeste_start_stmt_ ();

    if (errl)
      {
	ffeste_io_err_
	  = ffeste_io_abort_
	  = ffecom_lookup_label
	  (info->open_spec[FFESTP_openixERR].u.label);
	ffeste_io_abort_is_temp_ = FALSE;
      }
    else
      {
	ffeste_io_err_ = NULL_TREE;

	if ((ffeste_io_abort_is_temp_ = iostat))
	  ffeste_io_abort_ = ffecom_temp_label ();
	else
	  ffeste_io_abort_ = NULL_TREE;
      }

    if (iostat)
      {
	/* Have IOSTAT= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = ffecom_expr
	  (info->open_spec[FFESTP_openixIOSTAT].u.expr);
      }
    else if (ffeste_io_abort_ != NULL_TREE)
      {
	/* Have no IOSTAT= but have ERR=.  */

	ffeste_io_iostat_is_temp_ = TRUE;
	ffeste_io_iostat_
	  = ffecom_make_tempvar ("open", ffecom_integer_type_node,
				 FFETARGET_charactersizeNONE, -1);
      }
    else
      {
	/* No IOSTAT= or ERR= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = NULL_TREE;
      }

    /* Now prescan, then convert, all the arguments.  */

    args = ffeste_io_olist_ (errl || iostat,
			     info->open_spec[FFESTP_openixUNIT].u.expr,
			     &info->open_spec[FFESTP_openixFILE],
			     &info->open_spec[FFESTP_openixSTATUS],
			     &info->open_spec[FFESTP_openixACCESS],
			     &info->open_spec[FFESTP_openixFORM],
			     &info->open_spec[FFESTP_openixRECL],
			     &info->open_spec[FFESTP_openixBLANK]);

    /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
       label, since we're gonna fall through to there anyway. */

    ffeste_io_call_ (ffecom_call_gfrt (FFECOM_gfrtFOPEN, args, NULL_TREE),
		     ! ffeste_io_abort_is_temp_);

    /* If we've got a temp label, generate its code here.  */

    if (ffeste_io_abort_is_temp_)
      {
	DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
	emit_nop ();
	expand_label (ffeste_io_abort_);

	assert (ffeste_io_err_ == NULL_TREE);
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* CLOSE statement.  */

void
ffeste_R907 (ffestpCloseStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ CLOSE (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->close_spec[FFESTP_closeixUNIT]);
  ffeste_subr_file_ ("ERR", &info->close_spec[FFESTP_closeixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->close_spec[FFESTP_closeixIOSTAT]);
  ffeste_subr_file_ ("STATUS", &info->close_spec[FFESTP_closeixSTATUS]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree args;
    bool iostat;
    bool errl;

    ffeste_emit_line_note_ ();

#define specified(something) (info->close_spec[something].kw_or_val_present)

    iostat = specified (FFESTP_closeixIOSTAT);
    errl = specified (FFESTP_closeixERR);

#undef specified

    ffeste_start_stmt_ ();

    if (errl)
      {
	ffeste_io_err_
	  = ffeste_io_abort_
	  = ffecom_lookup_label
	  (info->close_spec[FFESTP_closeixERR].u.label);
	ffeste_io_abort_is_temp_ = FALSE;
      }
    else
      {
	ffeste_io_err_ = NULL_TREE;

	if ((ffeste_io_abort_is_temp_ = iostat))
	  ffeste_io_abort_ = ffecom_temp_label ();
	else
	  ffeste_io_abort_ = NULL_TREE;
      }

    if (iostat)
      {
	/* Have IOSTAT= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = ffecom_expr
	  (info->close_spec[FFESTP_closeixIOSTAT].u.expr);
      }
    else if (ffeste_io_abort_ != NULL_TREE)
      {
	/* Have no IOSTAT= but have ERR=.  */

	ffeste_io_iostat_is_temp_ = TRUE;
	ffeste_io_iostat_
	  = ffecom_make_tempvar ("close", ffecom_integer_type_node,
				 FFETARGET_charactersizeNONE, -1);
      }
    else
      {
	/* No IOSTAT= or ERR= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = NULL_TREE;
      }

    /* Now prescan, then convert, all the arguments.  */

    args = ffeste_io_cllist_ (errl || iostat,
			      info->close_spec[FFESTP_closeixUNIT].u.expr,
			      &info->close_spec[FFESTP_closeixSTATUS]);

    /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
       label, since we're gonna fall through to there anyway. */

    ffeste_io_call_ (ffecom_call_gfrt (FFECOM_gfrtFCLOS, args, NULL_TREE),
		     ! ffeste_io_abort_is_temp_);

    /* If we've got a temp label, generate its code here. */

    if (ffeste_io_abort_is_temp_)
      {
	DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
	emit_nop ();
	expand_label (ffeste_io_abort_);

	assert (ffeste_io_err_ == NULL_TREE);
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* READ(...) statement -- start.  */

void
ffeste_R909_start (ffestpReadStmt *info, bool only_format UNUSED,
		   ffestvUnit unit, ffestvFormat format, bool rec,
		   bool key UNUSED)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatNONE:
      if (rec)
	fputs ("+ READ_ufdac", dmpout);
      else if (key)
	fputs ("+ READ_ufidx", dmpout);
      else
	fputs ("+ READ_ufseq", dmpout);
      break;

    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      if (rec)
	fputs ("+ READ_fmdac", dmpout);
      else if (key)
	fputs ("+ READ_fmidx", dmpout);
      else if (unit == FFESTV_unitCHAREXPR)
	fputs ("+ READ_fmint", dmpout);
      else
	fputs ("+ READ_fmseq", dmpout);
      break;

    case FFESTV_formatASTERISK:
      if (unit == FFESTV_unitCHAREXPR)
	fputs ("+ READ_lsint", dmpout);
      else
	fputs ("+ READ_lsseq", dmpout);
      break;

    case FFESTV_formatNAMELIST:
      fputs ("+ READ_nlseq", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in R909 READ" == NULL);
    }

  if (only_format)
    {
      fputc (' ', dmpout);
      ffeste_subr_file_ ("FORMAT", &info->read_spec[FFESTP_readixFORMAT]);
      fputc (' ', dmpout);

      return;
    }

  fputs (" (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->read_spec[FFESTP_readixUNIT]);
  ffeste_subr_file_ ("FORMAT", &info->read_spec[FFESTP_readixFORMAT]);
  ffeste_subr_file_ ("ADVANCE", &info->read_spec[FFESTP_readixADVANCE]);
  ffeste_subr_file_ ("EOR", &info->read_spec[FFESTP_readixEOR]);
  ffeste_subr_file_ ("ERR", &info->read_spec[FFESTP_readixERR]);
  ffeste_subr_file_ ("END", &info->read_spec[FFESTP_readixEND]);
  ffeste_subr_file_ ("IOSTAT", &info->read_spec[FFESTP_readixIOSTAT]);
  ffeste_subr_file_ ("KEYEQ", &info->read_spec[FFESTP_readixKEYEQ]);
  ffeste_subr_file_ ("KEYGE", &info->read_spec[FFESTP_readixKEYGE]);
  ffeste_subr_file_ ("KEYGT", &info->read_spec[FFESTP_readixKEYGT]);
  ffeste_subr_file_ ("KEYID", &info->read_spec[FFESTP_readixKEYID]);
  ffeste_subr_file_ ("NULLS", &info->read_spec[FFESTP_readixNULLS]);
  ffeste_subr_file_ ("REC", &info->read_spec[FFESTP_readixREC]);
  ffeste_subr_file_ ("SIZE", &info->read_spec[FFESTP_readixSIZE]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  ffeste_emit_line_note_ ();

  {
    ffecomGfrt start;
    ffecomGfrt end;
    tree cilist;
    bool iostat;
    bool errl;
    bool endl;

    /* First determine the start, per-item, and end run-time functions to
       call.  The per-item function is picked by choosing an ffeste function
       to call to handle a given item; it knows how to generate a call to the
       appropriate run-time function, and is called an "I/O driver".  */

    switch (format)
      {
      case FFESTV_formatNONE:	/* no FMT= */
	ffeste_io_driver_ = ffeste_io_douio_;
	if (rec)
	  start = FFECOM_gfrtSRDUE, end = FFECOM_gfrtERDUE;
#if 0
	else if (key)
	  start = FFECOM_gfrtSRIUE, end = FFECOM_gfrtERIUE;
#endif
	else
	  start = FFECOM_gfrtSRSUE, end = FFECOM_gfrtERSUE;
	break;

      case FFESTV_formatLABEL:	/* FMT=10 */
      case FFESTV_formatCHAREXPR:	/* FMT='(I10)' */
      case FFESTV_formatINTEXPR:	/* FMT=I [after ASSIGN 10 TO I] */
	ffeste_io_driver_ = ffeste_io_dofio_;
	if (rec)
	  start = FFECOM_gfrtSRDFE, end = FFECOM_gfrtERDFE;
#if 0
	else if (key)
	  start = FFECOM_gfrtSRIFE, end = FFECOM_gfrtERIFE;
#endif
	else if (unit == FFESTV_unitCHAREXPR)
	  start = FFECOM_gfrtSRSFI, end = FFECOM_gfrtERSFI;
	else
	  start = FFECOM_gfrtSRSFE, end = FFECOM_gfrtERSFE;
	break;

      case FFESTV_formatASTERISK:	/* FMT=* */
	ffeste_io_driver_ = ffeste_io_dolio_;
	if (unit == FFESTV_unitCHAREXPR)
	  start = FFECOM_gfrtSRSLI, end = FFECOM_gfrtERSLI;
	else
	  start = FFECOM_gfrtSRSLE, end = FFECOM_gfrtERSLE;
	break;

      case FFESTV_formatNAMELIST:	/* FMT=FOO or NML=FOO [NAMELIST
					   /FOO/] */
	ffeste_io_driver_ = NULL;	/* No start or driver function. */
	start = FFECOM_gfrtSRSNE, end = FFECOM_gfrt;
	break;

      default:
	assert ("Weird stuff" == NULL);
	start = FFECOM_gfrt, end = FFECOM_gfrt;
	break;
      }
    ffeste_io_endgfrt_ = end;

#define specified(something) (info->read_spec[something].kw_or_val_present)

    iostat = specified (FFESTP_readixIOSTAT);
    errl = specified (FFESTP_readixERR);
    endl = specified (FFESTP_readixEND);

#undef specified

    ffeste_start_stmt_ ();

    if (errl)
      {
	/* Have ERR= specification.   */

	ffeste_io_err_
	  = ffecom_lookup_label (info->read_spec[FFESTP_readixERR].u.label);

	if (endl)
	  {
	    /* Have both ERR= and END=.  Need a temp label to handle both.  */
	    ffeste_io_end_
	      = ffecom_lookup_label (info->read_spec[FFESTP_readixEND].u.label);
	    ffeste_io_abort_is_temp_ = TRUE;
	    ffeste_io_abort_ = ffecom_temp_label ();
	  }
	else
	  {
	    /* Have ERR= but no END=.  */
	    ffeste_io_end_ = NULL_TREE;
	    if ((ffeste_io_abort_is_temp_ = iostat))
	      ffeste_io_abort_ = ffecom_temp_label ();
	    else
	      ffeste_io_abort_ = ffeste_io_err_;
	  }
      }
    else
      {
	/* No ERR= specification.  */

	ffeste_io_err_ = NULL_TREE;
	if (endl)
	  {
	    /* Have END= but no ERR=.  */
	    ffeste_io_end_
	      = ffecom_lookup_label (info->read_spec[FFESTP_readixEND].u.label);
	    if ((ffeste_io_abort_is_temp_ = iostat))
	      ffeste_io_abort_ = ffecom_temp_label ();
	    else
	      ffeste_io_abort_ = ffeste_io_end_;
	  }
	else
	  {
	    /* Have no ERR= or END=.  */

	    ffeste_io_end_ = NULL_TREE;
	    if ((ffeste_io_abort_is_temp_ = iostat))
	      ffeste_io_abort_ = ffecom_temp_label ();
	    else
	      ffeste_io_abort_ = NULL_TREE;
	  }
      }

    if (iostat)
      {
	/* Have IOSTAT= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_
	  = ffecom_expr (info->read_spec[FFESTP_readixIOSTAT].u.expr);
      }
    else if (ffeste_io_abort_ != NULL_TREE)
      {
	/* Have no IOSTAT= but have ERR= and/or END=.  */

	ffeste_io_iostat_is_temp_ = TRUE;
	ffeste_io_iostat_
	  = ffecom_make_tempvar ("read", ffecom_integer_type_node,
				 FFETARGET_charactersizeNONE, -1);
      }
    else
      {
	/* No IOSTAT=, ERR=, or END= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = NULL_TREE;
      }

    /* Now prescan, then convert, all the arguments.  */

    if (unit == FFESTV_unitCHAREXPR)
      cilist = ffeste_io_icilist_ (errl || iostat,
				   info->read_spec[FFESTP_readixUNIT].u.expr,
				   endl || iostat, format,
				   &info->read_spec[FFESTP_readixFORMAT]);
    else
      cilist = ffeste_io_cilist_ (errl || iostat, unit,
				  info->read_spec[FFESTP_readixUNIT].u.expr,
				  5, endl || iostat, format,
				  &info->read_spec[FFESTP_readixFORMAT],
				  rec,
				  info->read_spec[FFESTP_readixREC].u.expr);

    /* If there is no end function, then there are no item functions (i.e.
       it's a NAMELIST), and vice versa by the way.  In this situation, don't
       generate the "if (iostat != 0) goto label;" if the label is temp abort
       label, since we're gonna fall through to there anyway.  */

    ffeste_io_call_ (ffecom_call_gfrt (start, cilist, NULL_TREE),
		     (! ffeste_io_abort_is_temp_) || (end != FFECOM_gfrt));
  }
#else
#error
#endif
}

/* READ statement -- I/O item.  */

void
ffeste_R909_item (ffebld expr, ffelexToken expr_token)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  if (expr == NULL)
    return;

  /* Strip parens off items such as in "READ *,(A)".  This is really a bug
     in the user's code, but I've been told lots of code does this.  */
  while (ffebld_op (expr) == FFEBLD_opPAREN)
    expr = ffebld_left (expr);

  if (ffebld_op (expr) == FFEBLD_opANY)
    return;

  if (ffebld_op (expr) == FFEBLD_opIMPDO)
    ffeste_io_impdo_ (expr, expr_token);
  else
    {
      ffeste_start_stmt_ ();

      ffecom_prepare_arg_ptr_to_expr (expr);

      ffecom_prepare_end ();

      ffeste_io_call_ ((*ffeste_io_driver_) (expr), TRUE);

      ffeste_end_stmt_ ();
    }
#else
#error
#endif
}

/* READ statement -- end.  */

void
ffeste_R909_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
     label, since we're gonna fall through to there anyway. */

  if (ffeste_io_endgfrt_ != FFECOM_gfrt)
    ffeste_io_call_ (ffecom_call_gfrt (ffeste_io_endgfrt_, NULL_TREE,
				       NULL_TREE),
		     ! ffeste_io_abort_is_temp_);

  /* If we've got a temp label, generate its code here and have it fan out
     to the END= or ERR= label as appropriate. */

  if (ffeste_io_abort_is_temp_)
    {
      DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
      emit_nop ();
      expand_label (ffeste_io_abort_);

      /* "if (iostat<0) goto end_label;".  */

      if ((ffeste_io_end_ != NULL_TREE)
	  && (TREE_CODE (ffeste_io_end_) != ERROR_MARK))
	{
	  expand_start_cond (ffecom_truth_value
			     (ffecom_2 (LT_EXPR, integer_type_node,
					ffeste_io_iostat_,
					ffecom_integer_zero_node)),
			     0);
	  expand_goto (ffeste_io_end_);
	  expand_end_cond ();
	}

      /* "if (iostat>0) goto err_label;".  */

      if ((ffeste_io_err_ != NULL_TREE)
	  && (TREE_CODE (ffeste_io_err_) != ERROR_MARK))
	{
	  expand_start_cond (ffecom_truth_value
			     (ffecom_2 (GT_EXPR, integer_type_node,
					ffeste_io_iostat_,
					ffecom_integer_zero_node)),
			     0);
	  expand_goto (ffeste_io_err_);
	  expand_end_cond ();
	}
    }

  ffeste_end_stmt_ ();
#else
#error
#endif
}

/* WRITE statement -- start.  */

void
ffeste_R910_start (ffestpWriteStmt *info, ffestvUnit unit,
		   ffestvFormat format, bool rec)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatNONE:
      if (rec)
	fputs ("+ WRITE_ufdac (", dmpout);
      else
	fputs ("+ WRITE_ufseq_or_idx (", dmpout);
      break;

    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      if (rec)
	fputs ("+ WRITE_fmdac (", dmpout);
      else if (unit == FFESTV_unitCHAREXPR)
	fputs ("+ WRITE_fmint (", dmpout);
      else
	fputs ("+ WRITE_fmseq_or_idx (", dmpout);
      break;

    case FFESTV_formatASTERISK:
      if (unit == FFESTV_unitCHAREXPR)
	fputs ("+ WRITE_lsint (", dmpout);
      else
	fputs ("+ WRITE_lsseq (", dmpout);
      break;

    case FFESTV_formatNAMELIST:
      fputs ("+ WRITE_nlseq (", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in R910 WRITE" == NULL);
    }

  ffeste_subr_file_ ("UNIT", &info->write_spec[FFESTP_writeixUNIT]);
  ffeste_subr_file_ ("FORMAT", &info->write_spec[FFESTP_writeixFORMAT]);
  ffeste_subr_file_ ("ADVANCE", &info->write_spec[FFESTP_writeixADVANCE]);
  ffeste_subr_file_ ("EOR", &info->write_spec[FFESTP_writeixEOR]);
  ffeste_subr_file_ ("ERR", &info->write_spec[FFESTP_writeixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->write_spec[FFESTP_writeixIOSTAT]);
  ffeste_subr_file_ ("REC", &info->write_spec[FFESTP_writeixREC]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  ffeste_emit_line_note_ ();

  {
    ffecomGfrt start;
    ffecomGfrt end;
    tree cilist;
    bool iostat;
    bool errl;

    /* First determine the start, per-item, and end run-time functions to
       call.  The per-item function is picked by choosing an ffeste function
       to call to handle a given item; it knows how to generate a call to the
       appropriate run-time function, and is called an "I/O driver".  */

    switch (format)
      {
      case FFESTV_formatNONE:	/* no FMT= */
	ffeste_io_driver_ = ffeste_io_douio_;
	if (rec)
	  start = FFECOM_gfrtSWDUE, end = FFECOM_gfrtEWDUE;
	else
	  start = FFECOM_gfrtSWSUE, end = FFECOM_gfrtEWSUE;
	break;

      case FFESTV_formatLABEL:	/* FMT=10 */
      case FFESTV_formatCHAREXPR:	/* FMT='(I10)' */
      case FFESTV_formatINTEXPR:	/* FMT=I [after ASSIGN 10 TO I] */
	ffeste_io_driver_ = ffeste_io_dofio_;
	if (rec)
	  start = FFECOM_gfrtSWDFE, end = FFECOM_gfrtEWDFE;
	else if (unit == FFESTV_unitCHAREXPR)
	  start = FFECOM_gfrtSWSFI, end = FFECOM_gfrtEWSFI;
	else
	  start = FFECOM_gfrtSWSFE, end = FFECOM_gfrtEWSFE;
	break;

      case FFESTV_formatASTERISK:	/* FMT=* */
	ffeste_io_driver_ = ffeste_io_dolio_;
	if (unit == FFESTV_unitCHAREXPR)
	  start = FFECOM_gfrtSWSLI, end = FFECOM_gfrtEWSLI;
	else
	  start = FFECOM_gfrtSWSLE, end = FFECOM_gfrtEWSLE;
	break;

      case FFESTV_formatNAMELIST:	/* FMT=FOO or NML=FOO [NAMELIST
					   /FOO/] */
	ffeste_io_driver_ = NULL;	/* No start or driver function. */
	start = FFECOM_gfrtSWSNE, end = FFECOM_gfrt;
	break;

      default:
	assert ("Weird stuff" == NULL);
	start = FFECOM_gfrt, end = FFECOM_gfrt;
	break;
      }
    ffeste_io_endgfrt_ = end;

#define specified(something) (info->write_spec[something].kw_or_val_present)

    iostat = specified (FFESTP_writeixIOSTAT);
    errl = specified (FFESTP_writeixERR);

#undef specified

    ffeste_start_stmt_ ();

    ffeste_io_end_ = NULL_TREE;

    if (errl)
      {
	/* Have ERR= specification.   */

	ffeste_io_err_
	  = ffeste_io_abort_
	  = ffecom_lookup_label
	  (info->write_spec[FFESTP_writeixERR].u.label);
	ffeste_io_abort_is_temp_ = FALSE;
      }
    else
      {
	/* No ERR= specification.  */

	ffeste_io_err_ = NULL_TREE;

	if ((ffeste_io_abort_is_temp_ = iostat))
	  ffeste_io_abort_ = ffecom_temp_label ();
	else
	  ffeste_io_abort_ = NULL_TREE;
      }

    if (iostat)
      {
	/* Have IOSTAT= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = ffecom_expr
	  (info->write_spec[FFESTP_writeixIOSTAT].u.expr);
      }
    else if (ffeste_io_abort_ != NULL_TREE)
      {
	/* Have no IOSTAT= but have ERR=.  */

	ffeste_io_iostat_is_temp_ = TRUE;
	ffeste_io_iostat_
	  = ffecom_make_tempvar ("write", ffecom_integer_type_node,
				 FFETARGET_charactersizeNONE, -1);
      }
    else
      {
	/* No IOSTAT= or ERR= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = NULL_TREE;
      }

    /* Now prescan, then convert, all the arguments.  */

    if (unit == FFESTV_unitCHAREXPR)
      cilist = ffeste_io_icilist_ (errl || iostat,
				   info->write_spec[FFESTP_writeixUNIT].u.expr,
				   FALSE, format,
				   &info->write_spec[FFESTP_writeixFORMAT]);
    else
      cilist = ffeste_io_cilist_ (errl || iostat, unit,
				  info->write_spec[FFESTP_writeixUNIT].u.expr,
				  6, FALSE, format,
				  &info->write_spec[FFESTP_writeixFORMAT],
				  rec,
				  info->write_spec[FFESTP_writeixREC].u.expr);

    /* If there is no end function, then there are no item functions (i.e.
       it's a NAMELIST), and vice versa by the way.  In this situation, don't
       generate the "if (iostat != 0) goto label;" if the label is temp abort
       label, since we're gonna fall through to there anyway.  */

    ffeste_io_call_ (ffecom_call_gfrt (start, cilist, NULL_TREE),
		     (! ffeste_io_abort_is_temp_) || (end != FFECOM_gfrt));
  }
#else
#error
#endif
}

/* WRITE statement -- I/O item.  */

void
ffeste_R910_item (ffebld expr, ffelexToken expr_token)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  if (expr == NULL)
    return;

  if (ffebld_op (expr) == FFEBLD_opANY)
    return;

  if (ffebld_op (expr) == FFEBLD_opIMPDO)
    ffeste_io_impdo_ (expr, expr_token);
  else
    {
      ffeste_start_stmt_ ();

      ffecom_prepare_arg_ptr_to_expr (expr);

      ffecom_prepare_end ();

      ffeste_io_call_ ((*ffeste_io_driver_) (expr), TRUE);

      ffeste_end_stmt_ ();
    }
#else
#error
#endif
}

/* WRITE statement -- end.  */

void
ffeste_R910_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
     label, since we're gonna fall through to there anyway. */

  if (ffeste_io_endgfrt_ != FFECOM_gfrt)
    ffeste_io_call_ (ffecom_call_gfrt (ffeste_io_endgfrt_, NULL_TREE,
				       NULL_TREE),
		     ! ffeste_io_abort_is_temp_);

  /* If we've got a temp label, generate its code here. */

  if (ffeste_io_abort_is_temp_)
    {
      DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
      emit_nop ();
      expand_label (ffeste_io_abort_);

      assert (ffeste_io_err_ == NULL_TREE);
    }

  ffeste_end_stmt_ ();
#else
#error
#endif
}

/* PRINT statement -- start.  */

void
ffeste_R911_start (ffestpPrintStmt *info, ffestvFormat format)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      fputs ("+ PRINT_fm ", dmpout);
      break;

    case FFESTV_formatASTERISK:
      fputs ("+ PRINT_ls ", dmpout);
      break;

    case FFESTV_formatNAMELIST:
      fputs ("+ PRINT_nl ", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in R911 PRINT" == NULL);
    }
  ffeste_subr_file_ ("FORMAT", &info->print_spec[FFESTP_printixFORMAT]);
  fputc (' ', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  ffeste_emit_line_note_ ();

  {
    ffecomGfrt start;
    ffecomGfrt end;
    tree cilist;

    /* First determine the start, per-item, and end run-time functions to
       call.  The per-item function is picked by choosing an ffeste function
       to call to handle a given item; it knows how to generate a call to the
       appropriate run-time function, and is called an "I/O driver".  */

    switch (format)
      {
      case FFESTV_formatLABEL:	/* FMT=10 */
      case FFESTV_formatCHAREXPR:	/* FMT='(I10)' */
      case FFESTV_formatINTEXPR:	/* FMT=I [after ASSIGN 10 TO I] */
	ffeste_io_driver_ = ffeste_io_dofio_;
	start = FFECOM_gfrtSWSFE, end = FFECOM_gfrtEWSFE;
	break;

      case FFESTV_formatASTERISK:	/* FMT=* */
	ffeste_io_driver_ = ffeste_io_dolio_;
	start = FFECOM_gfrtSWSLE, end = FFECOM_gfrtEWSLE;
	break;

      case FFESTV_formatNAMELIST:	/* FMT=FOO or NML=FOO [NAMELIST
					   /FOO/] */
	ffeste_io_driver_ = NULL;	/* No start or driver function. */
	start = FFECOM_gfrtSWSNE, end = FFECOM_gfrt;
	break;

      default:
	assert ("Weird stuff" == NULL);
	start = FFECOM_gfrt, end = FFECOM_gfrt;
	break;
      }
    ffeste_io_endgfrt_ = end;

    ffeste_start_stmt_ ();

    ffeste_io_end_ = NULL_TREE;
    ffeste_io_err_ = NULL_TREE;
    ffeste_io_abort_ = NULL_TREE;
    ffeste_io_abort_is_temp_ = FALSE;
    ffeste_io_iostat_is_temp_ = FALSE;
    ffeste_io_iostat_ = NULL_TREE;

    /* Now prescan, then convert, all the arguments.  */

    cilist = ffeste_io_cilist_ (FALSE, FFESTV_unitNONE, NULL, 6, FALSE, format,
		      &info->print_spec[FFESTP_printixFORMAT], FALSE, NULL);

    /* If there is no end function, then there are no item functions (i.e.
       it's a NAMELIST), and vice versa by the way.  In this situation, don't
       generate the "if (iostat != 0) goto label;" if the label is temp abort
       label, since we're gonna fall through to there anyway.  */

    ffeste_io_call_ (ffecom_call_gfrt (start, cilist, NULL_TREE),
		     (! ffeste_io_abort_is_temp_) || (end != FFECOM_gfrt));
  }
#else
#error
#endif
}

/* PRINT statement -- I/O item.  */

void
ffeste_R911_item (ffebld expr, ffelexToken expr_token)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  if (expr == NULL)
    return;

  if (ffebld_op (expr) == FFEBLD_opANY)
    return;

  if (ffebld_op (expr) == FFEBLD_opIMPDO)
    ffeste_io_impdo_ (expr, expr_token);
  else
    {
      ffeste_start_stmt_ ();

      ffecom_prepare_arg_ptr_to_expr (expr);

      ffecom_prepare_end ();

      ffeste_io_call_ ((*ffeste_io_driver_) (expr), TRUE);

      ffeste_end_stmt_ ();
    }
#else
#error
#endif
}

/* PRINT statement -- end.  */

void
ffeste_R911_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC

  if (ffeste_io_endgfrt_ != FFECOM_gfrt)
    ffeste_io_call_ (ffecom_call_gfrt (ffeste_io_endgfrt_, NULL_TREE,
				       NULL_TREE),
		     FALSE);

  ffeste_end_stmt_ ();
#else
#error
#endif
}

/* BACKSPACE statement.  */

void
ffeste_R919 (ffestpBeruStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ BACKSPACE (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->beru_spec[FFESTP_beruixUNIT]);
  ffeste_subr_file_ ("ERR", &info->beru_spec[FFESTP_beruixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->beru_spec[FFESTP_beruixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_subr_beru_ (info, FFECOM_gfrtFBACK);
#else
#error
#endif
}

/* ENDFILE statement.  */

void
ffeste_R920 (ffestpBeruStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ ENDFILE (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->beru_spec[FFESTP_beruixUNIT]);
  ffeste_subr_file_ ("ERR", &info->beru_spec[FFESTP_beruixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->beru_spec[FFESTP_beruixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_subr_beru_ (info, FFECOM_gfrtFEND);
#else
#error
#endif
}

/* REWIND statement.  */

void
ffeste_R921 (ffestpBeruStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ REWIND (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->beru_spec[FFESTP_beruixUNIT]);
  ffeste_subr_file_ ("ERR", &info->beru_spec[FFESTP_beruixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->beru_spec[FFESTP_beruixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  ffeste_subr_beru_ (info, FFECOM_gfrtFREW);
#else
#error
#endif
}

/* INQUIRE statement (non-IOLENGTH version).  */

void
ffeste_R923A (ffestpInquireStmt *info, bool by_file UNUSED)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if (by_file)
    {
      fputs ("+ INQUIRE_file (", dmpout);
      ffeste_subr_file_ ("FILE", &info->inquire_spec[FFESTP_inquireixFILE]);
    }
  else
    {
      fputs ("+ INQUIRE_unit (", dmpout);
      ffeste_subr_file_ ("UNIT", &info->inquire_spec[FFESTP_inquireixUNIT]);
    }
  ffeste_subr_file_ ("ACCESS", &info->inquire_spec[FFESTP_inquireixACCESS]);
  ffeste_subr_file_ ("ACTION", &info->inquire_spec[FFESTP_inquireixACTION]);
  ffeste_subr_file_ ("BLANK", &info->inquire_spec[FFESTP_inquireixBLANK]);
  ffeste_subr_file_ ("CARRIAGECONTROL", &info->inquire_spec[FFESTP_inquireixCARRIAGECONTROL]);
  ffeste_subr_file_ ("DEFAULTFILE", &info->inquire_spec[FFESTP_inquireixDEFAULTFILE]);
  ffeste_subr_file_ ("DELIM", &info->inquire_spec[FFESTP_inquireixDELIM]);
  ffeste_subr_file_ ("DIRECT", &info->inquire_spec[FFESTP_inquireixDIRECT]);
  ffeste_subr_file_ ("ERR", &info->inquire_spec[FFESTP_inquireixERR]);
  ffeste_subr_file_ ("EXIST", &info->inquire_spec[FFESTP_inquireixEXIST]);
  ffeste_subr_file_ ("FORM", &info->inquire_spec[FFESTP_inquireixFORM]);
  ffeste_subr_file_ ("FORMATTED", &info->inquire_spec[FFESTP_inquireixFORMATTED]);
  ffeste_subr_file_ ("IOSTAT", &info->inquire_spec[FFESTP_inquireixIOSTAT]);
  ffeste_subr_file_ ("KEYED", &info->inquire_spec[FFESTP_inquireixKEYED]);
  ffeste_subr_file_ ("NAME", &info->inquire_spec[FFESTP_inquireixNAME]);
  ffeste_subr_file_ ("NAMED", &info->inquire_spec[FFESTP_inquireixNAMED]);
  ffeste_subr_file_ ("NEXTREC", &info->inquire_spec[FFESTP_inquireixNEXTREC]);
  ffeste_subr_file_ ("NUMBER", &info->inquire_spec[FFESTP_inquireixNUMBER]);
  ffeste_subr_file_ ("OPENED", &info->inquire_spec[FFESTP_inquireixOPENED]);
  ffeste_subr_file_ ("ORGANIZATION", &info->inquire_spec[FFESTP_inquireixORGANIZATION]);
  ffeste_subr_file_ ("PAD", &info->inquire_spec[FFESTP_inquireixPAD]);
  ffeste_subr_file_ ("POSITION", &info->inquire_spec[FFESTP_inquireixPOSITION]);
  ffeste_subr_file_ ("READ", &info->inquire_spec[FFESTP_inquireixREAD]);
  ffeste_subr_file_ ("READWRITE", &info->inquire_spec[FFESTP_inquireixREADWRITE]);
  ffeste_subr_file_ ("RECL", &info->inquire_spec[FFESTP_inquireixRECL]);
  ffeste_subr_file_ ("RECORDTYPE", &info->inquire_spec[FFESTP_inquireixRECORDTYPE]);
  ffeste_subr_file_ ("SEQUENTIAL", &info->inquire_spec[FFESTP_inquireixSEQUENTIAL]);
  ffeste_subr_file_ ("UNFORMATTED", &info->inquire_spec[FFESTP_inquireixUNFORMATTED]);
  ffeste_subr_file_ ("WRITE", &info->inquire_spec[FFESTP_inquireixWRITE]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree args;
    bool iostat;
    bool errl;

    ffeste_emit_line_note_ ();

#define specified(something) (info->inquire_spec[something].kw_or_val_present)

    iostat = specified (FFESTP_inquireixIOSTAT);
    errl = specified (FFESTP_inquireixERR);

#undef specified

    ffeste_start_stmt_ ();

    if (errl)
      {
	ffeste_io_err_
	  = ffeste_io_abort_
	  = ffecom_lookup_label
	  (info->inquire_spec[FFESTP_inquireixERR].u.label);
	ffeste_io_abort_is_temp_ = FALSE;
      }
    else
      {
	ffeste_io_err_ = NULL_TREE;

	if ((ffeste_io_abort_is_temp_ = iostat))
	  ffeste_io_abort_ = ffecom_temp_label ();
	else
	  ffeste_io_abort_ = NULL_TREE;
      }

    if (iostat)
      {
	/* Have IOSTAT= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = ffecom_expr
	  (info->inquire_spec[FFESTP_inquireixIOSTAT].u.expr);
      }
    else if (ffeste_io_abort_ != NULL_TREE)
      {
	/* Have no IOSTAT= but have ERR=.  */

	ffeste_io_iostat_is_temp_ = TRUE;
	ffeste_io_iostat_
	  = ffecom_make_tempvar ("inquire", ffecom_integer_type_node,
				 FFETARGET_charactersizeNONE, -1);
      }
    else
      {
	/* No IOSTAT= or ERR= specification.  */

	ffeste_io_iostat_is_temp_ = FALSE;
	ffeste_io_iostat_ = NULL_TREE;
      }

    /* Now prescan, then convert, all the arguments.  */

    args
      = ffeste_io_inlist_ (errl || iostat,
			   &info->inquire_spec[FFESTP_inquireixUNIT],
			   &info->inquire_spec[FFESTP_inquireixFILE],
			   &info->inquire_spec[FFESTP_inquireixEXIST],
			   &info->inquire_spec[FFESTP_inquireixOPENED],
			   &info->inquire_spec[FFESTP_inquireixNUMBER],
			   &info->inquire_spec[FFESTP_inquireixNAMED],
			   &info->inquire_spec[FFESTP_inquireixNAME],
			   &info->inquire_spec[FFESTP_inquireixACCESS],
			   &info->inquire_spec[FFESTP_inquireixSEQUENTIAL],
			   &info->inquire_spec[FFESTP_inquireixDIRECT],
			   &info->inquire_spec[FFESTP_inquireixFORM],
			   &info->inquire_spec[FFESTP_inquireixFORMATTED],
			   &info->inquire_spec[FFESTP_inquireixUNFORMATTED],
			   &info->inquire_spec[FFESTP_inquireixRECL],
			   &info->inquire_spec[FFESTP_inquireixNEXTREC],
			   &info->inquire_spec[FFESTP_inquireixBLANK]);

    /* Don't generate "if (iostat != 0) goto label;" if label is temp abort
       label, since we're gonna fall through to there anyway. */

    ffeste_io_call_ (ffecom_call_gfrt (FFECOM_gfrtFINQU, args, NULL_TREE),
		     ! ffeste_io_abort_is_temp_);

    /* If we've got a temp label, generate its code here.  */

    if (ffeste_io_abort_is_temp_)
      {
	DECL_INITIAL (ffeste_io_abort_) = error_mark_node;
	emit_nop ();
	expand_label (ffeste_io_abort_);

	assert (ffeste_io_err_ == NULL_TREE);
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* INQUIRE(IOLENGTH=expr) statement -- start.  */

void
ffeste_R923B_start (ffestpInquireStmt *info UNUSED)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ INQUIRE (", dmpout);
  ffeste_subr_file_ ("IOLENGTH", &info->inquire_spec[FFESTP_inquireixIOLENGTH]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  assert ("INQUIRE(IOLENGTH=<var>) not implemented yet! ~~~" == NULL);

  ffeste_emit_line_note_ ();
#else
#error
#endif
}

/* INQUIRE(IOLENGTH=expr) statement -- I/O item.  */

void
ffeste_R923B_item (ffebld expr UNUSED)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* INQUIRE(IOLENGTH=expr) statement -- end.  */

void
ffeste_R923B_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ffeste_R1001 -- FORMAT statement

   ffeste_R1001(format_list);  */

void
ffeste_R1001 (ffests s)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "$ FORMAT %.*s\n", (int) ffests_length (s), ffests_text (s));
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree t;
    tree ttype;
    tree maxindex;
    tree var;

    assert (ffeste_label_formatdef_ != NULL);

    ffeste_emit_line_note_ ();

    t = build_string (ffests_length (s), ffests_text (s));

    TREE_TYPE (t)
      = build_type_variant (build_array_type
			    (char_type_node,
			     build_range_type (integer_type_node,
					       integer_one_node,
					     build_int_2 (ffests_length (s),
							  0))),
			    1, 0);
    TREE_CONSTANT (t) = 1;
    TREE_STATIC (t) = 1;

    push_obstacks_nochange ();
    end_temporary_allocation ();

    var = ffecom_lookup_label (ffeste_label_formatdef_);
    if ((var != NULL_TREE)
	&& (TREE_CODE (var) == VAR_DECL))
      {
	DECL_INITIAL (var) = t;
	maxindex = build_int_2 (ffests_length (s) - 1, 0);
	ttype = TREE_TYPE (var);
	TYPE_DOMAIN (ttype) = build_range_type (integer_type_node,
						integer_zero_node,
						maxindex);
	if (!TREE_TYPE (maxindex))
	  TREE_TYPE (maxindex) = TYPE_DOMAIN (ttype);
	layout_type (ttype);
	rest_of_decl_compilation (var, NULL, 1, 0);
	expand_decl (var);
	expand_decl_init (var);
      }

    resume_temporary_allocation ();
    pop_obstacks ();

    ffeste_label_formatdef_ = NULL;
  }
#else
#error
#endif
}

/* END PROGRAM.  */

void
ffeste_R1103 ()
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_PROGRAM\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* END BLOCK DATA.  */

void
ffeste_R1112 ()
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("* END_BLOCK_DATA\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* CALL statement.  */

void
ffeste_R1212 (ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ CALL ", dmpout);
  ffebld_dump (expr);
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    ffebld args = ffebld_right (expr);
    ffebld arg;
    ffebld labels = NULL;	/* First in list of LABTERs. */
    ffebld prevlabels = NULL;
    ffebld prevargs = NULL;

    ffeste_emit_line_note_ ();

    /* Here we split the list at ffebld_right(expr) into two lists: one at
       ffebld_right(expr) consisting of all items that are not LABTERs, the
       other at labels consisting of all items that are LABTERs.  Then, if
       the latter list is NULL, we have an ordinary call, else we have a call
       with alternate returns. */

    for (args = ffebld_right (expr); args != NULL; args = ffebld_trail (args))
      {
	if (((arg = ffebld_head (args)) == NULL)
	    || (ffebld_op (arg) != FFEBLD_opLABTER))
	  {
	    if (prevargs == NULL)
	      {
		prevargs = args;
		ffebld_set_right (expr, args);
	      }
	    else
	      {
		ffebld_set_trail (prevargs, args);
		prevargs = args;
	      }
	  }
	else
	  {
	    if (prevlabels == NULL)
	      {
		prevlabels = labels = args;
	      }
	    else
	      {
		ffebld_set_trail (prevlabels, args);
		prevlabels = args;
	      }
	  }
      }
    if (prevlabels == NULL)
      labels = NULL;
    else
      ffebld_set_trail (prevlabels, NULL);
    if (prevargs == NULL)
      ffebld_set_right (expr, NULL);
    else
      ffebld_set_trail (prevargs, NULL);

    ffeste_start_stmt_ ();

    /* No temporaries are actually needed at this level, but we go
       through the motions anyway, just to be sure in case they do
       get made.  Temporaries needed for arguments should be in the
       scopes of inner blocks, and if clean-up actions are supported,
       such as CALL-ing an intrinsic that writes to an argument of one
       type when a variable of a different type is provided (requiring
       assignment to the variable from a temporary after the library
       routine returns), the clean-up must be done by the expression
       evaluator, generally, to handle alternate returns (which we hope
       won't ever be supported by intrinsics, but might be a similar
       issue, such as CALL-ing an F90-style subroutine with an INTERFACE
       block).  That implies the expression evaluator will have to
       recognize the need for its own temporary anyway, meaning it'll
       construct a block within the one constructed here.  */

    ffecom_prepare_expr (expr);

    ffecom_prepare_end ();

    if (labels == NULL)
      expand_expr_stmt (ffecom_expr (expr));
    else
      {
	tree texpr;
	tree value;
	tree tlabel;
	int caseno;
	int pushok;
	tree duplicate;
	ffebld label;

	texpr = ffecom_expr (expr);
	expand_start_case (0, texpr, TREE_TYPE (texpr), "CALL statement");

	for (caseno = 1, label = labels;
	     label != NULL;
	     ++caseno, label = ffebld_trail (label))
	  {
	    value = build_int_2 (caseno, 0);
	    tlabel = build_decl (LABEL_DECL, NULL_TREE, NULL_TREE);

	    pushok = pushcase (value, convert, tlabel, &duplicate);
	    assert (pushok == 0);

	    tlabel
	      = ffecom_lookup_label (ffebld_labter (ffebld_head (label)));
	    if ((tlabel == NULL_TREE)
		|| (TREE_CODE (tlabel) == ERROR_MARK))
	      continue;
	    TREE_USED (tlabel) = 1;
	    expand_goto (tlabel);
	  }

	expand_end_case (texpr);
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* END FUNCTION.  */

void
ffeste_R1221 ()
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ END_FUNCTION\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* END SUBROUTINE.  */

void
ffeste_R1225 ()
{
#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ END_SUBROUTINE\n");
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ENTRY statement.  */

void
ffeste_R1226 (ffesymbol entry)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fprintf (dmpout, "+ ENTRY %s", ffesymbol_text (entry));
  if (ffesymbol_dummyargs (entry) != NULL)
    {
      ffebld argh;

      fputc ('(', dmpout);
      for (argh = ffesymbol_dummyargs (entry);
	   argh != NULL;
	   argh = ffebld_trail (argh))
	{
	  assert (ffebld_head (argh) != NULL);
	  switch (ffebld_op (ffebld_head (argh)))
	    {
	    case FFEBLD_opSYMTER:
	      fputs (ffesymbol_text (ffebld_symter (ffebld_head (argh))),
		     dmpout);
	      break;

	    case FFEBLD_opSTAR:
	      fputc ('*', dmpout);
	      break;

	    default:
	      fputc ('?', dmpout);
	      ffebld_dump (ffebld_head (argh));
	      fputc ('?', dmpout);
	      break;
	    }
	  if (ffebld_trail (argh) != NULL)
	    fputc (',', dmpout);
	}
      fputc (')', dmpout);
    }
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree label = ffesymbol_hook (entry).length_tree;

    ffeste_emit_line_note_ ();

    if (label == error_mark_node)
      return;

    DECL_INITIAL (label) = error_mark_node;
    emit_nop ();
    expand_label (label);
  }
#else
#error
#endif
}

/* RETURN statement.  */

void
ffeste_R1227 (ffestw block UNUSED, ffebld expr)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  if (expr == NULL)
    {
      fputs ("+ RETURN\n", dmpout);
    }
  else
    {
      fputs ("+ RETURN_alternate ", dmpout);
      ffebld_dump (expr);
      fputc ('\n', dmpout);
    }
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
  {
    tree rtn;

    ffeste_emit_line_note_ ();

    ffeste_start_stmt_ ();

    ffecom_prepare_return_expr (expr);

    ffecom_prepare_end ();

    rtn = ffecom_return_expr (expr);

    if ((rtn == NULL_TREE)
	|| (rtn == error_mark_node))
      expand_null_return ();
    else
      {
	tree result = DECL_RESULT (current_function_decl);

	if ((result != error_mark_node)
	    && (TREE_TYPE (result) != error_mark_node))
	  expand_return (ffecom_modify (NULL_TREE,
					result,
					convert (TREE_TYPE (result),
						 rtn)));
	else
	  expand_null_return ();
      }

    ffeste_end_stmt_ ();
  }
#else
#error
#endif
}

/* REWRITE statement -- start.  */

#if FFESTR_VXT
void
ffeste_V018_start (ffestpRewriteStmt *info, ffestvFormat format)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatNONE:
      fputs ("+ REWRITE_uf (", dmpout);
      break;

    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      fputs ("+ REWRITE_fm (", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in V018 REWRITE" == NULL);
    }
  ffeste_subr_file_ ("UNIT", &info->rewrite_spec[FFESTP_rewriteixUNIT]);
  ffeste_subr_file_ ("FMT", &info->rewrite_spec[FFESTP_rewriteixFMT]);
  ffeste_subr_file_ ("ERR", &info->rewrite_spec[FFESTP_rewriteixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->rewrite_spec[FFESTP_rewriteixIOSTAT]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* REWRITE statement -- I/O item.  */

void
ffeste_V018_item (ffebld expr)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* REWRITE statement -- end.  */

void
ffeste_V018_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ACCEPT statement -- start.  */

void
ffeste_V019_start (ffestpAcceptStmt *info, ffestvFormat format)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      fputs ("+ ACCEPT_fm ", dmpout);
      break;

    case FFESTV_formatASTERISK:
      fputs ("+ ACCEPT_ls ", dmpout);
      break;

    case FFESTV_formatNAMELIST:
      fputs ("+ ACCEPT_nl ", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in V019 ACCEPT" == NULL);
    }
  ffeste_subr_file_ ("FORMAT", &info->accept_spec[FFESTP_acceptixFORMAT]);
  fputc (' ', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ACCEPT statement -- I/O item.  */

void
ffeste_V019_item (ffebld expr)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ACCEPT statement -- end.  */

void
ffeste_V019_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

#endif
/* TYPE statement -- start.  */

void
ffeste_V020_start (ffestpTypeStmt *info UNUSED,
		   ffestvFormat format UNUSED)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  switch (format)
    {
    case FFESTV_formatLABEL:
    case FFESTV_formatCHAREXPR:
    case FFESTV_formatINTEXPR:
      fputs ("+ TYPE_fm ", dmpout);
      break;

    case FFESTV_formatASTERISK:
      fputs ("+ TYPE_ls ", dmpout);
      break;

    case FFESTV_formatNAMELIST:
      fputs ("* TYPE_nl ", dmpout);
      break;

    default:
      assert ("Unexpected kind of format item in V020 TYPE" == NULL);
    }
  ffeste_subr_file_ ("FORMAT", &info->type_spec[FFESTP_typeixFORMAT]);
  fputc (' ', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* TYPE statement -- I/O item.  */

void
ffeste_V020_item (ffebld expr UNUSED)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* TYPE statement -- end.  */

void
ffeste_V020_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DELETE statement.  */

#if FFESTR_VXT
void
ffeste_V021 (ffestpDeleteStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ DELETE (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->delete_spec[FFESTP_deleteixUNIT]);
  ffeste_subr_file_ ("REC", &info->delete_spec[FFESTP_deleteixREC]);
  ffeste_subr_file_ ("ERR", &info->delete_spec[FFESTP_deleteixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->delete_spec[FFESTP_deleteixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* UNLOCK statement.  */

void
ffeste_V022 (ffestpBeruStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ UNLOCK (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->beru_spec[FFESTP_beruixUNIT]);
  ffeste_subr_file_ ("ERR", &info->beru_spec[FFESTP_beruixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->beru_spec[FFESTP_beruixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ENCODE statement -- start.  */

void
ffeste_V023_start (ffestpVxtcodeStmt *info)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ ENCODE (", dmpout);
  ffeste_subr_file_ ("C", &info->vxtcode_spec[FFESTP_vxtcodeixC]);
  ffeste_subr_file_ ("F", &info->vxtcode_spec[FFESTP_vxtcodeixF]);
  ffeste_subr_file_ ("B", &info->vxtcode_spec[FFESTP_vxtcodeixB]);
  ffeste_subr_file_ ("ERR", &info->vxtcode_spec[FFESTP_vxtcodeixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->vxtcode_spec[FFESTP_vxtcodeixIOSTAT]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ENCODE statement -- I/O item.  */

void
ffeste_V023_item (ffebld expr)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* ENCODE statement -- end.  */

void
ffeste_V023_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DECODE statement -- start.  */

void
ffeste_V024_start (ffestpVxtcodeStmt *info)
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ DECODE (", dmpout);
  ffeste_subr_file_ ("C", &info->vxtcode_spec[FFESTP_vxtcodeixC]);
  ffeste_subr_file_ ("F", &info->vxtcode_spec[FFESTP_vxtcodeixF]);
  ffeste_subr_file_ ("B", &info->vxtcode_spec[FFESTP_vxtcodeixB]);
  ffeste_subr_file_ ("ERR", &info->vxtcode_spec[FFESTP_vxtcodeixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->vxtcode_spec[FFESTP_vxtcodeixIOSTAT]);
  fputs (") ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DECODE statement -- I/O item.  */

void
ffeste_V024_item (ffebld expr)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (expr);
  fputc (',', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DECODE statement -- end.  */

void
ffeste_V024_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DEFINEFILE statement -- start.  */

void
ffeste_V025_start ()
{
  ffeste_check_start_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ DEFINE_FILE ", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DEFINE FILE statement -- item.  */

void
ffeste_V025_item (ffebld u, ffebld m, ffebld n, ffebld asv)
{
  ffeste_check_item_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  ffebld_dump (u);
  fputc ('(', dmpout);
  ffebld_dump (m);
  fputc (',', dmpout);
  ffebld_dump (n);
  fputs (",U,", dmpout);
  ffebld_dump (asv);
  fputs ("),", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* DEFINE FILE statement -- end.  */

void
ffeste_V025_finish ()
{
  ffeste_check_finish_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputc ('\n', dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

/* FIND statement.  */

void
ffeste_V026 (ffestpFindStmt *info)
{
  ffeste_check_simple_ ();

#if FFECOM_targetCURRENT == FFECOM_targetFFE
  fputs ("+ FIND (", dmpout);
  ffeste_subr_file_ ("UNIT", &info->find_spec[FFESTP_findixUNIT]);
  ffeste_subr_file_ ("REC", &info->find_spec[FFESTP_findixREC]);
  ffeste_subr_file_ ("ERR", &info->find_spec[FFESTP_findixERR]);
  ffeste_subr_file_ ("IOSTAT", &info->find_spec[FFESTP_findixIOSTAT]);
  fputs (")\n", dmpout);
#elif FFECOM_targetCURRENT == FFECOM_targetGCC
#else
#error
#endif
}

#endif

#ifdef ENABLE_CHECKING
void
ffeste_terminate_2 (void)
{
  assert (! ffeste_top_block_);
}
#endif