Revision 7d6cec3857985b92ed11312dcdeac0a49edb0ab8 authored by Mike Stewart on 13 March 2018, 04:58:16 UTC, committed by Mike Stewart on 13 March 2018, 04:58:16 UTC
1 parent 1296fee
ParseERASE.c
/*
* Copyright 2003-2004,2016 Ronald S. Burkey <info@sandroid.org>
*
* This file is part of yaAGC.
*
* yaAGC is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* yaAGC is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with yaAGC; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* Filename: ParseERASE.c
* Purpose: Assembles the ERASE pseudo-op.
* Mods: 04/19/03 RSB Began.
* 09/04/04 RSB Eliminated range allocation (i.e.,
* "ERASE start - end"). It turns out
* that this is exactly the same as
* "EQUALS start".
* 10/21/16 RSB Eliminated a few comments that were
* apparently causing problems for
* MS Visual C, but which served no purpose
* anyway.
*/
#include "yaYUL.h"
#include <stdlib.h>
#include <string.h>
#if 0
//------------------------------------------------------------------------
// Figure out what erasable bank a pseudo address (i.e., a linear
// address from 0-0117777) is in. Return values are:
// -2 Not in erasable memory.
// -1 Unbanked (00000-01377)
// 0 Bank 0 (00000-00377) (won't happen)
// 1 Bank 1 (00400-00777) (won't happen)
// 2 Bank 2 (01000-01377) (won't happen)
// 3 Bank 3 (01400-01777)
// ...
// 7 Bank 7 (03400-03777)
int GetErasableBank(int LinearAddress)
{
if (LinearAddress < 0 || LinearAddress > 03777)
return (-2);
if (LinearAddress < 01400)
return (-1);
return (LinearAddress / 0400);
}
#endif
//------------------------------------------------------------------------
// Return non-zero on unrecoverable error.
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->EBank = InRecord->EBank;
OutRecord->SBank = InRecord->SBank;
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
ParseEQUALS(InRecord, OutRecord);
#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);
}
Computing file changes ...