t = ffesymbol_hook (s).decl_tree;
ffecom_expr_ (ffebld expr, tree dest_tree,	      ffebld dest, bool *dest_used,	      bool assignp){  tree item;  tree list;  tree args;  ffeinfoBasictype bt;  ffeinfoKindtype kt;  tree t;  tree tree_type;  tree dt;			/* decl_tree for an ffesymbol. */  ffesymbol s;  enum tree_code code;  assert (expr != NULL);  if (dest_used != NULL)    *dest_used = FALSE;  bt = ffeinfo_basictype (ffebld_info (expr));  kt = ffeinfo_kindtype (ffebld_info (expr));  switch (ffebld_op (expr))    {    case FFEBLD_opACCTER:      tree_type = ffecom_tree_type[bt][kt];      {	ffetargetOffset i;	ffebit bits = ffebld_accter_bits (expr);	ffetargetOffset source_offset = 0;	size_t size;	tree purpose;	size = ffetype_size (ffeinfo_type (bt, kt));	list = item = NULL;	for (;;)	  {	    ffebldConstantUnion cu;	    ffebitCount length;	    bool value;	    ffebldConstantArray ca = ffebld_accter (expr);	    ffebit_test (bits, source_offset, &value, &length);	    if (length == 0)	      break;	    if (value)	      {		for (i = 0; i < length; ++i)		  {		    cu = ffebld_constantarray_get (ca, bt, kt,						   source_offset + i);		    t = ffecom_constantunion (&cu, bt, kt, tree_type);		    if (i == 0)		      purpose = build_int_2 (source_offset, 0);		    else		      purpose = NULL_TREE;		    if (list == NULL_TREE)		      list = item = build_tree_list (purpose, t);		    else		      {			TREE_CHAIN (item) = build_tree_list (purpose, t);			item = TREE_CHAIN (item);		      }		  }	      }	    source_offset += length;	  }      }      item = build_int_2 (ffebld_accter_size (expr), 0);      ffebit_kill (ffebld_accter_bits (expr));      TREE_TYPE (item) = ffecom_integer_type_node;      item	= build_array_type	  (tree_type,	   build_range_type (ffecom_integer_type_node,			     ffecom_integer_zero_node,			     item));      list = build (CONSTRUCTOR, item, NULL_TREE, list);      TREE_CONSTANT (list) = 1;      TREE_STATIC (list) = 1;      return list;    case FFEBLD_opARRTER:      tree_type = ffecom_tree_type[bt][kt];      {	ffetargetOffset i;	list = item = NULL_TREE;	for (i = 0; i < ffebld_arrter_size (expr); ++i)	  {	    ffebldConstantUnion cu	    = ffebld_constantarray_get (ffebld_arrter (expr), bt, kt, i);	    t = ffecom_constantunion (&cu, bt, kt, tree_type);	    if (list == NULL_TREE)	      list = item = build_tree_list (NULL_TREE, t);	    else	      {		TREE_CHAIN (item) = build_tree_list (NULL_TREE, t);		item = TREE_CHAIN (item);	      }	  }      }      item = build_int_2 (ffebld_arrter_size (expr), 0);      TREE_TYPE (item) = ffecom_integer_type_node;      item	= build_array_type	  (tree_type,	   build_range_type (ffecom_integer_type_node,			     ffecom_integer_one_node,			     item));      list = build (CONSTRUCTOR, item, NULL_TREE, list);      TREE_CONSTANT (list) = 1;      TREE_STATIC (list) = 1;      return list;    case FFEBLD_opCONTER:      tree_type = ffecom_tree_type[bt][kt];      item	= ffecom_constantunion (&ffebld_constant_union (ffebld_conter (expr)),				bt, kt, tree_type);      return item;    case FFEBLD_opSYMTER:      if ((ffebld_symter_generic (expr) != FFEINTRIN_genNONE)	  || (ffebld_symter_specific (expr) != FFEINTRIN_specNONE))	return ffecom_ptr_to_expr (expr);	/* Same as %REF(intrinsic). */      s = ffebld_symter (expr);      if (assignp)	{			/* ASSIGN'ed-label expr. */	  t = ffesymbol_hook (s).decl_tree;	  if (t != NULL_TREE)	    DECL_IN_SYSTEM_HEADER (t) = 1;	/* Don't let -Wunused complain. */	  t = ffesymbol_hook (s).assign_tree;	  if (t == NULL_TREE)	    {	      s = ffecom_sym_transform_assign_ (s);	      t = ffesymbol_hook (s).assign_tree;	      assert (t != NULL_TREE);	    }	}      else	{	  t = ffesymbol_hook (s).decl_tree;	  if (t == NULL_TREE)	    {	      s = ffecom_sym_transform_ (s);	      t = ffesymbol_hook (s).decl_tree;	      assert (t != NULL_TREE);	    }	  if (ffesymbol_hook (s).addr)	    t = ffecom_1 (INDIRECT_REF,			  TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (t))), t);	}      return t;    case FFEBLD_opARRAYREF:      {	ffebld dims[FFECOM_dimensionsMAX];#if FFECOM_FASTER_ARRAY_REFS	tree array;#endif	int i;#if FFECOM_FASTER_ARRAY_REFS	t = ffecom_ptr_to_expr (ffebld_left (expr));#else	t = ffecom_expr (ffebld_left (expr));#endif	if (t == error_mark_node)	  return t;	if ((ffeinfo_where (ffebld_info (expr)) == FFEINFO_whereFLEETING)	    && !mark_addressable (t))	  return error_mark_node;	/* Make sure non-const ref is to					   non-reg. */	/* Build up ARRAY_REFs in reverse order (since we're column major	   here in Fortran land). */	for (i = 0, expr = ffebld_right (expr);	     expr != NULL;	     expr = ffebld_trail (expr))	  dims[i++] = ffebld_head (expr);#if FFECOM_FASTER_ARRAY_REFS	for (--i, array = TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (t)));	     i >= 0;	     --i, array = TYPE_MAIN_VARIANT (TREE_TYPE (array)))	  t = ffecom_2 (PLUS_EXPR,			build_pointer_type (TREE_TYPE (array)),			t,			size_binop (MULT_EXPR,				    size_in_bytes (TREE_TYPE (array)),				    size_binop (MINUS_EXPR,						ffecom_expr (dims[i]),						TYPE_MIN_VALUE (TYPE_DOMAIN (array)))));	t = ffecom_1 (INDIRECT_REF,		      TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (t))),		      t);#else	while (i > 0)	  t = ffecom_2 (ARRAY_REF,			TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (t))),			t,			ffecom_expr (dims[--i]));#endif	return t;      }    case FFEBLD_opUPLUS:      tree_type = ffecom_tree_type[bt][kt];      return ffecom_1 (NOP_EXPR, tree_type, ffecom_expr (ffebld_left (expr)));    case FFEBLD_opPAREN:	/* ~~~Make sure Fortran rules respected here */      tree_type = ffecom_tree_type[bt][kt];      return ffecom_1 (NOP_EXPR, tree_type, ffecom_expr (ffebld_left (expr)));    case FFEBLD_opUMINUS:      tree_type = ffecom_tree_type[bt][kt];      return ffecom_1 (NEGATE_EXPR, tree_type,		       ffecom_expr (ffebld_left (expr)));    case FFEBLD_opADD:      tree_type = ffecom_tree_type[bt][kt];      return ffecom_2 (PLUS_EXPR, tree_type,		       ffecom_expr (ffebld_left (expr)),		       ffecom_expr (ffebld_right (expr)));      break;    case FFEBLD_opSUBTRACT:      tree_type = ffecom_tree_type[bt][kt];      return ffecom_2 (MINUS_EXPR, tree_type,		       ffecom_expr (ffebld_left (expr)),		       ffecom_expr (ffebld_right (expr)));    case FFEBLD_opMULTIPLY:      tree_type = ffecom_tree_type[bt][kt];      return ffecom_2 (MULT_EXPR, tree_type,		       ffecom_expr (ffebld_left (expr)),		       ffecom_expr (ffebld_right (expr)));    case FFEBLD_opDIVIDE:      tree_type = ffecom_tree_type[bt][kt];      return	ffecom_tree_divide_ (tree_type,			     ffecom_expr (ffebld_left (expr)),			     ffecom_expr (ffebld_right (expr)),			     dest_tree, dest, dest_used);    case FFEBLD_opPOWER:      tree_type = ffecom_tree_type[bt][kt];      {	ffebld left = ffebld_left (expr);	ffebld right = ffebld_right (expr);	ffecomGfrt code;	ffeinfoKindtype rtkt;	switch (ffeinfo_basictype (ffebld_info (right)))	  {	  case FFEINFO_basictypeINTEGER:	    if (1 || optimize)	      {		item = ffecom_expr_power_integer_ (left, right);		if (item != NULL_TREE)		  return item;	      }	    rtkt = FFEINFO_kindtypeINTEGER1;	    switch (ffeinfo_basictype (ffebld_info (left)))	      {	      case FFEINFO_basictypeINTEGER:		if ((ffeinfo_kindtype (ffebld_info (left))		    == FFEINFO_kindtypeINTEGER4)		    || (ffeinfo_kindtype (ffebld_info (right))			== FFEINFO_kindtypeINTEGER4))		  {		    code = FFECOM_gfrtPOW_QQ;		    rtkt = FFEINFO_kindtypeINTEGER4;		  }		else		  code = FFECOM_gfrtPOW_II;		break;	      case FFEINFO_basictypeREAL:		if (ffeinfo_kindtype (ffebld_info (left))		    == FFEINFO_kindtypeREAL1)		  code = FFECOM_gfrtPOW_RI;		else		  code = FFECOM_gfrtPOW_DI;		break;	      case FFEINFO_basictypeCOMPLEX:		if (ffeinfo_kindtype (ffebld_info (left))		    == FFEINFO_kindtypeREAL1)		  code = FFECOM_gfrtPOW_CI;	/* Overlapping result okay. */		else		  {		    code = FFECOM_gfrtPOW_ZI;		    dest_used = NULL;	/* This one doesn't work with overlapping result. */		  }		break;	      default:		assert ("bad pow_*i" == NULL);		code = FFECOM_gfrtPOW_CI;	/* Overlapping result okay. */		break;	      }	    if (ffeinfo_kindtype (ffebld_info (left)) != rtkt)	      left = ffeexpr_convert (left, NULL, NULL,				      FFEINFO_basictypeINTEGER,				      rtkt, 0,				      FFETARGET_charactersizeNONE,				      FFEEXPR_contextLET);	    if (ffeinfo_kindtype (ffebld_info (right)) != rtkt)	      right = ffeexpr_convert (right, NULL, NULL,				       FFEINFO_basictypeINTEGER,				       rtkt, 0,				       FFETARGET_charactersizeNONE,				       FFEEXPR_contextLET);	    break;	  case FFEINFO_basictypeREAL:	    if (ffeinfo_kindtype (ffebld_info (left)) == FFEINFO_kindtypeREAL1)	      left = ffeexpr_convert (left, NULL, NULL, FFEINFO_basictypeREAL,				      FFEINFO_kindtypeREALDOUBLE, 0,				      FFETARGET_charactersizeNONE,				      FFEEXPR_contextLET);	    if (ffeinfo_kindtype (ffebld_info (right))		== FFEINFO_kindtypeREAL1)	      right = ffeexpr_convert (right, NULL, NULL,				       FFEINFO_basictypeREAL,				       FFEINFO_kindtypeREALDOUBLE, 0,				       FFETARGET_charactersizeNONE,				       FFEEXPR_contextLET);	    code = FFECOM_gfrtPOW_DD;	    break;	  case FFEINFO_basictypeCOMPLEX:	    if (ffeinfo_kindtype (ffebld_info (left)) == FFEINFO_kindtypeREAL1)	      left = ffeexpr_convert (left, NULL, NULL,				      FFEINFO_basictypeCOMPLEX,				      FFEINFO_kindtypeREALDOUBLE, 0,				      FFETARGET_charactersizeNONE,				      FFEEXPR_contextLET);	    if (ffeinfo_kindtype (ffebld_info (right))		== FFEINFO_kindtypeREAL1)	      right = ffeexpr_convert (right, NULL, NULL,				       FFEINFO_basictypeCOMPLEX,				       FFEINFO_kindtypeREALDOUBLE, 0,				       FFETARGET_charactersizeNONE,				       FFEEXPR_contextLET);	    code = FFECOM_gfrtPOW_ZZ;	/* Overlapping result okay. */	    break;	  default:	    assert ("bad pow_x*" == NULL);	    code = FFECOM_gfrtPOW_II;	    break;	  }	return ffecom_call_binop_ (ffecom_gfrt_tree_ (code),				   ffecom_gfrt_kind_type_ (code),				   (ffe_is_f2c_library ()				    && ffecom_gfrt_complex_[code]),				   tree_type, left, right,				   dest_tree, dest, dest_used,				   NULL_TREE, FALSE);      }    case FFEBLD_opNOT:      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	  item	    = ffecom_truth_value_invert (ffecom_expr (ffebld_left (expr)));	  return convert (tree_type, item);	case FFEINFO_basictypeINTEGER:	  return ffecom_1 (BIT_NOT_EXPR, tree_type,			   ffecom_expr (ffebld_left (expr)));	default:	  assert ("NOT bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opFUNCREF:      assert (ffeinfo_basictype (ffebld_info (expr))	      != FFEINFO_basictypeCHARACTER);      /* Fall through.	 */    case FFEBLD_opSUBRREF:      tree_type = ffecom_tree_type[bt][kt];      if (ffeinfo_where (ffebld_info (ffebld_left (expr)))	  == FFEINFO_whereINTRINSIC)	{			/* Invocation of an intrinsic. */	  item = ffecom_expr_intrinsic_ (expr, dest_tree, dest,					 dest_used);	  return item;	}      s = ffebld_symter (ffebld_left (expr));      dt = ffesymbol_hook (s).decl_tree;      if (dt == NULL_TREE)	{	  s = ffecom_sym_transform_ (s);	  dt = ffesymbol_hook (s).decl_tree;	}      if (dt == error_mark_node)	return dt;      if (ffesymbol_hook (s).addr)	item = dt;      else	item = ffecom_1_fn (dt);      ffecom_push_calltemps ();      if (ffesymbol_where (s) == FFEINFO_whereCONSTANT)	args = ffecom_list_expr (ffebld_right (expr));      else	args = ffecom_list_ptr_to_expr (ffebld_right (expr));      ffecom_pop_calltemps ();      item = ffecom_call_ (item, kt,			   ffesymbol_is_f2c (s)			   && (bt == FFEINFO_basictypeCOMPLEX)			   && (ffesymbol_where (s)			       != FFEINFO_whereCONSTANT),			   tree_type,			   args,			   dest_tree, dest, dest_used,			   error_mark_node, FALSE);      TREE_SIDE_EFFECTS (item) = 1;      return item;    case FFEBLD_opAND:      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	  item	    = ffecom_2 (TRUTH_ANDIF_EXPR, integer_type_node,		       ffecom_truth_value (ffecom_expr (ffebld_left (expr))),		     ffecom_truth_value (ffecom_expr (ffebld_right (expr))));	  return convert (tree_type, item);	case FFEINFO_basictypeINTEGER:	  return ffecom_2 (BIT_AND_EXPR, tree_type,			   ffecom_expr (ffebld_left (expr)),			   ffecom_expr (ffebld_right (expr)));	default:	  assert ("AND bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opOR:      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	  item	    = ffecom_2 (TRUTH_ORIF_EXPR, integer_type_node,		       ffecom_truth_value (ffecom_expr (ffebld_left (expr))),		     ffecom_truth_value (ffecom_expr (ffebld_right (expr))));	  return convert (tree_type, item);	case FFEINFO_basictypeINTEGER:	  return ffecom_2 (BIT_IOR_EXPR, tree_type,			   ffecom_expr (ffebld_left (expr)),			   ffecom_expr (ffebld_right (expr)));	default:	  assert ("OR bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opXOR:    case FFEBLD_opNEQV:      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	  item	    = ffecom_2 (NE_EXPR, integer_type_node,			ffecom_expr (ffebld_left (expr)),			ffecom_expr (ffebld_right (expr)));	  return convert (tree_type, ffecom_truth_value (item));	case FFEINFO_basictypeINTEGER:	  return ffecom_2 (BIT_XOR_EXPR, tree_type,			   ffecom_expr (ffebld_left (expr)),			   ffecom_expr (ffebld_right (expr)));	default:	  assert ("XOR/NEQV bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opEQV:      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	  item	    = ffecom_2 (EQ_EXPR, integer_type_node,			ffecom_expr (ffebld_left (expr)),			ffecom_expr (ffebld_right (expr)));	  return convert (tree_type, ffecom_truth_value (item));	case FFEINFO_basictypeINTEGER:	  return	    ffecom_1 (BIT_NOT_EXPR, tree_type,		      ffecom_2 (BIT_XOR_EXPR, tree_type,				ffecom_expr (ffebld_left (expr)),				ffecom_expr (ffebld_right (expr))));	default:	  assert ("EQV bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opCONVERT:      if (ffebld_op (ffebld_left (expr)) == FFEBLD_opANY)	return error_mark_node;      tree_type = ffecom_tree_type[bt][kt];      switch (bt)	{	case FFEINFO_basictypeLOGICAL:	case FFEINFO_basictypeINTEGER:	case FFEINFO_basictypeREAL:	  return convert (tree_type, ffecom_expr (ffebld_left (expr)));	case FFEINFO_basictypeCOMPLEX:	  switch (ffeinfo_basictype (ffebld_info (ffebld_left (expr))))	    {	    case FFEINFO_basictypeINTEGER:	    case FFEINFO_basictypeLOGICAL:	    case FFEINFO_basictypeREAL:	      item = ffecom_expr (ffebld_left (expr));	      if (item == error_mark_node)		return error_mark_node;	      item = convert (TREE_TYPE (tree_type), item);	      item = convert (tree_type, item);	      return item;	    case FFEINFO_basictypeCOMPLEX:	      return convert (tree_type, ffecom_expr (ffebld_left (expr)));	    default:	      assert ("CONVERT COMPLEX bad basictype" == NULL);	      /* Fall through. */	    case FFEINFO_basictypeANY:	      return error_mark_node;	    }	  break;	default:	  assert ("CONVERT bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opLT:      code = LT_EXPR;      goto relational;		/* :::::::::::::::::::: */    case FFEBLD_opLE:      code = LE_EXPR;      goto relational;		/* :::::::::::::::::::: */    case FFEBLD_opEQ:      code = EQ_EXPR;      goto relational;		/* :::::::::::::::::::: */    case FFEBLD_opNE:      code = NE_EXPR;      goto relational;		/* :::::::::::::::::::: */    case FFEBLD_opGT:      code = GT_EXPR;      goto relational;		/* :::::::::::::::::::: */    case FFEBLD_opGE:      code = GE_EXPR;    relational:		/* :::::::::::::::::::: */      tree_type = ffecom_tree_type[bt][kt];      switch (ffeinfo_basictype (ffebld_info (ffebld_left (expr))))	{	case FFEINFO_basictypeLOGICAL:	case FFEINFO_basictypeINTEGER:	case FFEINFO_basictypeREAL:	  item = ffecom_2 (code, integer_type_node,			   ffecom_expr (ffebld_left (expr)),			   ffecom_expr (ffebld_right (expr)));	  return convert (tree_type, item);	case FFEINFO_basictypeCOMPLEX:	  assert (code == EQ_EXPR || code == NE_EXPR);	  {	    tree real_type;	    tree arg1 = ffecom_expr (ffebld_left (expr));	    tree arg2 = ffecom_expr (ffebld_right (expr));	    if (arg1 == error_mark_node || arg2 == error_mark_node)	      return error_mark_node;	    arg1 = ffecom_save_tree (arg1);	    arg2 = ffecom_save_tree (arg2);	    real_type = TREE_TYPE (TREE_TYPE (arg1));	    assert (real_type == TREE_TYPE (TREE_TYPE (arg2)));	    item	      = ffecom_2 (TRUTH_ANDIF_EXPR, integer_type_node,			  ffecom_2 (EQ_EXPR, integer_type_node,				  ffecom_1 (REALPART_EXPR, real_type, arg1),				 ffecom_1 (REALPART_EXPR, real_type, arg2)),			  ffecom_2 (EQ_EXPR, integer_type_node,				  ffecom_1 (IMAGPART_EXPR, real_type, arg1),				    ffecom_1 (IMAGPART_EXPR, real_type,					      arg2)));	    if (code == EQ_EXPR)	      item = ffecom_truth_value (item);	    else	      item = ffecom_truth_value_invert (item);	    return convert (tree_type, item);	  }	case FFEINFO_basictypeCHARACTER:	  ffecom_push_calltemps ();	/* Even though we might not call. */	  {	    ffebld left = ffebld_left (expr);	    ffebld right = ffebld_right (expr);	    tree left_tree;	    tree right_tree;	    tree left_length;	    tree right_length;	    /* f2c run-time functions do the implicit blank-padding for us,	       so we don't usually have to implement blank-padding ourselves.	       (The exception is when we pass an argument to a separately	       compiled statement function -- if we know the arg is not the	       same length as the dummy, we must truncate or extend it.	 If	       we "inline" statement functions, that necessity goes away as	       well.)	       Strip off the CONVERT operators that blank-pad.  (Truncation by	       CONVERT shouldn't happen here, but it can happen in	       assignments.) */	    while (ffebld_op (left) == FFEBLD_opCONVERT)	      left = ffebld_left (left);	    while (ffebld_op (right) == FFEBLD_opCONVERT)	      right = ffebld_left (right);	    left_tree = ffecom_arg_ptr_to_expr (left, &left_length);	    right_tree = ffecom_arg_ptr_to_expr (right, &right_length);	    if (left_tree == error_mark_node || left_length == error_mark_node		|| right_tree == error_mark_node		|| right_length == error_mark_node)	      {		ffecom_pop_calltemps ();		return error_mark_node;	      }	    if ((ffebld_size_known (left) == 1)		&& (ffebld_size_known (right) == 1))	      {		left_tree		  = ffecom_1 (INDIRECT_REF,		      TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (left_tree))),			      left_tree);		right_tree		  = ffecom_1 (INDIRECT_REF,		     TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (right_tree))),			      right_tree);		item		  = ffecom_2 (code, integer_type_node,			      ffecom_2 (ARRAY_REF,		      TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (left_tree))),					left_tree,					integer_one_node),			      ffecom_2 (ARRAY_REF,		     TYPE_MAIN_VARIANT (TREE_TYPE (TREE_TYPE (right_tree))),					right_tree,					integer_one_node));	      }	    else	      {		item = build_tree_list (NULL_TREE, left_tree);		TREE_CHAIN (item) = build_tree_list (NULL_TREE, right_tree);		TREE_CHAIN (TREE_CHAIN (item)) = build_tree_list (NULL_TREE,							       left_length);		TREE_CHAIN (TREE_CHAIN (TREE_CHAIN (item)))		  = build_tree_list (NULL_TREE, right_length);		item = ffecom_call_gfrt (FFECOM_gfrtCMP, item);		item = ffecom_2 (code, integer_type_node,				 item,				 convert (TREE_TYPE (item),					  integer_zero_node));	      }	    item = convert (tree_type, item);	  }	  ffecom_pop_calltemps ();	  return item;	default:	  assert ("relational bad basictype" == NULL);	  /* Fall through. */	case FFEINFO_basictypeANY:	  return error_mark_node;	}      break;    case FFEBLD_opPERCENT_LOC:      tree_type = ffecom_tree_type[bt][kt];      item = ffecom_arg_ptr_to_expr (ffebld_left (expr), &list);      return convert (tree_type, item);    case FFEBLD_opITEM:    case FFEBLD_opSTAR:    case FFEBLD_opBOUNDS:    case FFEBLD_opREPEAT:    case FFEBLD_opLABTER:    case FFEBLD_opLABTOK:    case FFEBLD_opIMPDO:    case FFEBLD_opCONCATENATE:    case FFEBLD_opSUBSTR:    default:      assert ("bad op" == NULL);      /* Fall through. */    case FFEBLD_opANY:      return error_mark_node;    }#if 1  assert ("didn't think anything got here anymore!!" == NULL);#else  switch (ffebld_arity (expr))    {    case 2:      TREE_OPERAND (item, 0) = ffecom_expr (ffebld_left (expr));      TREE_OPERAND (item, 1) = ffecom_expr (ffebld_right (expr));      if (TREE_OPERAND (item, 0) == error_mark_node	  || TREE_OPERAND (item, 1) == error_mark_node)	return error_mark_node;      break;    case 1:      TREE_OPERAND (item, 0) = ffecom_expr (ffebld_left (expr));      if (TREE_OPERAND (item, 0) == error_mark_node)	return error_mark_node;      break;    default:      break;    }  return fold (item);#endif}