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> &currentSymbol,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> &currentSymbol,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> &currentSymbol,WORD indexForm)
{
}

void Parse::parseIndexedRelativeMask(SmartPointer<Symbol> &currentSymbol,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> &currentSymbol,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> &currentSymbol,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> &currentSymbol,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> &currentSymbol,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> &currentSymbol,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> &currentSymbol,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;
}