/*
Copyright 2003,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: IncPc.c
Purpose: Increments (or decrements) an Address_t structure, with
detection of out-of range. This is a more complicated
thing than it seems, because of the variety of different
types of memory bank. (Also, since the Address_t
structure can represent a constant rather than an address.)
History: 04/15/03 RSB Began.
08/18/16 RSB Some cross-my-finger-and-hope tweaks for
--block1.
*/
#include "yaYUL.h"
#include <stdlib.h>
#include <math.h>
#include <string.h>
//-------------------------------------------------------------------------
// Increment program counter by a certain amount.
// Sets the Overflow flag in the Address_t structure.
void IncPc(Address_t *OldPc, int Increment, Address_t *NewPc)
{
int i, j, Max, Min, BankIncrement;
// I have no theoretical basis for how to treat the case of Increment
// being very large (larger than a bank size), but there is a place
// in the Luminary source code where decrements of about 12000 (octal)
// are used. The lower 12 bits seem to be applied to SREG, whereas
// the upper 3 bits seem to be applied to the bank number.
if (Increment >= 0) {
BankIncrement = 7 & (Increment >> 12);
Increment &= 07777;
} else {
Increment = -Increment;
BankIncrement = -(7 & (Increment >> 12));
Increment = -(07777 & Increment);
}
// Get a good starting point for the calculation.
*NewPc = *OldPc;
// If the value is invalid---not yet assigned---then adding to it makes
// no sense.
if (NewPc->Invalid)
return;
// Okay, add to the existing Value. This is something that ALWAYS works.
// (Only overflowing 32-bit arithmetic could make it fail, but since
// all possible starting values and increments are 15-bit or less,
// overflowing 32-bit arithmetic would be a real feat!
//NewPc->Value += Increment;
// Convert constants (which are presumably pseudo-addresses) to real
// addresses.
if (NewPc->Constant) {
// ... except we do want to check that the constant is in range.
//if (NewPc->Value < -16383 || NewPc->Value > 32767)
// NewPc->Overflow = 1;
if (NewPc->Value < 0)
return;
else if (NewPc->Value < 01400) {
NewPc->Constant = 0;
NewPc->Address = 1;
NewPc->Erasable = 1;
NewPc->Fixed = 0;
NewPc->Banked = 0;
NewPc->Unbanked = 1;
NewPc->EB = 0;
NewPc->FB = 0;
#ifdef YAYUL_TRACE
printf("*** IncPc (%d): clearing superbank...\n", __LINE__);
#endif
NewPc->Super = 0;
NewPc->SReg = NewPc->Value;
} else
return;
}
// Okey-smokey, the "address" is really an address. If it has previously
// overflowed, there's no particular reason to continue.
if (NewPc->Overflow)
return;
// Compute the new S-register value (in the absence of overflow).
i = (j = NewPc->SReg) + Increment;
NewPc->SReg = i;
if (NewPc->Erasable && NewPc->Banked)
NewPc->EB += BankIncrement;
else if (NewPc->Fixed && NewPc->Banked)
NewPc->FB += BankIncrement;
// Okay, here's some workaround code for the weird construct
// TC FixedMemoryLabel -LargeOffset
// taking a location in fixed memory down to a location in erasable.
// Don't blame me!
if (NewPc->Fixed && BankIncrement != 0 && NewPc->FB == 0) {
NewPc->Constant = 0;
NewPc->Address = 1;
NewPc->Erasable = 1;
NewPc->Fixed = 0;
NewPc->Banked = 0;
NewPc->Unbanked = 1;
NewPc->EB = 0;
NewPc->FB = 0;
#ifdef YAYUL_TRACE
//printf("--- IncPc (%d): clearing superbank...\n", __LINE__);
#endif
NewPc->Super = 0;
}
// Determine the appropriate SReg ranges for this memory region.
// The address will be either banked or unbanked, and either in fixed
// memory or erasable memory. So, there are four possible combos.
if (NewPc->Erasable) {
if (NewPc->Unbanked) {
Min = 0;
Max = Block1 ? 01777 : 01377;
} else if (!Block1 && NewPc->Banked) {
Min = 01400;
Max = 01777;
NewPc->EB += BankIncrement;
} else
goto ImplementationError;
} else if (NewPc->Fixed) {
if (NewPc->Banked) {
Min = Block1 ? 06000 : 02000;
Max = Block1 ? 07777 : 03777;
NewPc->FB += BankIncrement;
} else if (NewPc->Unbanked) {
Min = Block1 ? 02000 : 04000;
Max = 07777;
} else
goto ImplementationError;
} else
goto ImplementationError;
// Did the new S-register value go out of range for the memory region?
if (i < Min) {
NewPc->Overflow = 1;
NewPc->SReg = Min;
} else if (i > Max) {
NewPc->Overflow = 1;
NewPc->SReg = Max;
}
// Back-convert to get a pseudo-address.
if (NewPc->Unbanked)
NewPc->Value = NewPc->SReg;
else if (NewPc->Erasable) {
NewPc->Value = (NewPc->SReg - 01400) + 0400 * NewPc->EB;
}
else if (NewPc->Fixed) {
NewPc->Value = 010000 + (NewPc->SReg - 02000) + 02000 * NewPc->FB;
if (NewPc->Super && NewPc->FB >= 030)
NewPc->Value += 010 * 02000;
} else
goto ImplementationError;
return;
ImplementationError:
// Can't occur, but I give it a good pinch if it does!
NewPc->Invalid = 1;
}
