Ejemplo n.º 1
0
int 
ParseERASE (ParseInput_t *InRecord, ParseOutput_t *OutRecord)
{
  int Value, i;
  IncPc (&InRecord->ProgramCounter, 1, &OutRecord->ProgramCounter);
  if (!OutRecord->ProgramCounter.Invalid && OutRecord->ProgramCounter.Overflow)
    {
      strcpy (OutRecord->ErrorMessage, "Next code may overflow storage.");
      OutRecord->Warning = 1;
    }
  OutRecord->Bank = InRecord->Bank;
  if (InRecord->Extend && !InRecord->IndexValid)
    {
      strcpy (OutRecord->ErrorMessage, "Illegally preceded by EXTEND.");
      OutRecord->Fatal = 1;
      OutRecord->Extend = 0;
    }
  if (InRecord->IndexValid)
    {
      strcpy (OutRecord->ErrorMessage, "Illegally preceded by INDEX.");
      OutRecord->Fatal = 1;
      OutRecord->IndexValid = 0;
    }
  i = GetOctOrDec (InRecord->Operand, &Value);
  if (!i)
    {
      if (Value < 0)
        {
	  strcpy (OutRecord->ErrorMessage, "Address increment is negative.");
	  OutRecord->Warning = 1;
	}	
      else
        {
	  // There are really two cases here.  Normally, the operand is
	  // simply a number, and that's the end of it.  But it's also
	  // possible that Mod1 is "-", and Mod2 is another number, in 
	  // which case we want to allocate a range.
	  if (!strcmp (InRecord->Mod1, "-"))
	    {
#if 0
	      // This is the range case, "ERASE n - m".
	      i = GetOctOrDec (InRecord->Mod2, &Value2);
	      Value2++;
	      if (i)
	        {
		  strcpy (OutRecord->ErrorMessage, "End of range missing or illegal.");
		  OutRecord->Fatal = 1;
		}
	      else if (Value2 <= Value)
	        {
		  strcpy (OutRecord->ErrorMessage, "Ending address precedes starting address.");
		  OutRecord->Fatal = 1;
		}	
	      else
	        {
		  ParseOutput_t Dummy = { { 0 } }, Dummy2 = { { 0 } };
		  PseudoToSegmented (Value, &Dummy);
		  PseudoToSegmented (Value2, &Dummy2);
		  if (Dummy.Fatal || Dummy.Warning || Dummy2.Fatal || Dummy2.Warning
		      || Dummy.ProgramCounter.Invalid || !Dummy.ProgramCounter.Erasable
		      || Dummy2.ProgramCounter.Invalid || !Dummy2.ProgramCounter.Erasable
		      || Dummy.ProgramCounter.Banked != Dummy2.ProgramCounter.Banked
		      || Dummy.ProgramCounter.EB != Dummy2.ProgramCounter.EB)
		    {
		      strcpy (OutRecord->ErrorMessage, "May span bank boundary.");
		      OutRecord->Warning = 1;
		    }
		  InRecord->ProgramCounter = Dummy.ProgramCounter;
		  OutRecord->ProgramCounter = Dummy2.ProgramCounter;
		}
#else // 0
  		  char Mod1[1 + MAX_LINE_LENGTH], Mod2[1 + MAX_LINE_LENGTH];
		  strcpy (Mod1, InRecord->Mod1);
		  strcpy (Mod2, InRecord->Mod2);
		  strcpy (InRecord->Mod1, "");
		  strcpy (InRecord->Mod2, "");  
		  strcpy (InRecord->Operator, "EQUALS");            
		  ParseEQUALS (InRecord, OutRecord);
		  strcpy (InRecord->Mod1, Mod1);
		  strcpy (InRecord->Mod2, Mod2);
		  strcpy (InRecord->Operator, "ERASE");
#endif // 0
	    }
	  else
	    {  
	      // This is the normal case, "ERASE n".
	      if (0 != *InRecord->Mod1 && !OutRecord->Fatal)
	        {
		  strcpy (OutRecord->ErrorMessage, "Extra fields are present.");
		  OutRecord->Warning = 1;
		}
	      IncPc (&InRecord->ProgramCounter, 1 + Value, &OutRecord->ProgramCounter);
	      if (!OutRecord->ProgramCounter.Invalid)
		{
		  if (!OutRecord->ProgramCounter.Erasable)
		    {
		      strcpy (OutRecord->ErrorMessage, "Not in erasable memory.");
		      OutRecord->Fatal = 1;
		    }
		  else if (OutRecord->ProgramCounter.Overflow)
		    {
		      strcpy (OutRecord->ErrorMessage, "May overflow memory bank.");
		      OutRecord->Warning = 1;
		    }
		}
	    }
	}
    }
  else if (0 != *InRecord->Operand)
    {
      // Note that if the Operand field is simply missing, it's legal.
      strcpy (OutRecord->ErrorMessage, "Illegal number.");
      OutRecord->Fatal = 1;
    }  
  return (0);  
}
Ejemplo n.º 2
0
int
ParseEquate (ParseInput_t *InRecord, ParseOutput_t *OutRecord)
{
    return (ParseEQUALS (InRecord, OutRecord));
}