if (where == FFEINFO_whereGLOBAL) ffesymbol_globalize (s);
ffeexpr_sym_rhs_actualarg_ (ffesymbol s, ffelexToken t){  ffesymbolAttrs sa;  ffesymbolAttrs na;  ffeinfoKind kind;  ffeinfoWhere where;  ffesymbolState ns;  bool needs_type = FALSE;  assert ((ffesymbol_state (s) == FFESYMBOL_stateNONE)	  || (ffesymbol_state (s) == FFESYMBOL_stateUNCERTAIN));  na = sa = ffesymbol_attrs (s);  assert (!(sa & ~(FFESYMBOL_attrsACTUALARG		   | FFESYMBOL_attrsADJUSTABLE		   | FFESYMBOL_attrsANYLEN		   | FFESYMBOL_attrsARRAY		   | FFESYMBOL_attrsDUMMY		   | FFESYMBOL_attrsEXTERNAL		   | FFESYMBOL_attrsSFARG		   | FFESYMBOL_attrsTYPE)));  kind = ffesymbol_kind (s);  where = ffesymbol_where (s);  /* Figure out what kind of object we've got based on previous declarations     of or references to the object. */  ns = FFESYMBOL_stateUNDERSTOOD;  if (sa & FFESYMBOL_attrsEXTERNAL)    {      assert (!(sa & ~(FFESYMBOL_attrsACTUALARG		       | FFESYMBOL_attrsDUMMY		       | FFESYMBOL_attrsEXTERNAL		       | FFESYMBOL_attrsTYPE)));      if (sa & FFESYMBOL_attrsTYPE)	where = FFEINFO_whereGLOBAL;      else	/* Not TYPE. */	{	  ns = FFESYMBOL_stateUNCERTAIN;	  if (sa & FFESYMBOL_attrsDUMMY)	    assert (kind == FFEINFO_kindNONE);	/* FUNCTION, SUBROUTINE. */	  else if (sa & FFESYMBOL_attrsACTUALARG)	    ;			/* Not DUMMY or TYPE. */	  else	    /* Not ACTUALARG, DUMMY, or TYPE. */	    {	      assert (kind == FFEINFO_kindNONE);	/* FUNCTION, SUBROUTINE. */	      na |= FFESYMBOL_attrsACTUALARG;	      where = FFEINFO_whereGLOBAL;	    }	}    }  else if (sa & FFESYMBOL_attrsDUMMY)    {      assert (!(sa & FFESYMBOL_attrsEXTERNAL));	/* Handled above. */      assert (!(sa & ~(FFESYMBOL_attrsDUMMY		       | FFESYMBOL_attrsEXTERNAL		       | FFESYMBOL_attrsTYPE)));      kind = FFEINFO_kindENTITY;      if (!(sa & FFESYMBOL_attrsTYPE))	needs_type = TRUE;    }  else if (sa & FFESYMBOL_attrsARRAY)    {      assert (!(sa & ~(FFESYMBOL_attrsARRAY		       | FFESYMBOL_attrsADJUSTABLE		       | FFESYMBOL_attrsTYPE)));      where = FFEINFO_whereLOCAL;    }  else if (sa & FFESYMBOL_attrsSFARG)    {      assert (!(sa & ~(FFESYMBOL_attrsSFARG		       | FFESYMBOL_attrsTYPE)));      where = FFEINFO_whereLOCAL;    }  else if (sa & FFESYMBOL_attrsTYPE)    {      assert (!(sa & (FFESYMBOL_attrsARRAY		      | FFESYMBOL_attrsDUMMY		      | FFESYMBOL_attrsEXTERNAL		      | FFESYMBOL_attrsSFARG)));	/* Handled above. */      assert (!(sa & ~(FFESYMBOL_attrsTYPE		       | FFESYMBOL_attrsADJUSTABLE		       | FFESYMBOL_attrsANYLEN		       | FFESYMBOL_attrsARRAY		       | FFESYMBOL_attrsDUMMY		       | FFESYMBOL_attrsEXTERNAL		       | FFESYMBOL_attrsSFARG)));      if (sa & FFESYMBOL_attrsANYLEN)	ns = FFESYMBOL_stateNONE;      else	{	  kind = FFEINFO_kindENTITY;	  where = FFEINFO_whereLOCAL;	}    }  else if (sa == FFESYMBOL_attrsetNONE)    {      /* New state is left empty because there isn't any state flag to	 set for this case, and it's UNDERSTOOD after all.  */      assert (ffesymbol_state (s) == FFESYMBOL_stateNONE);      kind = FFEINFO_kindENTITY;      where = FFEINFO_whereLOCAL;      needs_type = TRUE;    }  else    ns = FFESYMBOL_stateNONE;	/* Error. */  /* Now see what we've got for a new object: NONE means a new error cropped     up; ANY means an old error to be ignored; otherwise, everything's ok,     update the object (symbol) and continue on. */  if (ns == FFESYMBOL_stateNONE)    ffesymbol_error (s, t);  else if (!(na & FFESYMBOL_attrsANY))    {      ffesymbol_signal_change (s);	/* May need to back up to previous					   version. */      if (needs_type && !ffeimplic_establish_symbol (s))	{	  ffesymbol_error (s, t);	  return s;	}      ffesymbol_set_info (s,			  ffeinfo_new (ffesymbol_basictype (s),				       ffesymbol_kindtype (s),				       ffesymbol_rank (s),				       kind,				       where,				       ffesymbol_size (s)));      ffesymbol_set_attrs (s, na);      ffesymbol_set_state (s, ns);      s = ffecom_sym_learned (s);      ffesymbol_signal_unreported (s);	/* For debugging purposes. */    }  return s;}