if (i == FFEINFO_basictypeCOMPLEX)
if (i == FFEINFO_basictypeINTEGER) {  if (GET_MODE_SIZE (TYPE_MODE (t)) >= GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (null_pointer_node)))) { if ((ffecom_pointer_kind_ == FFEINFO_kindtypeNONE) || (GET_MODE_SIZE (TYPE_MODE (ffecom_tree_type[i][ffecom_pointer_kind_])) > GET_MODE_SIZE (TYPE_MODE (t)))) ffecom_pointer_kind_ = j; } } else if (i == FFEINFO_basictypeCOMPLEX)
ffecom_init_0 (){  tree endlink;  int i;  int j;  tree t;  tree field;  ffetype type;  ffetype base_type;  /* This block of code comes from the now-obsolete cktyps.c.  It checks     whether the compiler environment is buggy in known ways, some of which     would, if not explicitly checked here, result in subtle bugs in g77.  */  {    static char names[][12]    =    {"bar", "bletch", "foo", "foobar"};    char *name;    unsigned long ul;    double fl;    name = bsearch ("foo", &names[0], ARRAY_SIZE (names), sizeof (names[0]),		    (int (*)()) strcmp);    if (name != (char *) &names[2])      {	assert ("bsearch doesn't work, #define FFEPROJ_BSEARCH 0 in proj.h"		== NULL);	abort ();      }    ul = strtoul ("123456789", NULL, 10);    if (ul != 123456789L)      {	assert ("strtoul doesn't have enough range, #define FFEPROJ_STRTOUL 0\ in proj.h" == NULL);	abort ();      }    fl = atof ("56.789");    if ((fl < 56.788) || (fl > 56.79))      {	assert ("atof not type double, fix your #include <stdio.h>"		== NULL);	abort ();      }  }#if FFECOM_GCC_INCLUDE  ffecom_initialize_char_syntax_ ();#endif  ffecom_outer_function_decl_ = NULL_TREE;  current_function_decl = NULL_TREE;  named_labels = NULL_TREE;  current_binding_level = NULL_BINDING_LEVEL;  free_binding_level = NULL_BINDING_LEVEL;  pushlevel (0);		/* make the binding_level structure for				   global names */  global_binding_level = current_binding_level;  /* Define `int' and `char' first so that dbx will output them first.  */  integer_type_node = make_signed_type (INT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("int"),			integer_type_node));  char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("char"),			char_type_node));  long_integer_type_node = make_signed_type (LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("long int"),			long_integer_type_node));  unsigned_type_node = make_unsigned_type (INT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned int"),			unsigned_type_node));  long_unsigned_type_node = make_unsigned_type (LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("long unsigned int"),			long_unsigned_type_node));  long_long_integer_type_node = make_signed_type (LONG_LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("long long int"),			long_long_integer_type_node));  long_long_unsigned_type_node = make_unsigned_type (LONG_LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("long long unsigned int"),			long_long_unsigned_type_node));  sizetype    = TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));  TREE_TYPE (TYPE_SIZE (integer_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (char_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (unsigned_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (long_unsigned_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;  TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;  error_mark_node = make_node (ERROR_MARK);  TREE_TYPE (error_mark_node) = error_mark_node;  short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("short int"),			short_integer_type_node));  short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("short unsigned int"),			short_unsigned_type_node));  /* Define both `signed char' and `unsigned char'.  */  signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("signed char"),			signed_char_type_node));  unsigned_char_type_node = make_unsigned_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned char"),			unsigned_char_type_node));  float_type_node = make_node (REAL_TYPE);  TYPE_PRECISION (float_type_node) = FLOAT_TYPE_SIZE;  pushdecl (build_decl (TYPE_DECL, get_identifier ("float"),			float_type_node));  layout_type (float_type_node);  double_type_node = make_node (REAL_TYPE);  TYPE_PRECISION (double_type_node) = DOUBLE_TYPE_SIZE;  pushdecl (build_decl (TYPE_DECL, get_identifier ("double"),			double_type_node));  layout_type (double_type_node);  long_double_type_node = make_node (REAL_TYPE);  TYPE_PRECISION (long_double_type_node) = LONG_DOUBLE_TYPE_SIZE;  pushdecl (build_decl (TYPE_DECL, get_identifier ("long double"),			long_double_type_node));  layout_type (long_double_type_node);  complex_integer_type_node = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex int"),			complex_integer_type_node));  TREE_TYPE (complex_integer_type_node) = integer_type_node;  layout_type (complex_integer_type_node);  complex_float_type_node = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex float"),			complex_float_type_node));  TREE_TYPE (complex_float_type_node) = float_type_node;  layout_type (complex_float_type_node);  complex_double_type_node = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex double"),			complex_double_type_node));  TREE_TYPE (complex_double_type_node) = double_type_node;  layout_type (complex_double_type_node);  complex_long_double_type_node = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex long double"),			complex_long_double_type_node));  TREE_TYPE (complex_long_double_type_node) = long_double_type_node;  layout_type (complex_long_double_type_node);  integer_zero_node = build_int_2 (0, 0);  TREE_TYPE (integer_zero_node) = integer_type_node;  integer_one_node = build_int_2 (1, 0);  TREE_TYPE (integer_one_node) = integer_type_node;  size_zero_node = build_int_2 (0, 0);  TREE_TYPE (size_zero_node) = sizetype;  size_one_node = build_int_2 (1, 0);  TREE_TYPE (size_one_node) = sizetype;  void_type_node = make_node (VOID_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("void"),			void_type_node));  layout_type (void_type_node);	/* Uses integer_zero_node */  /* We are not going to have real types in C with less than byte alignment,     so we might as well not have any types that claim to have it.  */  TYPE_ALIGN (void_type_node) = BITS_PER_UNIT;  null_pointer_node = build_int_2 (0, 0);  TREE_TYPE (null_pointer_node) = build_pointer_type (void_type_node);  layout_type (TREE_TYPE (null_pointer_node));  string_type_node = build_pointer_type (char_type_node);  ffecom_tree_fun_type_void    = build_function_type (void_type_node, NULL_TREE);  ffecom_tree_ptr_to_fun_type_void    = build_pointer_type (ffecom_tree_fun_type_void);  endlink = tree_cons (NULL_TREE, void_type_node, NULL_TREE);  float_ftype_float    = build_function_type (float_type_node,			   tree_cons (NULL_TREE, float_type_node, endlink));  double_ftype_double    = build_function_type (double_type_node,			   tree_cons (NULL_TREE, double_type_node, endlink));  ldouble_ftype_ldouble    = build_function_type (long_double_type_node,			   tree_cons (NULL_TREE, long_double_type_node,				      endlink));  for (i = 0; ((size_t) i) < ARRAY_SIZE (ffecom_tree_type); ++i)    for (j = 0; ((size_t) j) < ARRAY_SIZE (ffecom_tree_type[0]); ++j)      {	ffecom_tree_type[i][j] = NULL_TREE;	ffecom_tree_fun_type[i][j] = NULL_TREE;	ffecom_tree_ptr_to_fun_type[i][j] = NULL_TREE;	ffecom_f2c_typecode_[i][j] = -1;      }  /* Set up standard g77 types.  Note that INTEGER and LOGICAL are set     to size FLOAT_TYPE_SIZE because they have to be the same size as     REAL, which also is FLOAT_TYPE_SIZE, according to the standard.     Compiler options and other such stuff that change the ways these     types are set should not affect this particular setup.  */  ffecom_tree_type[FFEINFO_basictypeINTEGER][FFEINFO_kindtypeINTEGER1]    = t = make_signed_type (FLOAT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("integer"),			t));  type = ffetype_new ();  base_type = type;  ffeinfo_set_type (FFEINFO_basictypeINTEGER, FFEINFO_kindtypeINTEGER1,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 1, type);  assert (ffetype_size (type) == sizeof (ffetargetInteger1));  ffecom_tree_type[FFEINFO_basictypeHOLLERITH][FFEINFO_kindtypeINTEGER1]    = t = make_unsigned_type (FLOAT_TYPE_SIZE);	/* HOLLERITH means unsigned. */  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned"),			t));  ffecom_tree_type[FFEINFO_basictypeINTEGER][FFEINFO_kindtypeINTEGER2]    = t = make_signed_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("byte"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeINTEGER, FFEINFO_kindtypeINTEGER2,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 2, type);  assert (ffetype_size (type) == sizeof (ffetargetInteger2));  ffecom_tree_type[FFEINFO_basictypeHOLLERITH][FFEINFO_kindtypeINTEGER2]    = t = make_unsigned_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned byte"),			t));  ffecom_tree_type[FFEINFO_basictypeINTEGER][FFEINFO_kindtypeINTEGER3]    = t = make_signed_type (SHORT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("word"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeINTEGER, FFEINFO_kindtypeINTEGER3,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 3, type);  assert (ffetype_size (type) == sizeof (ffetargetInteger3));  ffecom_tree_type[FFEINFO_basictypeHOLLERITH][FFEINFO_kindtypeINTEGER3]    = t = make_unsigned_type (SHORT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned word"),			t));  ffecom_tree_type[FFEINFO_basictypeINTEGER][FFEINFO_kindtypeINTEGER4]    = t = make_signed_type (LONG_LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("integer4"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeINTEGER, FFEINFO_kindtypeINTEGER4,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 4, type);  assert (ffetype_size (type) == sizeof (ffetargetInteger4));  ffecom_tree_type[FFEINFO_basictypeHOLLERITH][FFEINFO_kindtypeINTEGER4]    = t = make_unsigned_type (LONG_LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("unsigned4"),			t));  if (LONG_TYPE_SIZE != FLOAT_TYPE_SIZE      && LONG_TYPE_SIZE != CHAR_TYPE_SIZE      && LONG_TYPE_SIZE != SHORT_TYPE_SIZE      && LONG_TYPE_SIZE != LONG_LONG_TYPE_SIZE)    {      fprintf (stderr, "Sorry, no g77 support for LONG_TYPE_SIZE (%d bits) yet.\n",	       LONG_TYPE_SIZE);    }  ffecom_tree_type[FFEINFO_basictypeLOGICAL][FFEINFO_kindtypeLOGICAL1]    = t = make_signed_type (FLOAT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("logical"),			t));  type = ffetype_new ();  base_type = type;  ffeinfo_set_type (FFEINFO_basictypeLOGICAL, FFEINFO_kindtypeLOGICAL1,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 1, type);  assert (ffetype_size (type) == sizeof (ffetargetLogical1));  ffecom_tree_type[FFEINFO_basictypeLOGICAL][FFEINFO_kindtypeLOGICAL2]    = t = make_signed_type (CHAR_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("logical2"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeLOGICAL, FFEINFO_kindtypeLOGICAL2,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 2, type);  assert (ffetype_size (type) == sizeof (ffetargetLogical2));  ffecom_tree_type[FFEINFO_basictypeLOGICAL][FFEINFO_kindtypeLOGICAL3]    = t = make_signed_type (SHORT_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("logical3"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeLOGICAL, FFEINFO_kindtypeLOGICAL3,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 3, type);  assert (ffetype_size (type) == sizeof (ffetargetLogical3));  ffecom_tree_type[FFEINFO_basictypeLOGICAL][FFEINFO_kindtypeLOGICAL4]    = t = make_signed_type (LONG_LONG_TYPE_SIZE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("logical4"),			t));  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeLOGICAL, FFEINFO_kindtypeLOGICAL4,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TREE_INT_CST_LOW (TYPE_SIZE (t)) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 4, type);  assert (ffetype_size (type) == sizeof (ffetargetLogical4));  ffecom_tree_type[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL1]    = t = make_node (REAL_TYPE);  TYPE_PRECISION (t) = FLOAT_TYPE_SIZE;  pushdecl (build_decl (TYPE_DECL, get_identifier ("real"),			t));  layout_type (t);  type = ffetype_new ();  base_type = type;  ffeinfo_set_type (FFEINFO_basictypeREAL, FFEINFO_kindtypeREAL1,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TYPE_PRECISION (t) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TYPE_PRECISION (t) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 1, type);  ffecom_f2c_typecode_[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL1]    = FFETARGET_f2cTYREAL;  assert (ffetype_size (type) == sizeof (ffetargetReal1));  ffecom_tree_type[FFEINFO_basictypeREAL][FFEINFO_kindtypeREALDOUBLE]    = t = make_node (REAL_TYPE);  TYPE_PRECISION (t) = FLOAT_TYPE_SIZE * 2;	/* Always twice REAL. */  pushdecl (build_decl (TYPE_DECL, get_identifier ("double precision"),			t));  layout_type (t);  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeREAL, FFEINFO_kindtypeREALDOUBLE,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TYPE_PRECISION (t) / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TYPE_PRECISION (t) / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 2, type);  ffecom_f2c_typecode_[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL2]    = FFETARGET_f2cTYDREAL;  assert (ffetype_size (type) == sizeof (ffetargetReal2));  ffecom_tree_type[FFEINFO_basictypeCOMPLEX][FFEINFO_kindtypeREAL1]    = t = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("complex"),			t));  TREE_TYPE (t)    = ffecom_tree_type[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL1];  layout_type (t);  type = ffetype_new ();  base_type = type;  ffeinfo_set_type (FFEINFO_basictypeCOMPLEX, FFEINFO_kindtypeREAL1,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (TREE_TYPE (t)) / BITS_PER_UNIT, 0,		   TYPE_PRECISION (TREE_TYPE (t)) * 2 / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TYPE_PRECISION (TREE_TYPE (t)) * 2 / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 1, type);  ffecom_f2c_typecode_[FFEINFO_basictypeCOMPLEX][FFEINFO_kindtypeREAL1]    = FFETARGET_f2cTYCOMPLEX;  assert (ffetype_size (type) == sizeof (ffetargetComplex1));  ffecom_tree_type[FFEINFO_basictypeCOMPLEX][FFEINFO_kindtypeREALDOUBLE]    = t = make_node (COMPLEX_TYPE);  pushdecl (build_decl (TYPE_DECL, get_identifier ("double complex"),			t));  TREE_TYPE (t)    = ffecom_tree_type[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL2];  layout_type (t);  type = ffetype_new ();  ffeinfo_set_type (FFEINFO_basictypeCOMPLEX, FFEINFO_kindtypeREALDOUBLE,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (TREE_TYPE (t)) / BITS_PER_UNIT, 0,		   TYPE_PRECISION (TREE_TYPE (t)) * 2 / BITS_PER_UNIT);  ffetype_set_star (base_type,		    TYPE_PRECISION (TREE_TYPE (t)) * 2 / CHAR_TYPE_SIZE,		    type);  ffetype_set_kind (base_type, 2,		    type);  ffecom_f2c_typecode_[FFEINFO_basictypeCOMPLEX][FFEINFO_kindtypeREAL2]    = FFETARGET_f2cTYDCOMPLEX;  assert (ffetype_size (type) == sizeof (ffetargetComplex2));  /* Make function and ptr-to-function types for non-CHARACTER types. */  for (i = 0; ((size_t) i) < ARRAY_SIZE (ffecom_tree_type); ++i)    for (j = 0; ((size_t) j) < ARRAY_SIZE (ffecom_tree_type[0]); ++j)      {	if ((t = ffecom_tree_type[i][j]) != NULL_TREE)	  {	    if (i == FFEINFO_basictypeCOMPLEX)	      t = void_type_node;	    /* For f2c compatibility, REAL functions are really	       implemented as DOUBLE PRECISION.  */	    else if ((i == FFEINFO_basictypeREAL)		     && (j == FFEINFO_kindtypeREAL1))	      t = ffecom_tree_type		[FFEINFO_basictypeREAL][FFEINFO_kindtypeREAL2];	    t = ffecom_tree_fun_type[i][j] = build_function_type (t,								  NULL_TREE);	    ffecom_tree_ptr_to_fun_type[i][j] = build_pointer_type (t);	  }      }  ffecom_integer_type_node    = ffecom_tree_type[FFEINFO_basictypeINTEGER][FFEINFO_kindtypeINTEGER1];  ffecom_integer_zero_node = convert (ffecom_integer_type_node,				      integer_zero_node);  ffecom_integer_one_node = convert (ffecom_integer_type_node,				     integer_one_node);  /* Yes, the "FLOAT_TYPE_SIZE" references below are intentional.     Turns out that by TYLONG, runtime/libI77/lio.h really means     "whatever size an ftnint is".  For consistency and sanity,     com.h and runtime/f2c.h.in agree that flag, ftnint, and ftlen     all are INTEGER, which we also make out of whatever back-end     integer type is FLOAT_TYPE_SIZE bits wide.  This change, from     LONG_TYPE_SIZE, for TYLONG and TYLOGICAL, was necessary to     accommodate machines like the Alpha.  Note that this suggests     f2c and libf2c are missing a distinction perhaps needed on     some machines between "int" and "long int".  -- burley 0.5.5 950215 */  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeINTEGER, FLOAT_TYPE_SIZE,			    FFETARGET_f2cTYLONG);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeINTEGER, SHORT_TYPE_SIZE,			    FFETARGET_f2cTYSHORT);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeINTEGER, CHAR_TYPE_SIZE,			    FFETARGET_f2cTYINT1);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeINTEGER, LONG_LONG_TYPE_SIZE,			    FFETARGET_f2cTYQUAD);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeLOGICAL, FLOAT_TYPE_SIZE,			    FFETARGET_f2cTYLOGICAL);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeLOGICAL, SHORT_TYPE_SIZE,			    FFETARGET_f2cTYLOGICAL2);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeLOGICAL, CHAR_TYPE_SIZE,			    FFETARGET_f2cTYLOGICAL1);  ffecom_f2c_set_lio_code_ (FFEINFO_basictypeLOGICAL, LONG_LONG_TYPE_SIZE,			    FFETARGET_f2cTYQUAD	/* ~~~ */);  /* CHARACTER stuff is all special-cased, so it is not handled in the above     loop.  CHARACTER items are built as arrays of unsigned char.  */  ffecom_tree_type[FFEINFO_basictypeCHARACTER]    [FFEINFO_kindtypeCHARACTER1] = t = char_type_node;  type = ffetype_new ();  base_type = type;  ffeinfo_set_type (FFEINFO_basictypeCHARACTER,		    FFEINFO_kindtypeCHARACTER1,		    type);  ffetype_set_ams (type,		   TYPE_ALIGN (t) / BITS_PER_UNIT, 0,		   TREE_INT_CST_LOW (TYPE_SIZE (t)) / BITS_PER_UNIT);  ffetype_set_kind (base_type, 1, type);  assert (ffetype_size (type)	  == sizeof (((ffetargetCharacter1) { 0, NULL }).text[0]));  ffecom_tree_fun_type[FFEINFO_basictypeCHARACTER]    [FFEINFO_kindtypeCHARACTER1] = ffecom_tree_fun_type_void;  ffecom_tree_ptr_to_fun_type[FFEINFO_basictypeCHARACTER]    [FFEINFO_kindtypeCHARACTER1]    = ffecom_tree_ptr_to_fun_type_void;  ffecom_f2c_typecode_[FFEINFO_basictypeCHARACTER][FFEINFO_kindtypeCHARACTER1]    = FFETARGET_f2cTYCHAR;  ffecom_f2c_typecode_[FFEINFO_basictypeANY][FFEINFO_kindtypeANY]    = 0;  /* Make multi-return-value type and fields. */  ffecom_multi_type_node_ = make_node (UNION_TYPE);  field = NULL_TREE;  for (i = 0; ((size_t) i) < ARRAY_SIZE (ffecom_tree_type); ++i)    for (j = 0; ((size_t) j) < ARRAY_SIZE (ffecom_tree_type[0]); ++j)      {	char name[30];	if (ffecom_tree_type[i][j] == NULL_TREE)	  continue;		/* Not supported. */	sprintf (&name[0], "bt_%s_kt_%s",		 ffeinfo_basictype_string ((ffeinfoBasictype) i),		 ffeinfo_kindtype_string ((ffeinfoKindtype) j));	ffecom_multi_fields_[i][j] = build_decl (FIELD_DECL,						 get_identifier (name),						 ffecom_tree_type[i][j]);	DECL_CONTEXT (ffecom_multi_fields_[i][j])	  = ffecom_multi_type_node_;	DECL_FRAME_SIZE (ffecom_multi_fields_[i][j]) = 0;	TREE_CHAIN (ffecom_multi_fields_[i][j]) = field;	field = ffecom_multi_fields_[i][j];      }  TYPE_FIELDS (ffecom_multi_type_node_) = field;  layout_type (ffecom_multi_type_node_);  /* Subroutines usually return integer because they might have alternate     returns. */  ffecom_tree_subr_type    = build_function_type (integer_type_node, NULL_TREE);  ffecom_tree_ptr_to_subr_type    = build_pointer_type (ffecom_tree_subr_type);  ffecom_tree_blockdata_type    = build_function_type (void_type_node, NULL_TREE);  builtin_function ("__builtin_sqrtf", float_ftype_float,		    BUILT_IN_FSQRT, "sqrtf");  builtin_function ("__builtin_fsqrt", double_ftype_double,		    BUILT_IN_FSQRT, "sqrt");  builtin_function ("__builtin_sqrtl", ldouble_ftype_ldouble,		    BUILT_IN_FSQRT, "sqrtl");  builtin_function ("__builtin_sinf", float_ftype_float,		    BUILT_IN_SIN, "sinf");  builtin_function ("__builtin_sin", double_ftype_double,		    BUILT_IN_SIN, "sin");  builtin_function ("__builtin_sinl", ldouble_ftype_ldouble,		    BUILT_IN_SIN, "sinl");  builtin_function ("__builtin_cosf", float_ftype_float,		    BUILT_IN_COS, "cosf");  builtin_function ("__builtin_cos", double_ftype_double,		    BUILT_IN_COS, "cos");  builtin_function ("__builtin_cosl", ldouble_ftype_ldouble,		    BUILT_IN_COS, "cosl");#if BUILT_FOR_270  pedantic_lvalues = FALSE;#endif  ffecom_f2c_make_type_ (&ffecom_f2c_integer_type_node,			 FFECOM_f2cINTEGER,			 "integer");  ffecom_f2c_make_type_ (&ffecom_f2c_address_type_node,			 FFECOM_f2cADDRESS,			 "address");  ffecom_f2c_make_type_ (&ffecom_f2c_real_type_node,			 FFECOM_f2cREAL,			 "real");  ffecom_f2c_make_type_ (&ffecom_f2c_doublereal_type_node,			 FFECOM_f2cDOUBLEREAL,			 "doublereal");  ffecom_f2c_make_type_ (&ffecom_f2c_complex_type_node,			 FFECOM_f2cCOMPLEX,			 "complex");  ffecom_f2c_make_type_ (&ffecom_f2c_doublecomplex_type_node,			 FFECOM_f2cDOUBLECOMPLEX,			 "doublecomplex");  ffecom_f2c_make_type_ (&ffecom_f2c_longint_type_node,			 FFECOM_f2cLONGINT,			 "longint");  ffecom_f2c_make_type_ (&ffecom_f2c_logical_type_node,			 FFECOM_f2cLOGICAL,			 "logical");  ffecom_f2c_make_type_ (&ffecom_f2c_flag_type_node,			 FFECOM_f2cFLAG,			 "flag");  ffecom_f2c_make_type_ (&ffecom_f2c_ftnlen_type_node,			 FFECOM_f2cFTNLEN,			 "ftnlen");  ffecom_f2c_make_type_ (&ffecom_f2c_ftnint_type_node,			 FFECOM_f2cFTNINT,			 "ftnint");  ffecom_f2c_ftnlen_zero_node    = convert (ffecom_f2c_ftnlen_type_node, integer_zero_node);  ffecom_f2c_ftnlen_one_node    = convert (ffecom_f2c_ftnlen_type_node, integer_one_node);  ffecom_f2c_ftnlen_two_node = build_int_2 (2, 0);  TREE_TYPE (ffecom_f2c_ftnlen_two_node) = ffecom_integer_type_node;  ffecom_f2c_ptr_to_ftnlen_type_node    = build_pointer_type (ffecom_f2c_ftnlen_type_node);  ffecom_f2c_ptr_to_ftnint_type_node    = build_pointer_type (ffecom_f2c_ftnint_type_node);  ffecom_float_zero_ = build_real (float_type_node, dconst0);  ffecom_double_zero_ = build_real (double_type_node, dconst0);  {    REAL_VALUE_TYPE point_5;#ifdef REAL_ARITHMETIC    REAL_ARITHMETIC (point_5, RDIV_EXPR, dconst1, dconst2);#else    point_5 = .5;#endif    ffecom_float_half_ = build_real (float_type_node, point_5);    ffecom_double_half_ = build_real (double_type_node, point_5);  }  /* Do "extern int xargc;".  */  ffecom_tree_xargc_ = build_decl (VAR_DECL,				   get_identifier ("xargc"),				   integer_type_node);  DECL_EXTERNAL (ffecom_tree_xargc_) = 1;  TREE_STATIC (ffecom_tree_xargc_) = 1;  TREE_PUBLIC (ffecom_tree_xargc_) = 1;  ffecom_tree_xargc_ = start_decl (ffecom_tree_xargc_, FALSE);  finish_decl (ffecom_tree_xargc_, NULL_TREE, FALSE);  if ((FLOAT_TYPE_SIZE != 32)      || (TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (null_pointer_node))) != 32))    {      warning ("configuration: REAL, INTEGER, and LOGICAL are %d bits wide,",	       (int) FLOAT_TYPE_SIZE);      warning ("and pointers are %d bits wide, but g77 doesn't yet work",	  (int) TREE_INT_CST_LOW (TYPE_SIZE (TREE_TYPE (null_pointer_node))));      warning ("properly unless they all are 32 bits wide.");      warning ("Please keep this in mind before you report bugs.  g77 should");      warning ("support non-32-bit machines better as of version 0.6.");    }#if 0	/* Code in ste.c that would crash has been commented out. */  if (TYPE_PRECISION (ffecom_f2c_ftnlen_type_node)      < TYPE_PRECISION (string_type_node))    /* I/O will probably crash.  */    warning ("configuration: char * holds %d bits, but ftnlen only %d",	     TYPE_PRECISION (string_type_node),	     TYPE_PRECISION (ffecom_f2c_ftnlen_type_node));#endif#if 0	/* ASSIGN-related stuff has been changed to accommodate this. */  if (TYPE_PRECISION (ffecom_integer_type_node)      < TYPE_PRECISION (string_type_node))    /* ASSIGN 10 TO I will crash.  */    warning ("configuration: char * holds %d bits, but INTEGER only %d --\n\ ASSIGN statement might fail",	     TYPE_PRECISION (string_type_node),	     TYPE_PRECISION (ffecom_integer_type_node));#endif}