else				 kind = (ffeintrin_imps_[imp].control[0] == '-') ? FFEINFO_kindSUBROUTINE : FFEINFO_kindFUNCTION;
ffeintrin_is_intrinsic (char *name, ffelexToken t, bool explicit,			ffeintrinGen *xgen, ffeintrinSpec *xspec,			ffeintrinImp *ximp, ffeinfoKind *xkind){  struct _ffeintrin_name_ *intrinsic;  ffeintrinGen gen;  ffeintrinSpec spec;  ffeintrinImp imp;  ffeinfoKind kind;  ffeIntrinsicState state;  bool disabled = FALSE;  bool unimpl = FALSE;  intrinsic = bsearch (name, &ffeintrin_names_[0],		       ARRAY_SIZE (ffeintrin_names_),		       sizeof (struct _ffeintrin_name_),		         (void *) ffeintrin_cmp_name_);  if (intrinsic == NULL)    return FALSE;  gen = intrinsic->generic;  spec = intrinsic->specific;  imp = ffeintrin_specs_[spec].implementation;  /* Generic is okay only if at least one of its specifics is okay.  */  if (gen != FFEINTRIN_genNONE)    {      int i;      ffeintrinSpec tspec;      bool ok = FALSE;      for (i = 0;	   (((size_t) i) < ARRAY_SIZE (ffeintrin_gens_[gen].specs))	   && ((tspec		= ffeintrin_gens_[gen].specs[i]) != FFEINTRIN_specNONE);	   ++i)	{	  state = ffeintrin_state_family (ffeintrin_specs_[tspec].family);	  if (state == FFE_intrinsicstateDELETED)	    continue;	  if (state == FFE_intrinsicstateDISABLED)	    {	      disabled = TRUE;	      continue;	    }	  if (ffeintrin_specs_[tspec].implementation == FFEINTRIN_impNONE)	    {	      unimpl = TRUE;	      continue;	    }	  if ((state == FFE_intrinsicstateENABLED)	      || (explicit		  && (state == FFE_intrinsicstateHIDDEN)))	    {	      ok = TRUE;	      break;	    }	}      if (!ok)	gen = FFEINTRIN_genNONE;    }  /* Specific is okay only if not: unimplemented, disabled, deleted, or     hidden and not explicit.  */  if (spec != FFEINTRIN_specNONE)    {      if (((state = ffeintrin_state_family (ffeintrin_specs_[spec].family))	   == FFE_intrinsicstateDELETED)	  || (!explicit	      && (state == FFE_intrinsicstateHIDDEN)))	spec = FFEINTRIN_specNONE;      else if (state == FFE_intrinsicstateDISABLED)	{	  disabled = TRUE;	  spec = FFEINTRIN_specNONE;	}      else if (imp == FFEINTRIN_impNONE)	{	  unimpl = TRUE;	  spec = FFEINTRIN_specNONE;	}    }  /* If neither is okay, not an intrinsic.  */  if ((gen == FFEINTRIN_genNONE) && (spec == FFEINTRIN_specNONE))    {      /* Here is where we produce a diagnostic about a reference to a	 disabled or unimplemented intrinsic, if the diagnostic is desired.  */      if ((disabled || unimpl)	  && (t != NULL))	{	  ffebad_start (disabled			? FFEBAD_INTRINSIC_DISABLED			: FFEBAD_INTRINSIC_UNIMPL);	  ffebad_here (0, ffelex_token_where_line (t), ffelex_token_where_column (t));	  ffebad_string (name);	  ffebad_finish ();	}      if (disabled || unimpl)	*xkind = FFEINFO_kindANY;      else	*xkind = FFEINFO_kindNONE;      return FALSE;    }  /* Determine whether intrinsic is function or subroutine.  If no specific     id, scan list of possible specifics for generic to get consensus.  Must     be unanimous, at least for now.  */  if (spec == FFEINTRIN_specNONE)    {      int i;      ffeintrinSpec tspec;      ffeintrinImp timp;      ffeinfoKind tkind;      kind = FFEINFO_kindNONE;      for (i = 0;	   (((size_t) i) < ARRAY_SIZE (ffeintrin_gens_[gen].specs))	   && ((tspec		= ffeintrin_gens_[gen].specs[i]) != FFEINTRIN_specNONE);	   ++i)	{	  if ((timp = ffeintrin_specs_[tspec].implementation)	      == FFEINTRIN_impNONE)	    continue;	  if (ffeintrin_imps_[timp].control[0] == '-')	    tkind = FFEINFO_kindSUBROUTINE;	  else	    tkind = FFEINFO_kindFUNCTION;	  if ((kind == tkind) || (kind == FFEINFO_kindNONE))	    kind = tkind;	  else	    assert ("what kind of proc am i?" == NULL);	}    }  else				/* Have specific, use that. */    kind      = (ffeintrin_imps_[imp].control[0] == '-')      ? FFEINFO_kindSUBROUTINE      : FFEINFO_kindFUNCTION;  *xgen = gen;  *xspec = spec;  *ximp = imp;  *xkind = kind;  return TRUE;}