PUSH (NOSYMBOL, bfd_abs_section_ptr, TOS.value = ieee->section_table[section_n]->vma + ieee_per_section (ieee->section_table[section_n])->pc);
PUSH (NOSYMBOL, bfd_abs_section_ptr, 0);
parse_expression (ieee, value, symbol, pcrel, extra, section)     ieee_data_type *ieee;     bfd_vma *value;     ieee_symbol_index_type *symbol;     boolean *pcrel;     unsigned int *extra;     asection **section;{#define POS sp[1]#define TOS sp[0]#define NOS sp[-1]#define INC sp++;#define DEC sp--;  boolean loop = true;  ieee_value_type stack[10];  /* The stack pointer always points to the next unused location */#define PUSH(x,y,z) TOS.symbol=x;TOS.section=y;TOS.value=z;INC;#define POP(x,y,z) DEC;x=TOS.symbol;y=TOS.section;z=TOS.value;  ieee_value_type *sp = stack;  while (loop)    {      switch (this_byte (&(ieee->h)))	{	case ieee_variable_P_enum:	  /* P variable, current program counter for section n */	  {	    int section_n;	    next_byte (&(ieee->h));	    *pcrel = true;	    section_n = must_parse_int (&(ieee->h));	    PUSH (NOSYMBOL, bfd_abs_section_ptr,		  TOS.value = ieee->section_table[section_n]->vma +		  ieee_per_section (ieee->section_table[section_n])->pc);	    break;	  }	case ieee_variable_L_enum:	  /* L variable  address of section N */	  next_byte (&(ieee->h));	  PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);	  break;	case ieee_variable_R_enum:	  /* R variable, logical address of section module */	  /* FIXME, this should be different to L */	  next_byte (&(ieee->h));	  PUSH (NOSYMBOL, ieee->section_table[must_parse_int (&(ieee->h))], 0);	  break;	case ieee_variable_S_enum:	  /* S variable, size in MAUS of section module */	  next_byte (&(ieee->h));	  PUSH (NOSYMBOL,		0,		ieee->section_table[must_parse_int (&(ieee->h))]->_raw_size);	  break;	case ieee_variable_I_enum:	case ieee_variable_X_enum:	  /* Push the address of external variable n */	  {	    ieee_symbol_index_type sy;	    next_byte (&(ieee->h));	    sy.index = (int) (must_parse_int (&(ieee->h)));	    sy.letter = 'X';	    PUSH (sy, bfd_und_section_ptr, 0);	  }	  break;	case ieee_function_minus_enum:	  {	    bfd_vma value1, value2;	    asection *section1, *section_dummy;	    ieee_symbol_index_type sy;	    next_byte (&(ieee->h));	    POP (sy, section1, value1);	    POP (sy, section_dummy, value2);	    PUSH (sy, section1 ? section1 : section_dummy, value1 - value2);	  }	  break;	case ieee_function_plus_enum:	  {	    bfd_vma value1, value2;	    asection *section1;	    asection *section2;	    ieee_symbol_index_type sy1;	    ieee_symbol_index_type sy2;	    next_byte (&(ieee->h));	    POP (sy1, section1, value1);	    POP (sy2, section2, value2);	    PUSH (sy1.letter ? sy1 : sy2,		  bfd_is_abs_section (section1) ? section2 : section1,		  value1 + value2);	  }	  break;	default:	  {	    bfd_vma va;	    BFD_ASSERT (this_byte (&(ieee->h)) < (int) ieee_variable_A_enum		    || this_byte (&(ieee->h)) > (int) ieee_variable_Z_enum);	    if (parse_int (&(ieee->h), &va))	      {		PUSH (NOSYMBOL, bfd_abs_section_ptr, va);	      }	    else	      {		/*		  Thats all that we can understand. As far as I can see		  there is a bug in the Microtec IEEE output which I'm		  using to scan, whereby the comma operator is omitted		  sometimes in an expression, giving expressions with too		  many terms. We can tell if that's the case by ensuring		  that sp == stack here. If not, then we've pushed		  something too far, so we keep adding.  */		while (sp != stack + 1)		  {		    asection *section1;		    ieee_symbol_index_type sy1;		    POP (sy1, section1, *extra);		  }		{		  asection *dummy;		  POP (*symbol, dummy, *value);		  if (section)		    *section = dummy;		}		loop = false;	      }	  }	}    }}