2763 lines
76 KiB
Plaintext
2763 lines
76 KiB
Plaintext
void aba(void);
|
|
void abx(void);
|
|
void aby(void);
|
|
void adca(void);
|
|
void adcb(void);
|
|
void adda(void);
|
|
void addb(void);
|
|
void addd(void);
|
|
void anda(void);
|
|
void andb(void);
|
|
void asl(void);
|
|
void asla(void);
|
|
void aslb(void);
|
|
void asld(void);
|
|
void asr(void);
|
|
void asra(void);
|
|
void asrb(void);
|
|
void bcc(void);
|
|
void bclr(void);
|
|
void bcs(void);
|
|
void beq(void);
|
|
void bge(void);
|
|
void bgt(void);
|
|
void bhi(void);
|
|
void bhs(void);
|
|
void bita(void);
|
|
void bitb(void);
|
|
void ble(void);
|
|
void blo(void);
|
|
void bls(void);
|
|
void blt(void);
|
|
void bmi(void);
|
|
void bne(void);
|
|
void bpl(void);
|
|
void bra(void);
|
|
void brclr(void);
|
|
void brn(void);
|
|
void brset(void);
|
|
void bset(void);
|
|
void bsr(void);
|
|
void bvc(void);
|
|
void bvs(void);
|
|
void cba(void);
|
|
void clc(void);
|
|
void cli(void);
|
|
void clr(void);
|
|
void clra(void);
|
|
void clrb(void);
|
|
void clv(void);
|
|
void cmpa(void);
|
|
void cmpb(void);
|
|
void com(void);
|
|
void coma(void);
|
|
void comb(void);
|
|
void cpd(void);
|
|
void cpx(void);
|
|
void cpy(void);
|
|
void daa(void);
|
|
void dec(void);
|
|
void deca(void);
|
|
void decb(void);
|
|
void des(void);
|
|
void dex(void);
|
|
void dey(void);
|
|
void eora(void);
|
|
void eorb(void);
|
|
void fdiv(void);
|
|
void idiv(void);
|
|
void inc(void);
|
|
void inca(void);
|
|
void incb(void);
|
|
void ins(void);
|
|
void inx(void);
|
|
void iny(void);
|
|
void jmp(void);
|
|
void jsr(void);
|
|
void ldaa(void);
|
|
void ldab(void);
|
|
void ldd(void);
|
|
void lds(void);
|
|
void ldx(void);
|
|
void ldy(void);
|
|
void lsl(void);
|
|
void lsla(void);
|
|
void lslb(void);
|
|
void lsld(void);
|
|
void lsr(void);
|
|
void lsra(void);
|
|
void lsrb(void);
|
|
void lsrd(void);
|
|
void mul(void);
|
|
void neg(void);
|
|
void nega(void);
|
|
void negb(void);
|
|
void nop(void);
|
|
void oraa(void);
|
|
void orab(void);
|
|
void psha(void);
|
|
void pshb(void);
|
|
void pshx(void);
|
|
void pshy(void);
|
|
void pula(void);
|
|
void pulb(void);
|
|
void pulx(void);
|
|
void puly(void);
|
|
void rol(void);
|
|
void rola(void);
|
|
void rolb(void);
|
|
void ror(void);
|
|
void rora(void);
|
|
void rorb(void);
|
|
void rti(void);
|
|
void rts(void);
|
|
void sba(void);
|
|
void sbca(void);
|
|
void sbcb(void);
|
|
void sec(void);
|
|
void sei(void);
|
|
void sev(void);
|
|
void staa(void);
|
|
void stab(void);
|
|
void std(void);
|
|
void stop(void);
|
|
void sts(void);
|
|
void stx(void);
|
|
void sty(void);
|
|
void suba(void);
|
|
void subb(void);
|
|
void subd(void);
|
|
void swi(void);
|
|
void tab(void);
|
|
void tap(void);
|
|
void tba(void);
|
|
void test(void);
|
|
void tpa(void);
|
|
void tst(void);
|
|
void tsta(void);
|
|
void tstb(void);
|
|
void tsx(void);
|
|
void tsy(void);
|
|
void txs(void);
|
|
void tys(void);
|
|
void wai(void);
|
|
void xgdx(void);
|
|
void xgdy(void);
|
|
|
|
|
|
#if 0
|
|
case Scan::aba1 :{aba();break;}
|
|
case Scan::abx1 :{abx();break;}
|
|
case Scan::aby1 :{aby();break;}
|
|
case Scan::adca1 :{adca();break;}
|
|
case Scan::adcb1 :{adcb();break;}
|
|
case Scan::adda1 :{adda();break;}
|
|
case Scan::addb1 :{addb();break;}
|
|
case Scan::addd1 :{addd();break;}
|
|
case Scan::anda1 :{anda();break;}
|
|
case Scan::andb1 :{andb();break;}
|
|
case Scan::asl1 :{asl();break;}
|
|
case Scan::asla1 :{asla();break;}
|
|
case Scan::aslb1 :{aslb();break;}
|
|
case Scan::asld1 :{asld();break;}
|
|
case Scan::asr1 :{asr();break;}
|
|
case Scan::asra1 :{asra();break;}
|
|
case Scan::asrb1 :{asrb();break;}
|
|
case Scan::bcc1 :{bcc();break;}
|
|
case Scan::bclr1 :{bclr();break;}
|
|
case Scan::bcs1 :{bcs();break;}
|
|
case Scan::beq1 :{beq();break;}
|
|
case Scan::bge1 :{bge();break;}
|
|
case Scan::bgt1 :{bgt();break;}
|
|
case Scan::bhi1 :{bhi();break;}
|
|
case Scan::bhs1 :{bhs();break;}
|
|
case Scan::bita1 :{bita();break;}
|
|
case Scan::bitb1 :{bitb();break;}
|
|
case Scan::ble1 :{ble();break;}
|
|
case Scan::blo1 :{blo();break;}
|
|
case Scan::bls1 :{bls();break;}
|
|
case Scan::blt1 :{blt();break;}
|
|
case Scan::bmi1 :{bmi();break;}
|
|
case Scan::bne1 :{bne();break;}
|
|
case Scan::bpl1 :{bpl();break;}
|
|
case Scan::bra1 :{bra();break;}
|
|
case Scan::brclr1 :{brclr();break;}
|
|
case Scan::brn1 :{brn();break;}
|
|
case Scan::brset1 :{brset();break;}
|
|
case Scan::bset1 :{bset();break;}
|
|
case Scan::bsr1 :{bsr();break;}
|
|
case Scan::bvc1 :{bvc();break;}
|
|
case Scan::bvs1 :{bvs();break;}
|
|
case Scan::cba1 :{cba();break;}
|
|
case Scan::clc1 :{clc();break;}
|
|
case Scan::cli1 :{cli();break;}
|
|
case Scan::clr1 :{clr();break;}
|
|
case Scan::clra1 :{clra();break;}
|
|
case Scan::clrb1 :{clrb();break;}
|
|
case Scan::clv1 :{clv();break;}
|
|
case Scan::cmpa1 :{cmpa();break;}
|
|
case Scan::cmpb1 :{cmpb();break;}
|
|
case Scan::com1 :{com();break;}
|
|
case Scan::coma1 :{coma();break;}
|
|
case Scan::comb1 :{comb();break;}
|
|
case Scan::cpd1 :{cpd();break;}
|
|
case Scan::cpx1 :{cpx();break;}
|
|
case Scan::cpy1 :{cpy();break;}
|
|
case Scan::daa1 :{daa();break;}
|
|
case Scan::dec1 :{dec();break;}
|
|
case Scan::deca1 :{deca();break;}
|
|
case Scan::decb1 :{decb();break;}
|
|
case Scan::des1 :{des();break;}
|
|
case Scan::dex1 :{dex();break;}
|
|
case Scan::dey1 :{dey();break;}
|
|
case Scan::eora1 :{eora();break;}
|
|
case Scan::eorb1 :{eorb();break;}
|
|
case Scan::fdiv1 :{fdiv();break;}
|
|
case Scan::idiv1 :{idiv();break;}
|
|
case Scan::inc1 :{inc();break;}
|
|
case Scan::inca1 :{inca();break;}
|
|
case Scan::incb1 :{incb();break;}
|
|
case Scan::ins1 :{ins();break;}
|
|
case Scan::inx1 :{inx();break;}
|
|
case Scan::iny1 :{iny();break;}
|
|
case Scan::jmp1 :{jmp();break;}
|
|
case Scan::jsr1 :{jsr();break;}
|
|
case Scan::ldaa1 :{ldaa();break;}
|
|
case Scan::ldab1 :{ldab();break;}
|
|
case Scan::ldd1 :{ldd();break;}
|
|
case Scan::lds1 :{lds();break;}
|
|
case Scan::ldx1 :{ldx();break;}
|
|
case Scan::ldy1 :{ldy();break;}
|
|
case Scan::lsl1 :{lsl();break;}
|
|
case Scan::lsla1 :{lsla();break;}
|
|
case Scan::lslb1 :{lslb();break;}
|
|
case Scan::lsld1 :{lsld();break;}
|
|
case Scan::lsr1 :{lsr();break;}
|
|
case Scan::lsra1 :{lsra();break;}
|
|
case Scan::lsrb1 :{lsrb();break;}
|
|
case Scan::lsrd1 :{lsrd();break;}
|
|
case Scan::mul1 :{mul();break;}
|
|
case Scan::neg1 :{neg();break;}
|
|
case Scan::nega1 :{nega();break;}
|
|
case Scan::negb1 :{negb();break;}
|
|
case Scan::nop1 :{nop();break;}
|
|
case Scan::oraa1 :{oraa();break;}
|
|
case Scan::orab1 :{orab();break;}
|
|
case Scan::psha1 :{psha();break;}
|
|
case Scan::pshb1 :{pshb();break;}
|
|
case Scan::pshx1 :{pshx();break;}
|
|
case Scan::pshy1 :{pshy();break;}
|
|
case Scan::pula1 :{pula();break;}
|
|
case Scan::pulb1 :{pulb();break;}
|
|
case Scan::pulx1 :{pulx();break;}
|
|
case Scan::puly1 :{puly();break;}
|
|
case Scan::rol1 :{rol();break;}
|
|
case Scan::rola1 :{rola();break;}
|
|
case Scan::rolb1 :{rolb();break;}
|
|
case Scan::ror1 :{ror();break;}
|
|
case Scan::rora1 :{rora();break;}
|
|
case Scan::rorb1 :{rorb();break;}
|
|
case Scan::rti1 :{rti();break;}
|
|
case Scan::rts1 :{rts();break;}
|
|
case Scan::sba1 :{sba();break;}
|
|
case Scan::sbca1 :{sbca();break;}
|
|
case Scan::sbcb1 :{sbcb();break;}
|
|
case Scan::sec1 :{sec();break;}
|
|
case Scan::sei1 :{sei();break;}
|
|
case Scan::sev1 :{sev();break;}
|
|
case Scan::staa1 :{staa();break;}
|
|
case Scan::stab1 :{stab();break;}
|
|
case Scan::std1 :{std();break;}
|
|
case Scan::stop1 :{stop();break;}
|
|
case Scan::sts1 :{sts();break;}
|
|
case Scan::stx1 :{stx();break;}
|
|
case Scan::sty1 :{sty();break;}
|
|
case Scan::suba1 :{suba();break;}
|
|
case Scan::subb1 :{subb();break;}
|
|
case Scan::subd1 :{subd();break;}
|
|
case Scan::swi1 :{swi();break;}
|
|
case Scan::tab1 :{tab();break;}
|
|
case Scan::tap1 :{tap();break;}
|
|
case Scan::tba1 :{tba();break;}
|
|
case Scan::test1 :{test();break;}
|
|
case Scan::tpa1 :{tpa();break;}
|
|
case Scan::tst1 :{tst();break;}
|
|
case Scan::tsta1 :{tsta();break;}
|
|
case Scan::tstb1 :{tstb();break;}
|
|
case Scan::tsx1 :{tsx();break;}
|
|
case Scan::tsy1 :{tsy();break;}
|
|
case Scan::txs1 :{txs();break;}
|
|
case Scan::tys1 :{tys();break;}
|
|
case Scan::wai1 :{wai();break;}
|
|
case Scan::xgdx1 :{xgdx();break;}
|
|
case Scan::xgdy1 :{xgdy();break;}
|
|
case Scan::end1 :{;break;}
|
|
nextSymbol();
|
|
break;
|
|
#endif
|
|
|
|
|
|
#if 0
|
|
void Parse::aba(void)
|
|
{
|
|
}
|
|
|
|
void Parse::abx(void)
|
|
{
|
|
}
|
|
|
|
void Parse::aby(void)
|
|
{
|
|
}
|
|
|
|
void Parse::adca(void)
|
|
{
|
|
}
|
|
|
|
void Parse::adcb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::adda(void)
|
|
{
|
|
}
|
|
|
|
void Parse::addb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::addd(void)
|
|
{
|
|
}
|
|
|
|
void Parse::anda(void)
|
|
{
|
|
}
|
|
|
|
void Parse::andb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asl(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asla(void)
|
|
{
|
|
}
|
|
|
|
void Parse::aslb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asld(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asr(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asra(void)
|
|
{
|
|
}
|
|
|
|
void Parse::asrb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bcc(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bclr(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bcs(void)
|
|
{
|
|
}
|
|
|
|
void Parse::beq(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bge(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bgt(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bhi(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bhs(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bita(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bitb(void)
|
|
{
|
|
}
|
|
|
|
void Parse::ble(void)
|
|
{
|
|
}
|
|
|
|
void Parse::blo(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bls(void)
|
|
{
|
|
}
|
|
|
|
void Parse::blt(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bmi(void)
|
|
{
|
|
}
|
|
|
|
void Parse::bne(void);
|
|
void Parse::bpl(void);
|
|
void Parse::bra(void);
|
|
void Parse::brclr(void);
|
|
void Parse::brn(void);
|
|
void Parse::brset(void);
|
|
void Parse::bset(void);
|
|
void Parse::bsr(void);
|
|
void Parse::bvc(void);
|
|
void Parse::bvs(void);
|
|
void Parse::cba(void);
|
|
void Parse::clc(void);
|
|
void Parse::cli(void);
|
|
void Parse::clr(void);
|
|
void Parse::clra(void);
|
|
void Parse::clrb(void);
|
|
void Parse::clv(void);
|
|
void Parse::cmpa(void);
|
|
void Parse::cmpb(void);
|
|
void Parse::com(void);
|
|
void Parse::coma(void);
|
|
void Parse::comb(void);
|
|
void Parse::cpd(void);
|
|
void Parse::cpx(void);
|
|
void Parse::cpy(void);
|
|
void Parse::daa(void);
|
|
void Parse::dec(void);
|
|
void Parse::deca(void);
|
|
void Parse::decb(void);
|
|
void Parse::des(void);
|
|
void Parse::dex(void);
|
|
void Parse::dey(void);
|
|
void Parse::eora(void);
|
|
void Parse::eorb(void);
|
|
void Parse::fdiv(void);
|
|
void Parse::idiv(void);
|
|
void Parse::inc(void);
|
|
void Parse::inca(void);
|
|
void Parse::incb(void);
|
|
void Parse::ins(void);
|
|
void Parse::inx(void);
|
|
void Parse::iny(void);
|
|
void Parse::jmp(void);
|
|
void Parse::jsr(void);
|
|
void Parse::ldaa(void);
|
|
void Parse::ldab(void);
|
|
void Parse::ldd(void);
|
|
void Parse::lds(void);
|
|
void Parse::ldx(void);
|
|
void Parse::ldy(void);
|
|
void Parse::lsl(void);
|
|
void Parse::lsla(void);
|
|
void Parse::lslb(void);
|
|
void Parse::lsld(void);
|
|
void Parse::lsr(void);
|
|
void Parse::lsra(void);
|
|
void Parse::lsrb(void);
|
|
void Parse::lsrd(void);
|
|
void Parse::mul(void);
|
|
void Parse::neg(void);
|
|
void Parse::nega(void);
|
|
void Parse::negb(void);
|
|
void Parse::nop(void);
|
|
void Parse::oraa(void);
|
|
void Parse::orab(void);
|
|
void Parse::psha(void);
|
|
void Parse::pshb(void);
|
|
void Parse::pshx(void);
|
|
void Parse::pshy(void);
|
|
void Parse::pula(void);
|
|
void Parse::pulb(void);
|
|
void Parse::pulx(void);
|
|
void Parse::puly(void);
|
|
void Parse::rol(void);
|
|
void Parse::rola(void);
|
|
void Parse::rolb(void);
|
|
void Parse::ror(void);
|
|
void Parse::rora(void);
|
|
void Parse::rorb(void);
|
|
void Parse::rti(void);
|
|
void Parse::rts(void);
|
|
void Parse::sba(void);
|
|
void Parse::sbca(void);
|
|
void Parse::sbcb(void);
|
|
void Parse::sec(void);
|
|
void Parse::sei(void);
|
|
void Parse::sev(void);
|
|
void Parse::staa(void);
|
|
void Parse::stab(void);
|
|
void Parse::std(void);
|
|
void Parse::stop(void);
|
|
void Parse::sts(void);
|
|
void Parse::stx(void);
|
|
void Parse::sty(void);
|
|
void Parse::suba(void);
|
|
void Parse::subb(void);
|
|
void Parse::subd(void);
|
|
void Parse::swi(void);
|
|
void Parse::tab(void);
|
|
void Parse::tap(void);
|
|
void Parse::tba(void);
|
|
void Parse::test(void);
|
|
void Parse::tpa(void);
|
|
void Parse::tst(void);
|
|
void Parse::tsta(void);
|
|
void Parse::tstb(void);
|
|
void Parse::tsx(void);
|
|
void Parse::tsy(void);
|
|
void Parse::txs(void);
|
|
void Parse::tys(void);
|
|
void Parse::wai(void);
|
|
void Parse::xgdx(void);
|
|
void Parse::xgdy(void);
|
|
#endif
|
|
|
|
|
|
|
|
|
|
// peek((int&)nextSymbol);
|
|
// if(Scan::colon1==nextSymbol)
|
|
// {
|
|
// insertSymbols(ParseSymbol(Scan::colon1));
|
|
// expect(Scan::name1);
|
|
// removeSymbols(ParseSymbol(Scan::colon1));
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::colon1);
|
|
// removeSymbols(mStatementSymbols);
|
|
// emit(label2);
|
|
// }
|
|
// else syntaxCheck();
|
|
|
|
|
|
{
|
|
for(int index=0;index<symbols.size();index++)
|
|
{
|
|
if(symbols[index].hasImmediateMode())
|
|
{
|
|
Symbol &symbol=symbols[index];
|
|
String strRegisterLength;
|
|
|
|
if(Instruction::SingleByte==symbol.registerLength())strRegisterLength=" SingleByte";
|
|
else if(Instruction::DoubleByte==symbol.registerLength())strRegisterLength=" DoubleByte";
|
|
else strRegisterLength=" NotApplicable";
|
|
::OutputDebugString(symbol.symbolName()+strRegisterLength+String("\n"));
|
|
}
|
|
// ::OutputDebugString((String)symbols[index]+String("\n"));
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
BOOL Scan::scanNumeral(void)
|
|
{
|
|
char chBuffer[128];
|
|
char chIndex(0);
|
|
int value(0);
|
|
|
|
while(isdigit(mChar)||isInHex(mChar))
|
|
{
|
|
if(chIndex>=sizeof(chBuffer))return FALSE;
|
|
chBuffer[chIndex++]=mChar;
|
|
readch();
|
|
}
|
|
if('h'==mChar){value=hex(chBuffer,chIndex);readch();}
|
|
else if('b'==mChar){value=binary(chBuffer,chIndex);readch();}
|
|
else value=decimal(chBuffer,chIndex);
|
|
emit(numeral1,value);
|
|
return TRUE;
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#include <as68hc11/table.hpp>
|
|
#include <as68hc11/parse.hpp>
|
|
#include <as68hc11/label.hpp>
|
|
#include <common/stdio.hpp>
|
|
|
|
Parse::Parse(PureViewOfFile &srcView,PureViewOfFile &dstView)
|
|
: Emit(srcView,dstView), mNumeralValue(0), mIsInError(FALSE), mLastMessage("Success"),
|
|
mLastLineNumber(FirstLine), mLineNumber(FirstLine), mCurrentSymbolType(Scan::unknown1),
|
|
mOrigin(0), mLogFile("parse.log",FileHandle::Write,FileHandle::ShareRead,FileHandle::Overwrite)
|
|
{
|
|
createSimpleExpressionSymbols();
|
|
createExpressionSymbols();
|
|
createStatementSymbols();
|
|
createFactorSymbols();
|
|
createTermSymbols();
|
|
createMathSymbols();
|
|
createAddSymbols();
|
|
createSignSymbols();
|
|
}
|
|
|
|
Parse::~Parse()
|
|
{
|
|
}
|
|
|
|
void Parse::parse(void)
|
|
{
|
|
nextSymbol();
|
|
// emit(codestart2);
|
|
insertSymbols(ParseSymbol(Scan::endtext1));
|
|
while(Scan::endtext1!=currentSymbolType()&&!isInError())statement();
|
|
removeSymbols(ParseSymbol(Scan::endtext1));
|
|
resolve();
|
|
// emit(codeend2);
|
|
}
|
|
|
|
void Parse::statement(void)
|
|
{
|
|
if(Scan::label1==currentSymbolType())labelStatement();
|
|
else if(Scan::directive1==currentSymbolType())directiveStatement();
|
|
else if(Scan::name1==currentSymbolType())
|
|
{
|
|
switch(mCurrentSymbol->symbolType())
|
|
{
|
|
case Symbol::KeywordSymbol :
|
|
keywordStatement();
|
|
break;
|
|
case Symbol::DirectiveSymbol :
|
|
directiveStatement();
|
|
break;
|
|
case Symbol::UserSymbol :
|
|
userStatement();
|
|
break;
|
|
}
|
|
}
|
|
else syntaxCheck();
|
|
// else errorExpect(Scan::name1);
|
|
// else if(Scan::startliteral1==mSymbol)userStatement();
|
|
// else syntaxCheck();
|
|
}
|
|
|
|
void Parse::labelStatement(void)
|
|
{
|
|
Label codeLabel;
|
|
SmartPointer<Label> nodeLabel;
|
|
|
|
codeLabel.strLabel(mLiteralValue);
|
|
codeLabel.offset(outputView().tell());
|
|
codeLabel.disposition(Label::Absolute);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(currentSymbolType());
|
|
removeSymbols(mStatementSymbols);
|
|
if(isInError())return;
|
|
if(mLabelGenerator.insert(codeLabel))return;
|
|
if(!mLabelGenerator.searchItem(codeLabel,nodeLabel))return;
|
|
if(Label::Absolute==nodeLabel->disposition()){error(SymbolAlreadyDefined);return;}
|
|
nodeLabel->disposition(Label::Absolute);
|
|
nodeLabel->offset(outputView().tell());
|
|
}
|
|
|
|
void Parse::userStatement(void)
|
|
{
|
|
Scan::ScanSymbols nextSymbol;
|
|
|
|
// insertSymbols(ParseSymbol(Scan::colon1));
|
|
// expect(Scan::name1);
|
|
// removeSymbols(ParseSymbol(Scan::colon1));
|
|
// if(isInError())return;
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::colon1);
|
|
// removeSymbols(mStatementSymbols);
|
|
// if(isInError())return;
|
|
// emit(label2);
|
|
}
|
|
void Parse::directiveStatement(void)
|
|
{
|
|
SmartPointer<Symbol> currentSymbol=mCurrentSymbol;
|
|
|
|
if(Scan::origin1==currentSymbol->identifier())
|
|
{
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(mCurrentSymbolType);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
mOrigin=mNumeralValue;
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
}
|
|
else errorExpect(Symbol::DirectiveSymbol);
|
|
}
|
|
|
|
void Parse::keywordStatement(void)
|
|
{
|
|
SmartPointer<Symbol> currentSymbol;
|
|
Scan::ScanSymbols peekSymbol;
|
|
WORD indexForm;
|
|
DWORD value;
|
|
|
|
currentSymbol=mCurrentSymbol;
|
|
if(currentSymbol->hasInherentMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
displayEncoding(currentSymbol,addressMode,0,0);
|
|
// emit(purecode2,0x01);
|
|
emit((*mCurrentSymbol)[0].opcode());
|
|
insertSymbols(mStatementSymbols);
|
|
nextSymbol();
|
|
removeSymbols(mStatementSymbols);
|
|
return;
|
|
}
|
|
peek((int&)peekSymbol);
|
|
if(Scan::leftbracket1==peekSymbol)
|
|
{
|
|
insertSymbols(ParseSymbol(peekSymbol));
|
|
nextSymbol();
|
|
removeSymbols(ParseSymbol(peekSymbol));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(peekSymbol);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
value=mNumeralValue;
|
|
insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
expect(Scan::numeral1);
|
|
removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
insertSymbols(mStatementSymbols);
|
|
nextSymbol();
|
|
removeSymbols(mStatementSymbols);
|
|
if(!inRange(value))error(ValueOutOfRangeForInstruction);
|
|
else if(value>0xFF) // use extended addressing
|
|
{
|
|
if(currentSymbol->hasExtendedMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte()){emit(purecode2,0x04);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x03);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(value));
|
|
emit(loByte(value));
|
|
displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
else // value <=0xFF
|
|
{
|
|
if(currentSymbol->hasDirectMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte()){emit(purecode2,0x03);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x02);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(value));
|
|
displayEncoding(currentSymbol,addressMode,value,FALSE);
|
|
}
|
|
else
|
|
{
|
|
if(currentSymbol->hasExtendedMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte()){emit(purecode2,0x04);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x03);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(value));
|
|
emit(loByte(value));
|
|
displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
}
|
|
}
|
|
else if(Scan::numeral1==peekSymbol) // immediate
|
|
{
|
|
if(currentSymbol->hasImmediateMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(mCurrentSymbolType);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
insertSymbols(mStatementSymbols);
|
|
value=mNumeralValue;
|
|
if(!inRange(value))error(ValueOutOfRangeForInstruction);
|
|
else if(Instruction::SingleByte==currentSymbol->registerLength())
|
|
{
|
|
if(value<=0xFF)
|
|
{
|
|
// if(addressMode.prebyte()){emit(purecode2,0x03);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x02);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(value));
|
|
}
|
|
else error(OperandSizeMustMatch);
|
|
}
|
|
else
|
|
{
|
|
// if(addressMode.prebyte()){emit(purecode2,0x04);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x03);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(value));
|
|
emit(loByte(value));
|
|
}
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
displayEncoding(currentSymbol,addressMode,value,Instruction::DoubleByte==currentSymbol->registerLength()?TRUE:FALSE);
|
|
}
|
|
else if(mCurrentSymbol->hasRelativeMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte()){emit(purecode2,0x04);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x03);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(value));
|
|
emit(loByte(value));
|
|
displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
else // could be relative or indexed
|
|
{
|
|
if(currentSymbol->hasIndexedMode(indexForm)) // indexed
|
|
{
|
|
SmartPointer<Symbol> nextSymbol;
|
|
DWORD expressionResult(0);
|
|
|
|
insertSymbols(ParseSymbol(Scan::name1));
|
|
expect(Scan::name1);
|
|
nextSymbol=mCurrentSymbol;
|
|
if(!nextSymbol.isOkay())
|
|
{
|
|
error(ExpectedIndexRegister);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
return;
|
|
}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::name1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
this->nextSymbol();
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(mStatementSymbols);
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// emit(purecode2,0x02);
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
}
|
|
else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasPreByte(indexForm);
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// emit(purecode2,0x03);
|
|
emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
}
|
|
else error(ExpectedIndexRegister);
|
|
return;
|
|
}
|
|
else if(currentSymbol->hasRelativeMode(indexForm)) // relative
|
|
{
|
|
BOOL needsFixup(FALSE);
|
|
Label branchLabel;
|
|
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(Scan::label1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::label1));
|
|
branchLabel.strLabel(mLiteralValue);
|
|
if(!mLabelGenerator.find(branchLabel))
|
|
{
|
|
branchLabel.offset(0);
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
needsFixup=TRUE;
|
|
}
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::label1);
|
|
removeSymbols(mStatementSymbols);
|
|
// if(currentSymbol->hasPreByte()){emit(purecode2,0x03);emit(addressMode.prebyte());}
|
|
// else emit(purecode2,0x02);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
if(needsFixup)
|
|
{
|
|
mFixups.insert(&Fixup(outputView().tell(),branchLabel));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else emit(BYTE(-((outputView().tell()-branchLabel.offset()))));
|
|
displayEncoding(currentSymbol,addressMode,-((outputView().tell()-branchLabel.offset())),FALSE);
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
}
|
|
|
|
void Parse::simpleExpression(DWORD &expressionResult)
|
|
{
|
|
insertSymbols(mAddSymbols);
|
|
insertSymbols(mTermSymbols);
|
|
insertSymbols(mSignSymbols);
|
|
syntaxCheck();
|
|
removeSymbols(mSignSymbols);
|
|
if(symbolIn(mSignSymbols))
|
|
{
|
|
DWORD indexItem;
|
|
Scan::ScanSymbols currSymbol(mCurrentSymbolType);
|
|
expect(mCurrentSymbolType);
|
|
if(Scan::minus1==currSymbol)expressionResult=-expressionResult;
|
|
removeSymbols(mTermSymbols);
|
|
}
|
|
else
|
|
{
|
|
removeSymbols(mTermSymbols);
|
|
expressionResult=term();
|
|
}
|
|
while(symbolIn(mAddSymbols))
|
|
{
|
|
DWORD localExpression;
|
|
Scan::ScanSymbols currSymbol(mCurrentSymbolType);
|
|
insertSymbols(mTermSymbols);
|
|
expect(mCurrentSymbolType);
|
|
removeSymbols(mTermSymbols);
|
|
localExpression=term();
|
|
if(Scan::plus1==currSymbol)expressionResult+=localExpression;
|
|
else if(Scan::minus1==currSymbol)expressionResult-=localExpression;
|
|
else syntaxError();
|
|
}
|
|
removeSymbols(mAddSymbols);
|
|
}
|
|
|
|
DWORD Parse::term(void)
|
|
{
|
|
DWORD termResult;
|
|
|
|
insertSymbols(mMathSymbols);
|
|
factor(termResult);
|
|
while(symbolIn(mMathSymbols))
|
|
{
|
|
DWORD localTerm;
|
|
Scan::ScanSymbols currSymbol(mCurrentSymbolType);
|
|
insertSymbols(mFactorSymbols);
|
|
expect(mCurrentSymbolType);
|
|
removeSymbols(mFactorSymbols);
|
|
factor(localTerm);
|
|
if(Scan::multiply1==currSymbol)termResult*=localTerm;
|
|
else if(Scan::divide1==currSymbol)termResult/=localTerm;
|
|
}
|
|
removeSymbols(mMathSymbols);
|
|
return termResult;
|
|
}
|
|
|
|
void Parse::factor(DWORD &expressionResult)
|
|
{
|
|
if(Scan::numeral1==mCurrentSymbolType)
|
|
{
|
|
expressionResult=mNumeralValue;
|
|
expect(mCurrentSymbolType);
|
|
}
|
|
else if(Scan::leftparen1==mCurrentSymbolType)
|
|
{
|
|
insertSymbols(ParseSymbol(Scan::rightparen1));
|
|
insertSymbols(mExpressionSymbols);
|
|
expect(mCurrentSymbolType);
|
|
removeSymbols(mExpressionSymbols);
|
|
expression(expressionResult);
|
|
removeSymbols(ParseSymbol(Scan::rightparen1));
|
|
expect(Scan::rightparen1);
|
|
}
|
|
else syntaxError();
|
|
}
|
|
|
|
void Parse::expression(DWORD &expressionResult)
|
|
{
|
|
simpleExpression(expressionResult);
|
|
}
|
|
|
|
WORD Parse::nextSymbol(void)
|
|
{
|
|
mNumeralValue=0;
|
|
mCurrentSymbolType=Scan::unknown1;
|
|
mCurrentSymbol=(Symbol*)0;
|
|
if(0xFFFF==read((int&)mCurrentSymbolType))return FALSE;
|
|
while(Scan::newline1==mCurrentSymbolType)
|
|
{
|
|
if(0xFFFF==read((int&)mCurrentSymbolType))return FALSE;
|
|
mLineNumber++;
|
|
}
|
|
if(Scan::numeral1==mCurrentSymbolType)read((int&)mNumeralValue);
|
|
else if(Scan::name1==mCurrentSymbolType)
|
|
{
|
|
int address;
|
|
if(0xFFFF==read(address))return FALSE;
|
|
mCurrentSymbol=(Symbol*)address;
|
|
}
|
|
else if(Scan::label1==mCurrentSymbolType)read(mLiteralValue);
|
|
return TRUE;
|
|
}
|
|
|
|
int Parse::symbolIn(Block<ParseSymbol> &parseSymbols)const
|
|
{
|
|
ParseSymbol currentSymbol(mCurrentSymbolType);
|
|
int size((size_t)parseSymbols.size());
|
|
for(int index=0;index<size;index++)if(currentSymbol==parseSymbols[index])return TRUE;
|
|
return FALSE;
|
|
}
|
|
|
|
void Parse::syntaxError(void)
|
|
{
|
|
if(!isInError())
|
|
{
|
|
mLastMessage=String("<Syntax error.>");
|
|
mLastLineNumber=mLineNumber;
|
|
mIsInError=TRUE;
|
|
}
|
|
while(!mParseSymbols.symbolIn(mCurrentSymbolType)&&nextSymbol());
|
|
}
|
|
|
|
void Parse::syntaxError(int symbol)
|
|
{
|
|
errorExpect(symbol);
|
|
while(!mParseSymbols.symbolIn(mCurrentSymbolType)&&nextSymbol());
|
|
}
|
|
|
|
void Parse::errorExpect(Symbol::SymbolType symbolType)
|
|
{
|
|
if(isInError())return;
|
|
switch(symbolType)
|
|
{
|
|
case Symbol::ConstantSymbol :
|
|
mLastMessage=String("<Expected Constant.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Symbol::KeywordSymbol :
|
|
mLastMessage=String("<Expected Keyword.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Symbol::RegisterSymbol :
|
|
mLastMessage=String("<Expected Register (ix,iy).>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Symbol::DirectiveSymbol :
|
|
mLastMessage=String("<Expected Directive.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Symbol::UserSymbol :
|
|
mLastMessage=String("<Expected User Defined Type.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
}
|
|
mIsInError=TRUE;
|
|
}
|
|
|
|
void Parse::errorExpect(int scanSymbol)
|
|
{
|
|
if(isInError())return;
|
|
switch(scanSymbol)
|
|
{
|
|
case Scan::name1 :
|
|
mLastMessage=String("<Expected Keyword.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Scan::comma1 :
|
|
mLastMessage=String("<Expected ','.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Scan::leftbracket1 :
|
|
mLastMessage=String("<Expected '['.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case Scan::rightbracket1 :
|
|
mLastMessage=String("<Expected ']'.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
default :
|
|
mLastMessage=String("<Expected symbol.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
}
|
|
mIsInError=TRUE;
|
|
}
|
|
|
|
void Parse::error(ErrorCode errorCode)
|
|
{
|
|
if(isInError())return;
|
|
switch(errorCode)
|
|
{
|
|
case OperandSizeMustMatch :
|
|
mLastMessage=String("Operand size must match.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case IllegalAddressingModeForMnemonic :
|
|
mLastMessage=String("Illegal addressing mode requested for mnemonic.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case ExpectedIndexRegister :
|
|
mLastMessage=String("Expected index register {ix/iy}.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case ValueOutOfRangeForInstruction :
|
|
mLastMessage=String("Value out of range for instruction.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case SymbolAlreadyDefined :
|
|
mLastMessage=String("Symbol already defined.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
case SymbolNotDefined :
|
|
mLastMessage=String("Undefined symbol.");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
default :
|
|
mLastMessage=String("<Unknown error interpreting mnemonic.>");
|
|
mLastLineNumber=mLineNumber;
|
|
break;
|
|
}
|
|
mIsInError=TRUE;
|
|
}
|
|
|
|
void Parse::createStatementSymbols(void)
|
|
{
|
|
mStatementSymbols.remove();
|
|
mStatementSymbols.insert(&ParseSymbol(Scan::name1));
|
|
mStatementSymbols.insert(&ParseSymbol(Scan::directive1));
|
|
mStatementSymbols.insert(&ParseSymbol(Scan::label1));
|
|
}
|
|
|
|
void Parse::createSimpleExpressionSymbols(void)
|
|
{
|
|
mSimpleExpressionSymbols.remove();
|
|
mSimpleExpressionSymbols.insert(&ParseSymbol(Scan::plus1));
|
|
mSimpleExpressionSymbols.insert(&ParseSymbol(Scan::minus1));
|
|
mSimpleExpressionSymbols.insert(&ParseSymbol(Scan::leftparen1));
|
|
mSimpleExpressionSymbols.insert(&ParseSymbol(Scan::numeral1));
|
|
}
|
|
|
|
void Parse::createMathSymbols(void)
|
|
{
|
|
mMathSymbols.remove();
|
|
mMathSymbols.insert(&ParseSymbol(Scan::multiply1));
|
|
mMathSymbols.insert(&ParseSymbol(Scan::divide1));
|
|
}
|
|
|
|
void Parse::createTermSymbols(void)
|
|
{
|
|
mTermSymbols.remove();
|
|
mTermSymbols.insert(&ParseSymbol(Scan::leftparen1));
|
|
mTermSymbols.insert(&ParseSymbol(Scan::numeral1));
|
|
}
|
|
|
|
void Parse::createFactorSymbols(void)
|
|
{
|
|
mFactorSymbols.remove();
|
|
mFactorSymbols.insert(&ParseSymbol(Scan::leftparen1));
|
|
mFactorSymbols.insert(&ParseSymbol(Scan::numeral1));
|
|
}
|
|
|
|
void Parse::createAddSymbols(void)
|
|
{
|
|
mAddSymbols.remove();
|
|
mAddSymbols.insert(&ParseSymbol(Scan::minus1));
|
|
mAddSymbols.insert(&ParseSymbol(Scan::plus1));
|
|
}
|
|
|
|
void Parse::createSignSymbols(void)
|
|
{
|
|
mSignSymbols.remove();
|
|
mSignSymbols.insert(&ParseSymbol(Scan::minus1));
|
|
mSignSymbols.insert(&ParseSymbol(Scan::plus1));
|
|
}
|
|
|
|
void Parse::createExpressionSymbols(void)
|
|
{
|
|
mExpressionSymbols.remove();
|
|
mExpressionSymbols.insert(&ParseSymbol(Scan::leftparen1));
|
|
mExpressionSymbols.insert(&ParseSymbol(Scan::minus1));
|
|
mExpressionSymbols.insert(&ParseSymbol(Scan::plus1));
|
|
mExpressionSymbols.insert(&ParseSymbol(Scan::numeral1));
|
|
}
|
|
|
|
void Parse::display(SmartPointer<Symbol> &symbol,AddressMode &addressMode)
|
|
{
|
|
::OutputDebugString(String("'")+symbol->symbolName()+String("' ")+(String)addressMode+String("\n"));
|
|
}
|
|
|
|
void Parse::displayEncoding(SmartPointer<Symbol> &symbol,AddressMode &addressMode,DWORD value,BOOL extended)
|
|
{
|
|
//#if 0
|
|
String strEncoding;
|
|
|
|
if(AddressMode::Inherent==addressMode.attribute())
|
|
{
|
|
::sprintf(strEncoding,"%s : \t%02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode());
|
|
}
|
|
else if(addressMode.prebyte())
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
else
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
strEncoding.upper();
|
|
mLogFile.writeLine(strEncoding);
|
|
// strEncoding+=String("\n");
|
|
// ::OutputDebugString(strEncoding);
|
|
//#endif
|
|
}
|
|
|
|
BOOL Parse::resolve(void)
|
|
{
|
|
BYTE charByte;
|
|
|
|
for(int index=0;index<mFixups.size();index++)
|
|
{
|
|
Fixup &fixup=mFixups[index];
|
|
Label label(fixup.label());
|
|
if(!mLabelGenerator.find(label))return FALSE;
|
|
if(Label::Reference==label.disposition())return FALSE;
|
|
outputView().seek(fixup.offset(),PureViewOfFile::SeekSet);
|
|
outputView().read(charByte);
|
|
outputView().seek(fixup.offset(),PureViewOfFile::SeekSet);
|
|
charByte=label.offset()-fixup.offset();
|
|
outputView().write(charByte);
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
|
|
// parseView.rewind();
|
|
// FileHandle outFile(strPathOutFile,FileHandle::Write,FileHandle::ShareRead,FileHandle::Overwrite);
|
|
// if(!outFile.isOkay())return FALSE;
|
|
// outFile.write((BYTE*)parseView.base(),codeLength);
|
|
|
|
|
|
|
|
class Parse : public Emit
|
|
{
|
|
public:
|
|
enum Status{Error,Ok};
|
|
enum ParseSymbols{codestart2,codeend2,purecode2}; // jmp2,call2,defaddr2,
|
|
Parse(PureViewOfFile &srcView,PureViewOfFile &dstView);
|
|
|
|
|
|
|
|
void Parse::statement(void)
|
|
{
|
|
if(Scan::label1==currentSymbolType())labelStatement();
|
|
else if(Scan::directive1==currentSymbolType())directiveStatement();
|
|
else if(Scan::name1==currentSymbolType())
|
|
{
|
|
switch(mCurrentSymbol->symbolType())
|
|
{
|
|
case Symbol::KeywordSymbol :
|
|
keywordStatement();
|
|
break;
|
|
case Symbol::DirectiveSymbol :
|
|
directiveStatement();
|
|
break;
|
|
case Symbol::UserSymbol :
|
|
userStatement();
|
|
break;
|
|
}
|
|
}
|
|
else syntaxCheck();
|
|
// else errorExpect(Scan::name1);
|
|
// else if(Scan::startliteral1==mSymbol)userStatement();
|
|
// else syntaxCheck();
|
|
}
|
|
|
|
|
|
void Parse::displayEncoding(SmartPointer<Symbol> &symbol,AddressMode &addressMode,DWORD value,BOOL extended)
|
|
{
|
|
//#if 0
|
|
String strEncoding;
|
|
|
|
if(AddressMode::Inherent==addressMode.attribute())
|
|
{
|
|
::sprintf(strEncoding,"%s : \t%02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode());
|
|
}
|
|
else if(addressMode.prebyte())
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
else
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
strEncoding.upper();
|
|
mLogFile.writeLine(strEncoding);
|
|
//#endif
|
|
}
|
|
|
|
|
|
|
|
void Parse::display(SmartPointer<Symbol> &symbol,AddressMode &addressMode)
|
|
{
|
|
::OutputDebugString(String("'")+symbol->symbolName()+String("' ")+(String)addressMode+String("\n"));
|
|
}
|
|
|
|
void display(SmartPointer<Symbol> &symbol,AddressMode &addressMode);
|
|
void displayEncoding(SmartPointer<Symbol> &symbol,AddressMode &addressMode,DWORD value,BOOL extended);
|
|
|
|
|
|
directive1,
|
|
|
|
|
|
// if(currentSymbol->hasInherentMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// displayEncoding(currentSymbol,addressMode,0,0);
|
|
// emit((*mCurrentSymbol)[0].opcode());
|
|
// insertSymbols(mStatementSymbols);
|
|
// nextSymbol();
|
|
// removeSymbols(mStatementSymbols);
|
|
// return;
|
|
// }
|
|
// peek((int&)peekSymbol);
|
|
// if(Scan::leftbracket1==peekSymbol)
|
|
// {
|
|
// insertSymbols(ParseSymbol(peekSymbol));
|
|
// nextSymbol();
|
|
// removeSymbols(ParseSymbol(peekSymbol));
|
|
// insertSymbols(ParseSymbol(Scan::numeral1));
|
|
// expect(peekSymbol);
|
|
// removeSymbols(ParseSymbol(Scan::numeral1));
|
|
// value=mNumeralValue;
|
|
// insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// insertSymbols(mStatementSymbols);
|
|
// nextSymbol();
|
|
// removeSymbols(mStatementSymbols);
|
|
// if(!inRange(value))error(ValueOutOfRangeForInstruction);
|
|
// else if(value>0xFF) // use extended addressing
|
|
// {
|
|
// if(currentSymbol->hasExtendedMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(hiByte(value));
|
|
// emit(loByte(value));
|
|
// displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
// }
|
|
// else error(IllegalAddressingModeForMnemonic);
|
|
// }
|
|
// else // value <=0xFF
|
|
// {
|
|
// if(currentSymbol->hasDirectMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(loByte(value));
|
|
// displayEncoding(currentSymbol,addressMode,value,FALSE);
|
|
// }
|
|
// else
|
|
// {
|
|
// if(currentSymbol->hasExtendedMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(hiByte(value));
|
|
// emit(loByte(value));
|
|
// displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
// }
|
|
// else error(IllegalAddressingModeForMnemonic);
|
|
// }
|
|
// }
|
|
// }
|
|
// else if(Scan::numeral1==peekSymbol) // immediate
|
|
// {
|
|
// if(currentSymbol->hasImmediateMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// insertSymbols(ParseSymbol(Scan::numeral1));
|
|
// expect(mCurrentSymbolType);
|
|
// removeSymbols(ParseSymbol(Scan::numeral1));
|
|
// insertSymbols(mStatementSymbols);
|
|
// value=mNumeralValue;
|
|
// if(!inRange(value))error(ValueOutOfRangeForInstruction);
|
|
// else if(Instruction::SingleByte==currentSymbol->registerLength())
|
|
// {
|
|
// if(value<=0xFF)
|
|
// {
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(loByte(value));
|
|
// }
|
|
// else error(OperandSizeMustMatch);
|
|
// }
|
|
// else
|
|
// {
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(hiByte(value));
|
|
// emit(loByte(value));
|
|
// }
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(mStatementSymbols);
|
|
// displayEncoding(currentSymbol,addressMode,value,Instruction::DoubleByte==currentSymbol->registerLength()?TRUE:FALSE);
|
|
// }
|
|
// else if(mCurrentSymbol->hasRelativeMode(indexForm))
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(hiByte(value));
|
|
// emit(loByte(value));
|
|
// displayEncoding(currentSymbol,addressMode,value,TRUE);
|
|
// }
|
|
// else error(IllegalAddressingModeForMnemonic);
|
|
// }
|
|
// else // could be relative or indexed
|
|
// {
|
|
// if(currentSymbol->hasIndexedMode(indexForm)) // indexed
|
|
// {
|
|
// SmartPointer<Symbol> nextSymbol;
|
|
// DWORD expressionResult(0);
|
|
//
|
|
// insertSymbols(ParseSymbol(Scan::name1));
|
|
// expect(Scan::name1);
|
|
// nextSymbol=mCurrentSymbol;
|
|
// if(!nextSymbol.isOkay())
|
|
// {
|
|
// error(ExpectedIndexRegister);
|
|
// removeSymbols(ParseSymbol(Scan::name1));
|
|
// return;
|
|
// }
|
|
// insertSymbols(ParseSymbol(Scan::comma1));
|
|
// expect(Scan::name1);
|
|
// removeSymbols(ParseSymbol(Scan::comma1));
|
|
// insertSymbols(mSimpleExpressionSymbols);
|
|
// removeSymbols(ParseSymbol(Scan::name1));
|
|
// this->nextSymbol();
|
|
// removeSymbols(mSimpleExpressionSymbols);
|
|
// insertSymbols(mStatementSymbols);
|
|
// simpleExpression(expressionResult);
|
|
// removeSymbols(mStatementSymbols);
|
|
// if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
// else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
// {
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// emit(addressMode.opcode());
|
|
// emit(loByte(expressionResult));
|
|
// displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
// }
|
|
// else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
// {
|
|
// currentSymbol->hasPreByte(indexForm);
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// emit(loByte(expressionResult));
|
|
// displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
// }
|
|
// else error(ExpectedIndexRegister);
|
|
// return;
|
|
// }
|
|
// else if(currentSymbol->hasRelativeMode(indexForm)) // relative
|
|
// {
|
|
// BOOL needsFixup(FALSE);
|
|
// Label branchLabel;
|
|
//
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// expect(currentSymbolType());
|
|
// removeSymbols(ParseSymbol(Scan::label1));
|
|
// insertSymbols(ParseSymbol(Scan::literal1));
|
|
// expect(currentSymbolType());
|
|
// removeSymbols(ParseSymbol(Scan::literal1));
|
|
//
|
|
// branchLabel.strLabel(mLiteralValue);
|
|
// if(!mLabelGenerator.find(branchLabel))
|
|
// {
|
|
// branchLabel.offset(0);
|
|
// branchLabel.disposition(Label::Reference);
|
|
// mLabelGenerator.insert(branchLabel);
|
|
// needsFixup=TRUE;
|
|
// }
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::label1);
|
|
// expect(Scan::literal1);
|
|
// removeSymbols(mStatementSymbols);
|
|
// if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
// emit(addressMode.opcode());
|
|
// if(needsFixup)
|
|
// {
|
|
// mFixups.insert(&Fixup(outputView().tell(),branchLabel));
|
|
// emit(BYTE(0xCC));
|
|
// }
|
|
// else
|
|
// {
|
|
// BYTE jumpDistance(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
// if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(JumpOutOfRange);
|
|
// else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
// emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
// }
|
|
// displayEncoding(currentSymbol,addressMode,-((outputView().tell()-branchLabel.offset())),FALSE);
|
|
// }
|
|
// else error(IllegalAddressingModeForMnemonic);
|
|
//// }
|
|
|
|
|
|
|
|
void Parse::parseIndexedRelative(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
if(currentSymbol->hasIndexedMode(indexForm)) // indexed
|
|
{
|
|
SmartPointer<Symbol> nextSymbol;
|
|
DWORD expressionResult(0);
|
|
|
|
insertSymbols(ParseSymbol(Scan::name1));
|
|
expect(Scan::name1);
|
|
nextSymbol=mCurrentSymbol;
|
|
if(!nextSymbol.isOkay())
|
|
{
|
|
error(ExpectedIndexRegister);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
return;
|
|
}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::name1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
this->nextSymbol();
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(mStatementSymbols);
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
// displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
}
|
|
else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasPreByte(indexForm);
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
// displayEncoding(currentSymbol,addressMode,expressionResult,FALSE);
|
|
}
|
|
else error(ExpectedIndexRegister);
|
|
return;
|
|
}
|
|
else if(currentSymbol->hasRelativeMode(indexForm)) // relative
|
|
{
|
|
BOOL needsFixup(FALSE);
|
|
Label branchLabel;
|
|
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// expect(currentSymbolType());
|
|
// removeSymbols(ParseSymbol(Scan::label1));
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
branchLabel.strLabel(mLiteralValue);
|
|
if(!mLabelGenerator.find(branchLabel))
|
|
{
|
|
branchLabel.offset(0);
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
needsFixup=TRUE;
|
|
}
|
|
insertSymbols(mStatementSymbols);
|
|
// expect(Scan::label1);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
if(needsFixup)
|
|
{
|
|
mFixups.insert(&Fixup(outputView().tell(),branchLabel));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(JumpOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
}
|
|
// displayEncoding(currentSymbol,addressMode,-((outputView().tell()-branchLabel.offset())),FALSE);
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
|
|
|
|
// if(isInError())return;
|
|
// if(mEquates.searchItem(equate,ptrEquate)&&ptrEquate->value()!=expressionResult)error(SymbolAlreadyDefined,ptrEquate->strLabel());
|
|
// else
|
|
// {
|
|
// equate.value(expressionResult);
|
|
// mEquates.insert(equate);
|
|
// }
|
|
|
|
|
|
|
|
#if 0
|
|
void Parse::parseRelative(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
BOOL needsFixup(FALSE);
|
|
Label branchLabel;
|
|
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
branchLabel.strLabel(mLiteralValue);
|
|
if(!mLabelGenerator.find(branchLabel))
|
|
{
|
|
Equate equate(branchLabel.strLabel());
|
|
if(mEquates.find(equate))branchLabel.offset(equate.value());
|
|
else
|
|
{
|
|
branchLabel.offset(0);
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
// needsFixup=TRUE;
|
|
}
|
|
}
|
|
if(Label::Reference==branchLabel.disposition())needsFixup=TRUE;
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
if(needsFixup)
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
displayEncoding(currentSymbol,addressMode,0xCC,FALSE);
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
displayEncoding(currentSymbol,addressMode,BYTE(-(outputView().tell()-branchLabel.offset())-2),FALSE);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
// insertSymbols(mSimpleExpressionSymbols);
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(peekSymbol);
|
|
// insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// simpleExpression(expressionResult);
|
|
// removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// removeSymbols(mSimpleExpressionSymbols);
|
|
// removeSymbols(mStatementSymbols);
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::rightbracket1);
|
|
// removeSymbols(mStatementSymbols);
|
|
|
|
|
|
|
|
// directiveStatement();
|
|
//void Parse::directiveStatement(void)
|
|
//{
|
|
// SmartPointer<Symbol> currentSymbol=mCurrentSymbol;
|
|
//
|
|
// if(Scan::origin1==currentSymbol->identifier())
|
|
// {
|
|
// insertSymbols(ParseSymbol(Scan::numeral1));
|
|
// expect(mCurrentSymbolType);
|
|
// removeSymbols(ParseSymbol(Scan::numeral1));
|
|
// mOrigin=mNumeralValue;
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(mStatementSymbols);
|
|
// }
|
|
// else errorExpect(Symbol::DirectiveSymbol);
|
|
//}
|
|
|
|
|
|
|
|
if(AddressMode::DirectRelativeMask&((Instruction&)*this).operator[](index).attribute())
|
|
|
|
|
|
|
|
|
|
void Parse::displayEncoding(SmartPointer<Symbol> &symbol,AddressMode &addressMode,DWORD value,BOOL extended)
|
|
{
|
|
//#if 0
|
|
String strEncoding;
|
|
|
|
if(AddressMode::Inherent==addressMode.attribute())
|
|
{
|
|
::sprintf(strEncoding,"%s : \t%02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode());
|
|
}
|
|
else if(addressMode.prebyte())
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
else
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),loByte(value));
|
|
}
|
|
strEncoding.upper();
|
|
mLogFile.writeLine(strEncoding);
|
|
strEncoding+=String("\n");
|
|
::OutputDebugString(strEncoding);
|
|
//#endif
|
|
}
|
|
|
|
void Parse::displayEncoding(SmartPointer<Symbol> &symbol,AddressMode &addressMode,DWORD value,BYTE mask,DWORD expression,BOOL extended)
|
|
{
|
|
//#if 0
|
|
String strEncoding;
|
|
|
|
if(AddressMode::Inherent==addressMode.attribute())
|
|
{
|
|
::sprintf(strEncoding,"%s : \t%02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode());
|
|
}
|
|
else if(addressMode.prebyte())
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),expression,(int)mask,hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.prebyte(),(int)addressMode.opcode(),expression,(int)mask,loByte(value));
|
|
}
|
|
else
|
|
{
|
|
if(extended)::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),expression,(int)mask,hiByte(value),loByte(value));
|
|
else ::sprintf(strEncoding,"%s : \t%02lx %02lx %02lx %02lx",(LPSTR)symbol->symbolName(),(int)addressMode.opcode(),expression,(int)mask,loByte(value));
|
|
}
|
|
strEncoding.upper();
|
|
mLogFile.writeLine(strEncoding);
|
|
strEncoding+=String("\n");
|
|
::OutputDebugString(strEncoding);
|
|
//#endif
|
|
}
|
|
|
|
|
|
|
|
|
|
void Parse::parseDirectRelativeMask(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
}
|
|
|
|
void Parse::parseIndexedRelativeMask(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
SmartPointer<AddressMode> addressMode;
|
|
SmartPointer<Symbol> nextSymbol;
|
|
DWORD expressionResult(0);
|
|
BYTE maskValue;
|
|
BOOL needsFixup(FALSE);
|
|
Label branchLabel;
|
|
Equate branchEquate;
|
|
|
|
addressMode=&(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(Scan::name1));
|
|
expect(Scan::name1);
|
|
nextSymbol=mCurrentSymbol;
|
|
if(!nextSymbol.isOkay())
|
|
{
|
|
error(ExpectedIndexRegister);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
return;
|
|
}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::name1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
this->nextSymbol();
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
{
|
|
emit(addressMode->opcode());
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasPreByte(indexForm);
|
|
addressMode=&(*currentSymbol)[indexForm];
|
|
emit(addressMode->prebyte());
|
|
emit(addressMode->opcode());
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else error(ExpectedIndexRegister);
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::comma1);
|
|
maskValue=mNumeralValue;
|
|
emit(maskValue);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
maskValue=mNumeralValue;
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(Scan::comma1);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
if(isInError())return;
|
|
branchLabel.strLabel(mLiteralValue);
|
|
branchEquate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!mLabelGenerator.find(branchLabel)||Label::Ignore==branchLabel.disposition())
|
|
{
|
|
if(mEquates.find(branchEquate))
|
|
{
|
|
if(Equate::Reference==branchEquate.disposition())
|
|
{
|
|
if(!jumpInRange(-((outputView().tell()+origin())-branchEquate.value())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-((outputView().tell()+origin())-branchEquate.value())-1));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(branchEquate.value()))error(BranchOutOfRange);
|
|
else emit(BYTE(branchEquate.value()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
branchLabel.offset(outputView().tell());
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Label::Reference==branchLabel.disposition())
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#if 0
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(Scan::comma1);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
if(isInError())return;
|
|
branchLabel.strLabel(mLiteralValue);
|
|
branchEquate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!mLabelGenerator.find(branchLabel)||Label::Ignore==branchLabel.disposition())
|
|
{
|
|
if(mEquates.find(branchEquate))
|
|
{
|
|
if(Equate::Reference==branchEquate.disposition())
|
|
{
|
|
if(!jumpInRange(-((outputView().tell()+origin())-branchEquate.value())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-((outputView().tell()+origin())-branchEquate.value())-1));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(branchEquate.value()))error(BranchOutOfRange);
|
|
else emit(BYTE(branchEquate.value()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
branchLabel.offset(outputView().tell());
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Label::Reference==branchLabel.disposition())
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void Parse::parseRelative(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
BOOL needsFixup(FALSE);
|
|
Label branchLabel;
|
|
Equate branchEquate;
|
|
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
parseBranch();
|
|
|
|
#if 0
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
branchLabel.strLabel(mLiteralValue);
|
|
branchEquate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!mLabelGenerator.find(branchLabel)||Label::Ignore==branchLabel.disposition())
|
|
{
|
|
if(mEquates.find(branchEquate))
|
|
{
|
|
if(Equate::Reference==branchEquate.disposition())
|
|
{
|
|
if(!jumpInRange(-((outputView().tell()+origin())-branchEquate.value())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-((outputView().tell()+origin())-branchEquate.value())-1));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(branchEquate.value()))error(BranchOutOfRange);
|
|
else emit(BYTE(branchEquate.value()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
branchLabel.offset(outputView().tell());
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Label::Reference==branchLabel.disposition())
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
void Parse::parseIndexed(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
SmartPointer<AddressMode> addressMode;
|
|
SmartPointer<Symbol> nextSymbol;
|
|
DWORD expressionResult(0);
|
|
|
|
parseIndex(currentSymbol,addressMode,expressionResult);
|
|
if(addressMode->prebyte())emit(addressMode->prebyte());
|
|
emit(addressMode->opcode());
|
|
emit(loByte(expressionResult));
|
|
|
|
#if 0
|
|
insertSymbols(ParseSymbol(Scan::name1));
|
|
expect(Scan::name1);
|
|
nextSymbol=mCurrentSymbol;
|
|
if(!nextSymbol.isOkay())
|
|
{
|
|
error(ExpectedIndexRegister);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
return;
|
|
}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::name1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
this->nextSymbol();
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(mStatementSymbols);
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasPreByte(indexForm);
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else error(ExpectedIndexRegister);
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
|
|
void Parse::parseIndex(SmartPointer<Symbol> ¤tSymbol,SmartPointer<AddressMode> &addressMode,DWORD &expressionResult)
|
|
{
|
|
SmartPointer<Symbol> nextSymbol;
|
|
WORD indexForm;
|
|
|
|
insertSymbols(ParseSymbol(Scan::name1));
|
|
expect(Scan::name1);
|
|
nextSymbol=mCurrentSymbol;
|
|
if(!nextSymbol.isOkay())
|
|
{
|
|
error(ExpectedIndexRegister);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
return;
|
|
}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::name1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
removeSymbols(ParseSymbol(Scan::name1));
|
|
this->nextSymbol();
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(mStatementSymbols);
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!inRange(expressionResult,MaxBit8))error(ValueOutOfRangeForInstruction);
|
|
else if(int(Scan::ix1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasIndexedMode(indexForm);
|
|
addressMode=&(*currentSymbol)[indexForm];
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
// emit(addressMode->opcode());
|
|
// emit(loByte(expressionResult));
|
|
}
|
|
else if(int(Scan::iy1)==nextSymbol->identifier())
|
|
{
|
|
currentSymbol->hasPreByte(indexForm);
|
|
// AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
addressMode=&(*currentSymbol)[indexForm];
|
|
// emit(addressMode->prebyte());
|
|
// emit(addressMode->opcode());
|
|
// emit(loByte(expressionResult));
|
|
}
|
|
else error(ExpectedIndexRegister);
|
|
}
|
|
|
|
|
|
void Parse::parseBranch(void)
|
|
{
|
|
Label branchLabel;
|
|
Equate branchEquate;
|
|
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType()); // expect(Scan::comma1);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
if(isInError())return;
|
|
branchLabel.strLabel(mLiteralValue);
|
|
branchEquate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!mLabelGenerator.find(branchLabel)||Label::Ignore==branchLabel.disposition())
|
|
{
|
|
if(mEquates.find(branchEquate))
|
|
{
|
|
if(Equate::Reference==branchEquate.disposition())
|
|
{
|
|
if(!jumpInRange(-((outputView().tell()+origin())-branchEquate.value())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-((outputView().tell()+origin())-branchEquate.value())-1));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(branchEquate.value()))error(BranchOutOfRange);
|
|
else emit(BYTE(branchEquate.value()));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
branchLabel.offset(outputView().tell());
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Label::Reference==branchLabel.disposition())
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange(-(outputView().tell()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(outputView().tell()-branchLabel.offset())-1));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void Parse::originStatement(void)
|
|
{
|
|
insertSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
removeSymbols(mSimpleExpressionSymbols);
|
|
insertSymbols(mStatementSymbols);
|
|
simpleExpression(mOrigin);
|
|
removeSymbols(mStatementSymbols);
|
|
|
|
// insertSymbols(Scan::numeral1);
|
|
// expect(currentSymbolType());
|
|
// removeSymbols(Scan::numeral1);
|
|
// mOrigin=mNumeralValue;
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(mStatementSymbols);
|
|
|
|
}
|
|
|
|
|
|
#if 0
|
|
void Parse::rmbStatement(void)
|
|
{
|
|
SmartPointer<Equate> ptrEquate;
|
|
SmartPointer<Label> ptrLabel;
|
|
Equate equate;
|
|
Label label;
|
|
DWORD rmbCount;
|
|
|
|
equate.strLabel(mLiteralValue);
|
|
label.strLabel(mLiteralValue);
|
|
insertSymbols(ParseSymbol(Scan::rmb1));
|
|
expect(Scan::literal1);
|
|
removeSymbols(ParseSymbol(Scan::rmb1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::rmb1);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
rmbCount=mNumeralValue;
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(isInError())return;
|
|
equate.disposition(Equate::Absolute);
|
|
if(mLabelGenerator.searchItem(label,ptrLabel))
|
|
{
|
|
if(Label::Absolute==ptrLabel->disposition()){error(SymbolAlreadyDifferentKind,equate.strLabel());return;}
|
|
else ptrLabel->disposition(Label::Ignore);
|
|
}
|
|
if(!(mEquates.searchItem(equate,ptrEquate)&&ptrEquate->value()!=(outputView().tell()+origin())))
|
|
{
|
|
equate.value(outputView().tell()+origin());
|
|
mEquates.insert(equate);
|
|
}
|
|
else error(SymbolAlreadyDefined,ptrEquate->strLabel());
|
|
for(int index=0;index<rmbCount;index++)emit(BYTE(0xCC));
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void Parse::parseMask(SmartPointer<Symbol> ¤tSymbol,Scan::ScanSymbols peekSymbol)
|
|
{
|
|
SmartPointer<AddressMode> addressMode;
|
|
WORD indexForm;
|
|
DWORD expressionResult;
|
|
BYTE maskValue;
|
|
|
|
if(Scan::leftbracket1==peekSymbol)
|
|
{
|
|
if(!currentSymbol->hasDirectMode(indexForm)){error(IllegalAddressingModeForMnemonic);return;}
|
|
addressMode=&(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(peekSymbol));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(peekSymbol));
|
|
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::leftbracket1);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
|
|
|
|
// insertSymbols(ParseSymbol(Scan::numeral1));
|
|
// expect(Scan::leftbracket1);
|
|
// removeSymbols(ParseSymbol(Scan::numeral1));
|
|
// expressionResult=mNumeralValue;
|
|
// insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
expect(Scan::rightbracket1);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::comma1);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
maskValue=mNumeralValue;
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
emit(addressMode->opcode());
|
|
emit(loByte(expressionResult));
|
|
emit(maskValue);
|
|
}
|
|
else
|
|
{
|
|
if(!currentSymbol->hasIndexedMode(indexForm)){error(IllegalAddressingModeForMnemonic);return;}
|
|
insertSymbols(ParseSymbol(Scan::comma1));
|
|
parseIndex(currentSymbol,addressMode,expressionResult);
|
|
removeSymbols(ParseSymbol(Scan::comma1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::comma1);
|
|
maskValue=mNumeralValue;
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(isInError())return;
|
|
if(addressMode->prebyte())emit(addressMode->prebyte());
|
|
emit(addressMode->opcode());
|
|
emit(loByte(expressionResult));
|
|
emit(maskValue);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void Parse::parseDirectExtended(SmartPointer<Symbol> ¤tSymbol,WORD indexForm,Scan::ScanSymbols peekSymbol)
|
|
{
|
|
DWORD expressionResult;
|
|
|
|
insertSymbols(ParseSymbol(peekSymbol));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(peekSymbol));
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::leftbracket1);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
simpleExpression(expressionResult);
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::rightbracket1);
|
|
removeSymbols(mStatementSymbols);
|
|
|
|
|
|
|
|
// insertSymbols(ParseSymbol(peekSymbol));
|
|
// nextSymbol();
|
|
// removeSymbols(ParseSymbol(peekSymbol));
|
|
// insertSymbols(ParseSymbol(Scan::numeral1));
|
|
// expect(peekSymbol);
|
|
// removeSymbols(ParseSymbol(Scan::numeral1));
|
|
// expressionResult=mNumeralValue;
|
|
// insertSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// expect(Scan::numeral1);
|
|
// removeSymbols(ParseSymbol(Scan::rightbracket1));
|
|
// insertSymbols(mStatementSymbols);
|
|
// nextSymbol();
|
|
// removeSymbols(mStatementSymbols);
|
|
|
|
|
|
if(!inRange(expressionResult)){error(ValueOutOfRangeForInstruction);return;}
|
|
if(expressionResult>0xFF)
|
|
{
|
|
if(currentSymbol->hasExtendedMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(expressionResult));
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
else
|
|
{
|
|
if(currentSymbol->hasDirectMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else
|
|
{
|
|
if(currentSymbol->hasExtendedMode(indexForm))
|
|
{
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
emit(hiByte(expressionResult));
|
|
emit(loByte(expressionResult));
|
|
}
|
|
else error(IllegalAddressingModeForMnemonic);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// int strLength;
|
|
// insertSymbols(ParseSymbol(Scan::literal1));
|
|
// expect(Scan::apostrophe1);
|
|
// strLength=mLiteralValue.length();
|
|
// for(int index=0;index<strLength;index++)emit(BYTE(*((char*)mLiteralValue+index)));
|
|
// removeSymbols(ParseSymbol(Scan::literal1));
|
|
// insertSymbols(ParseSymbol(Scan::apostrophe1));
|
|
// expect(Scan::literal1);
|
|
// removeSymbols(ParseSymbol(Scan::apostrophe1));
|
|
// insertSymbols(mStatementSymbols);
|
|
// expect(Scan::apostrophe1);
|
|
// removeSymbols(mStatementSymbols);
|
|
|
|
|
|
|
|
#if 0
|
|
void Parse::rmbStatement(void)
|
|
{
|
|
SmartPointer<Equate> ptrEquate;
|
|
SmartPointer<Label> ptrLabel;
|
|
Equate equate;
|
|
Label label;
|
|
DWORD startAddress;
|
|
DWORD rmbCount(0);
|
|
|
|
equate.strLabel(mLiteralValue);
|
|
label.strLabel(mLiteralValue);
|
|
insertSymbols(ParseSymbol(Scan::rmb1));
|
|
expect(Scan::literal1);
|
|
removeSymbols(ParseSymbol(Scan::rmb1));
|
|
insertSymbols(ParseSymbol(Scan::apostrophe1));
|
|
insertSymbols(ParseSymbol(Scan::numeral1));
|
|
expect(Scan::rmb1);
|
|
removeSymbols(ParseSymbol(Scan::numeral1));
|
|
removeSymbols(ParseSymbol(Scan::apostrophe1));
|
|
if(isInError())return;
|
|
startAddress=codePointer().position();
|
|
if(symbolIn(ParseSymbol(Scan::apostrophe1)))
|
|
{
|
|
int strLength;
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(Scan::apostrophe1);
|
|
strLength=mLiteralValue.length();
|
|
for(int index=0;index<strLength;index++)emit(BYTE(*((char*)mLiteralValue+index)));
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
insertSymbols(ParseSymbol(Scan::apostrophe1));
|
|
expect(Scan::literal1);
|
|
removeSymbols(ParseSymbol(Scan::apostrophe1));
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::apostrophe1);
|
|
removeSymbols(mStatementSymbols);
|
|
}
|
|
else
|
|
{
|
|
rmbCount=mNumeralValue;
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::numeral1);
|
|
removeSymbols(mStatementSymbols);
|
|
}
|
|
if(isInError())return;
|
|
equate.disposition(Equate::Absolute);
|
|
if(mLabelGenerator.searchItem(label,ptrLabel))
|
|
{
|
|
if(Label::Absolute==ptrLabel->disposition()){error(SymbolAlreadyDifferentKind,equate.strLabel());return;}
|
|
else ptrLabel->disposition(Label::Ignore);
|
|
}
|
|
if(!(mEquates.searchItem(equate,ptrEquate)&&ptrEquate->value()!=startAddress))
|
|
{
|
|
equate.value(startAddress);
|
|
mEquates.insert(equate);
|
|
}
|
|
else error(SymbolAlreadyDefined,ptrEquate->strLabel());
|
|
for(int index=0;index<rmbCount;index++)emit(BYTE(0x00));
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
#if 0
|
|
void Parse::parseLabelImmediate(SmartPointer<Symbol> ¤tSymbol,WORD indexForm)
|
|
{
|
|
Equate equate;
|
|
|
|
AddressMode &addressMode=(*currentSymbol)[indexForm];
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
equate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(addressMode.prebyte())emit(addressMode.prebyte());
|
|
emit(addressMode.opcode());
|
|
if(!mEquates.find(equate)){error(SymbolNotDefined);return;}
|
|
if(!inRange(equate.value(),MaxBit16)){error(ValueOutOfRangeForInstruction);return;}
|
|
if(Instruction::SingleByte==currentSymbol->registerLength())
|
|
{
|
|
if(!inRange(equate.value(),MaxBit8)){error(ValueOutOfRangeForInstruction);return;}
|
|
emit(BYTE(equate.value()));
|
|
}
|
|
else
|
|
{
|
|
if(!inRange(equate.value(),MaxBit16)){error(ValueOutOfRangeForInstruction);return;}
|
|
emit(WORD(equate.value()));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
void Scan::scanCharacter(void)
|
|
{
|
|
int character;
|
|
|
|
readch();
|
|
character=mChar;
|
|
readch();
|
|
// if('\''==mChar)
|
|
// {
|
|
// emit(numeral1,int(character));
|
|
// readch();
|
|
// }
|
|
// else
|
|
// {
|
|
*((char*)mWordString)=0;
|
|
mWordString+=character;
|
|
while(0xFFFF!=mChar&&'\''!=mChar&&0x0D!=mChar)
|
|
{
|
|
mWordString+=mChar;
|
|
readch();
|
|
}
|
|
readch();
|
|
emit(apostrophe1);
|
|
emit(literal1);
|
|
emit(mWordString);
|
|
emit(apostrophe1);
|
|
// }
|
|
}
|
|
|
|
|
|
|
|
// if(!jumpInRange(branchEquate.value()))error(BranchOutOfRange);
|
|
// else emit(BYTE(branchEquate.value()));
|
|
// modified the target by 2 bytes because branching via EQU value is two bytes past target
|
|
// smk 10/2002
|
|
// if(!jumpInRange((branchEquate.value()-codePointer().origin())-2))error(BranchOutOfRange);
|
|
// else emit(BYTE((branchEquate.value()-codePointer().origin())-2));
|
|
emit(BYTE((branchEquate.value()-codePointer().origin())-2));
|
|
|
|
|
|
if(!jumpInRange((branchEquate.value()-codePointer().origin())-2))error(BranchOutOfRange);
|
|
// else emit(BYTE((branchEquate.value()-codePointer().origin())-2));
|
|
else emit(BYTE((branchEquate.value()-codePointer().origin())-2));
|
|
|
|
|
|
|
|
|
|
bool S19Generator::generateCode(PureViewOfFile &rawCode,const String &strPathOutput)
|
|
{
|
|
File outFile;
|
|
DWORD genBytes=0;
|
|
String endLine;
|
|
|
|
endLine="S9030000FC";
|
|
rawCode.rewind();
|
|
if(!outFile.open(strPathOutput,"wb"))return false;
|
|
generateLines(rawCode.tell(),rawCode.size(),rawCode,outFile);
|
|
/*
|
|
for(int index=0;index<origins.size()&&genBytes<codeLength;index++)
|
|
{
|
|
Origin &origin=origins[index];
|
|
|
|
if(index<origins.size()-1)
|
|
{
|
|
Origin &nextOrigin=origins[index+1];
|
|
|
|
if(origin.getPosition()==nextOrigin.getPosition())continue; // kludge
|
|
|
|
generateLines(origin.getOrigin(),nextOrigin.getPosition(),rawCode,outFile);
|
|
genBytes+=nextOrigin.getPosition();
|
|
}
|
|
else
|
|
{
|
|
generateLines(origin.getOrigin(),codeLength-genBytes,rawCode,outFile);
|
|
}
|
|
}
|
|
*/
|
|
outFile.writeLine(endLine);
|
|
::OutputDebugString(endLine+String("\r\n"));
|
|
return false;
|
|
}
|
|
|
|
/*
|
|
bool S19Generator::generateCode(Origins &origins,PureViewOfFile &rawCode,DWORD codeLength,const String &strPathOutput)
|
|
{
|
|
File outFile;
|
|
DWORD genBytes=0;
|
|
String endLine;
|
|
|
|
endLine="S9030000FC";
|
|
rawCode.rewind();
|
|
if(!outFile.open(strPathOutput,"wb"))return false;
|
|
for(int index=0;index<origins.size()&&genBytes<codeLength;index++)
|
|
{
|
|
Origin &origin=origins[index];
|
|
|
|
if(index<origins.size()-1)
|
|
{
|
|
Origin &nextOrigin=origins[index+1];
|
|
|
|
if(origin.getPosition()==nextOrigin.getPosition())continue; // kludge
|
|
|
|
generateLines(origin.getOrigin(),nextOrigin.getPosition(),rawCode,outFile);
|
|
genBytes+=nextOrigin.getPosition();
|
|
}
|
|
else
|
|
{
|
|
generateLines(origin.getOrigin(),codeLength-genBytes,rawCode,outFile);
|
|
}
|
|
}
|
|
outFile.writeLine(endLine);
|
|
::OutputDebugString(endLine+String("\r\n"));
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
void Parse::parseBranch(void)
|
|
{
|
|
Label branchLabel;
|
|
Equate branchEquate;
|
|
|
|
insertSymbols(ParseSymbol(Scan::literal1));
|
|
expect(currentSymbolType());
|
|
removeSymbols(ParseSymbol(Scan::literal1));
|
|
if(isInError())return;
|
|
branchLabel.strLabel(mLiteralValue);
|
|
branchEquate.strLabel(mLiteralValue);
|
|
insertSymbols(mStatementSymbols);
|
|
expect(Scan::literal1);
|
|
removeSymbols(mStatementSymbols);
|
|
if(!mLabelGenerator.find(branchLabel)||Label::Ignore==branchLabel.disposition())
|
|
{
|
|
if(mEquates.find(branchEquate))
|
|
{
|
|
if(Equate::Reference==branchEquate.disposition())
|
|
{
|
|
if(!jumpInRange(-(codePointer().position()-branchEquate.value())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(codePointer().position()-branchEquate.value())-1));
|
|
}
|
|
else
|
|
{
|
|
if(!jumpInRange((branchEquate.value()-codePointer().origin())))error(BranchOutOfRange);
|
|
// else emit(BYTE((branchEquate.value()-codePointer().origin())-2));
|
|
// else emit(BYTE((branchEquate.value()-codePointer().origin())-2-1));
|
|
else emit(BYTE((branchEquate.value()-codePointer().position()-1)));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
branchLabel.offset(codePointer().position());
|
|
branchLabel.disposition(Label::Reference);
|
|
mLabelGenerator.insert(branchLabel);
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),codePointer().position(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(Label::Reference==branchLabel.disposition())
|
|
{
|
|
mFixups.insert(&Fixup(branchLabel.strLabel(),outputView().tell(),codePointer().position(),Fixup::Label));
|
|
emit(BYTE(0xCC));
|
|
}
|
|
else
|
|
{
|
|
// if(!jumpInRange(-(codePointer().position()-branchLabel.offset())))error(BranchOutOfRange);
|
|
// else emit(BYTE(-(codePointer().position()-branchLabel.offset())-2));
|
|
if(!jumpInRange(-(codePointer().position()-branchLabel.offset())-1))error(BranchOutOfRange);
|
|
else emit(BYTE(-(codePointer().position()-branchLabel.offset())-1));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
bool M68Assembler::assemble(const String &strPathFileName,const String &strPathOutFile)
|
|
{
|
|
FileHandle inFile;
|
|
bool returnCode;
|
|
|
|
mCodeSize=0;
|
|
if(!inFile.open(strPathFileName,FileHandle::Read,FileHandle::ShareRead))return FALSE;
|
|
FileMap inMap(inFile);
|
|
FileMap outMap("SCANOUT",0,MaxScanBytes);
|
|
FileMap parseMap("PARSEOUT",0,MaxParseBytes);
|
|
PureViewOfFile inView(inMap);
|
|
PureViewOfFile outView(outMap);
|
|
PureViewOfFile parseView(parseMap);
|
|
Scan scanner(inView,outView,mSymbolTable);
|
|
scanner.analyze();
|
|
outView.rewind();
|
|
|
|
for(int index=0;index<parseView.size();index++)parseView.write((BYTE)0x01);
|
|
parseView.rewind();
|
|
|
|
Parse parser(outView,parseView);
|
|
parser.parse();
|
|
mLastLineNumber=parser.lastLineNumber();
|
|
if(Parse::Error==parser.status())
|
|
{
|
|
String strMessage;
|
|
returnCode=FALSE;
|
|
::sprintf(strMessage,"%s at line number %d\n",(char*)parser.lastMessage(),parser.lastLineNumber());
|
|
mLastMessage=strMessage;
|
|
}
|
|
else
|
|
{
|
|
returnCode=TRUE;
|
|
mLastMessage=parser.lastMessage();
|
|
mCodeSize=parser.codeBytes();
|
|
generateCode(strPathOutFile,parseView,parser.codeBytes());
|
|
// generateListing(strPathOutFile,parseView,parser.codeBytes());
|
|
// generateS19(strPathOutFile,parser.origins(),parseView,parser.codeBytes());
|
|
generateS19(strPathOutFile,parseView);
|
|
}
|
|
return returnCode;
|
|
}
|
|
|
|
bool M68Assembler::generateCode(const String &strPathOutFile,PureViewOfFile &parseView,DWORD codeLength)
|
|
{
|
|
FileHandle outFile;
|
|
|
|
parseView.rewind();
|
|
if(!outFile.open(strPathOutFile,FileHandle::Write,FileHandle::ShareRead,FileHandle::Overwrite))return FALSE;
|
|
outFile.write((BYTE*)parseView.base(),codeLength);
|
|
return TRUE;
|
|
}
|
|
|
|
bool M68Assembler::generateListing(const String &strPathOutFile,PureViewOfFile &parseView,DWORD codeLength)
|
|
{
|
|
FileHandle outFile;
|
|
String strPathHexFile;
|
|
FormatLines formatLines;
|
|
Block<String> codeLines;
|
|
GlobalData<BYTE> codeBytes;
|
|
DiskInfo diskInfo;
|
|
|
|
strPathHexFile=strPathOutFile.betweenString(0,'.');
|
|
if(strPathHexFile==strPathOutFile)return false;
|
|
strPathHexFile+=".lst";
|
|
diskInfo.unlink(strPathHexFile);
|
|
if(!codeLength)return FALSE;
|
|
codeBytes.size(codeLength);
|
|
::memcpy((BYTE*)&codeBytes[0],(BYTE*)parseView.base(),codeLength);
|
|
formatLines.hexLines(codeLines,codeBytes);
|
|
if(!outFile.open(strPathHexFile,FileHandle::Write,FileHandle::ShareRead,FileHandle::Overwrite))return FALSE;
|
|
for(int index=0;index<codeLines.size();index++)outFile.writeLine(codeLines[index]);
|
|
outFile.close();
|
|
return TRUE;
|
|
}
|
|
|
|
/*
|
|
bool M68Assembler::generateS19(const String &strPathOutFile,Origins &origins,PureViewOfFile &rawCode,DWORD codeLength)
|
|
{
|
|
String strPathS19File;
|
|
DiskInfo diskInfo;
|
|
|
|
strPathS19File=strPathOutFile.betweenString(0,'.');
|
|
if(strPathS19File==strPathOutFile)return false;
|
|
strPathS19File+=".s19";
|
|
diskInfo.unlink(strPathS19File);
|
|
S19Generator::generateCode(origins,rawCode,codeLength,strPathS19File);
|
|
return false;
|
|
}
|
|
*/
|
|
|
|
bool M68Assembler::generateS19(const String &strPathOutFile,PureViewOfFile &rawCode)
|
|
{
|
|
String strPathS19File;
|
|
DiskInfo diskInfo;
|
|
|
|
strPathS19File=strPathOutFile.betweenString(0,'.');
|
|
if(strPathS19File==strPathOutFile)return false;
|
|
strPathS19File+=".s19";
|
|
diskInfo.unlink(strPathS19File);
|
|
// S19Generator::generateCode(origins,rawCode,codeLength,strPathS19File);
|
|
S19Generator::generateCode(rawCode,strPathS19File);
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|