anchor.diff:  c_action: CALL
   	| ASSEM_INSTR
   	;
  +
  +
  +
   
   
   {
  
positive.code: 	}
  }
  
  int lex_analyzer()
  {
  	extern char *next;
  
negative.code: /* This file contains the parser for the 'EM_table'.
   * Every row in the table is converted to a C-function.
   * The parser is a fairly simple program, for each row it prints a function-
   * header and the following actions are printed as C-statements. A CALL is just
   * copied, and an ASSEM_INSTR will be handed to the routine assemble().
   * Assemble() will turn the assembly-string into a sequence of C-function calls.
   * How this should be done is expressed in the 'as_table'.
   *
   * There are however some complicating factors:
   *	- A row in the 'EM_table' may contain CONDITION's. 
   *	  The parser supports this by outptutting some "if" and "else"'s.
   *
   *	- The user is allowed to use some abbreviation in the 'EM_table', (s)he
   *	  can use the DEF_C_INSTR's ( e.g. C_loe..).
   *	  One such DEF_C_INSTR must be expanded in 3 or more C-functions.
   *	  The solution is to copy the DEF_C_INSTR to a temporary file. Then
   *	  this file will be processed as many times as needed to generate all
   *	  the C-functions.
   *
   *	- The assembler-instructions must be processed in blocks not one at a
   *	  time, so buffering is needed.
   *
   *	- When generating object-code, the user can make use of the dist()
   * 	  function. This function should return the number of bytes between
   *	  the current instruction and a labelled one, both forward and backward
   *	  references must be handled.
   *	  This requires the saving of the generated function, and 
   *	  backpatching in a second phase.
   */
  {
  
  #include <system.h>
  #include "decl.h"
  #include "em.h"
  
  extern char yytext[];
  extern int yylineno;
  extern int first_action, last_action, token;
  