//	Copyright (C) 1999-2003 Core Technologies.
//
//	This file is part of tpasm.
//
//	tpasm is free software; you can redistribute it and/or modify
//	it under the terms of the tpasm LICENSE AGREEMENT.
//
//	tpasm is distributed in the hope that it will be useful,
//	but WITHOUT ANY WARRANTY; without even the implied warranty of
//	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//	tpasm LICENSE AGREEMENT for more details.
//
//	You should have received a copy of the tpasm LICENSE AGREEMENT
//	along with tpasm; see the file "LICENSE.TXT".


// Generate code for Rockwell 6502 (with or without 65C02 enhancements)

#include	"include.h"

static SYMTABLE
	*pseudoOpcodeSymbols,
	*opcodeSymbols,
	*opcode65C02Symbols;

static PROCESSOR
	*currentProcessor;

// enumerated addressing modes

#define	OT_IMPLIED				0								// no operands
#define	OT_IMMEDIATE			1								// #xx
#define	OT_ZEROPAGE				2								// xx
#define	OT_ZEROPAGE_OFF_X		3								// xx,X
#define	OT_ZEROPAGE_OFF_Y		4								// xx,Y
#define	OT_EXTENDED				5								// xxxx
#define	OT_EXTENDED_OFF_X		6								// xxxx,X
#define	OT_EXTENDED_OFF_Y		7								// xxxx,Y
#define	OT_INDIRECT_OFF_X		8								// (xx,X)
#define	OT_INDIRECT_OFF_Y		9								// (xx),Y
#define	OT_INDIRECT_WORD		10								// (xxxx)
#define	OT_RELATIVE				11								// one byte relative offset
#define	OT_IMPLIED_2			12								// two-byte implied opcode (second byte is ignored)

#define	OT_NUM					OT_IMPLIED_2+1					// number of addressing modes

// masks for the various addressing modes

#define	M_IMPLIED				(1<<OT_IMPLIED)
#define	M_IMMEDIATE				(1<<OT_IMMEDIATE)
#define	M_ZEROPAGE				(1<<OT_ZEROPAGE)
#define	M_ZEROPAGE_OFF_X		(1<<OT_ZEROPAGE_OFF_X)
#define	M_ZEROPAGE_OFF_Y		(1<<OT_ZEROPAGE_OFF_Y)
#define	M_EXTENDED				(1<<OT_EXTENDED)
#define	M_EXTENDED_OFF_X		(1<<OT_EXTENDED_OFF_X)
#define	M_EXTENDED_OFF_Y		(1<<OT_EXTENDED_OFF_Y)
#define	M_INDIRECT_OFF_X		(1<<OT_INDIRECT_OFF_X)
#define	M_INDIRECT_OFF_Y		(1<<OT_INDIRECT_OFF_Y)
#define	M_INDIRECT_WORD			(1<<OT_INDIRECT_WORD)
#define	M_RELATIVE				(1<<OT_RELATIVE)
#define	M_IMPLIED_2				(1<<OT_IMPLIED_2)

typedef struct opcode
{
	char
		*name;
	int
		typeMask;
	unsigned char
		baseOpcode[OT_NUM];
} OPCODE;

static PSEUDO_OPCODE
	pseudoOpcodes[]=
	{
		{"db",		HandleDB},
		{"dc.b",	HandleDB},
		{"dw",		HandleLEDW},		// words are little endian
		{"dc.w",	HandleLEDW},
		{"ds",		HandleDS},
		{"ds.b",	HandleDS},
		{"ds.w",	HandleDSW},
		{"incbin",	HandleIncbin},
	};

#define	____		0					// unused opcode

static OPCODE
	Opcodes[]=
	{
//																																			imp   imm  zp   zpx  zpy  ext  extx exty indx indy indw rel
		{"adc",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0x69,0x65,0x75,____,0x6D,0x7D,0x79,0x61,0x71,____,____}},
		{"and",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0x29,0x25,0x35,____,0x2D,0x3D,0x39,0x21,0x31,____,____}},
		{"asl",		M_IMPLIED|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,														{0x0A,____,0x06,0x16,____,0x0E,0x1E,____,____,____,____,____}},
		{"bcc",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x90}},
		{"bcs",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0xB0}},
		{"beq",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0xF0}},
		{"bit",		M_ZEROPAGE|M_EXTENDED,																									{____,____,0x24,____,____,0x2C,____,____,____,____,____,____}},
		{"bmi",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x30}},
		{"bne",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0xD0}},
		{"bpl",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x10}},
		{"brk",		M_IMPLIED_2,																											{0x00,____,____,____,____,____,____,____,____,____,____,____}},
		{"bvc",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x50}},
		{"bvs",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x70}},
		{"clc",		M_IMPLIED,																												{0x18,____,____,____,____,____,____,____,____,____,____,____}},
		{"cld",		M_IMPLIED,																												{0xD8,____,____,____,____,____,____,____,____,____,____,____}},
		{"cli",		M_IMPLIED,																												{0x58,____,____,____,____,____,____,____,____,____,____,____}},
		{"clv",		M_IMPLIED,																												{0xB8,____,____,____,____,____,____,____,____,____,____,____}},
		{"cmp",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0xC9,0xC5,0xD5,____,0xCD,0xDD,0xD9,0xC1,0xD1,____,____}},
		{"cpx",		M_IMMEDIATE|M_ZEROPAGE|M_EXTENDED,																						{____,0xE0,0xE4,____,____,0xEC,____,____,____,____,____,____}},
		{"cpy",		M_IMMEDIATE|M_ZEROPAGE|M_EXTENDED,																						{____,0xC0,0xC4,____,____,0xCC,____,____,____,____,____,____}},
		{"dec",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,																{____,____,0xC6,0xD6,____,0xCE,0xDE,____,____,____,____,____}},
		{"dex",		M_IMPLIED,																												{0xCA,____,____,____,____,____,____,____,____,____,____,____}},
		{"dey",		M_IMPLIED,																												{0x88,____,____,____,____,____,____,____,____,____,____,____}},
		{"eor",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0x49,0x45,0x55,____,0x4D,0x5D,0x59,0x41,0x51,____,____}},
		{"inc",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,																{____,____,0xE6,0xF6,____,0xEE,0xFE,____,____,____,____,____}},
		{"inx",		M_IMPLIED,																												{0xE8,____,____,____,____,____,____,____,____,____,____,____}},
		{"iny",		M_IMPLIED,																												{0xC8,____,____,____,____,____,____,____,____,____,____,____}},
		{"jmp",		M_EXTENDED|M_INDIRECT_WORD,																								{____,____,____,____,____,0x4C,____,____,____,____,0x6C,____}},
		{"jsr",		M_EXTENDED,																												{____,____,____,____,____,0x20,____,____,____,____,____,____}},
		{"lda",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0xA9,0xA5,0xB5,____,0xAD,0xBD,0xB9,0xA1,0xB1,____,____}},
		{"ldx",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_Y|M_EXTENDED|M_EXTENDED_OFF_Y,													{____,0xA2,0xA6,____,0xB6,0xAE,____,0xBE,____,____,____,____}},
		{"ldy",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,													{____,0xA0,0xA4,0xB4,____,0xAC,0xBC,____,____,____,____,____}},
		{"lsr",		M_IMPLIED|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,														{0x4A,____,0x46,0x56,____,0x4E,0x5E,____,____,____,____,____}},
		{"nop",		M_IMPLIED,																												{0xEA,____,____,____,____,____,____,____,____,____,____,____}},
		{"ora",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0x09,0x05,0x15,____,0x0D,0x1D,0x19,0x01,0x11,____,____}},
		{"pha",		M_IMPLIED,																												{0x48,____,____,____,____,____,____,____,____,____,____,____}},
		{"php",		M_IMPLIED,																												{0x08,____,____,____,____,____,____,____,____,____,____,____}},
		{"pla",		M_IMPLIED,																												{0x68,____,____,____,____,____,____,____,____,____,____,____}},
		{"plp",		M_IMPLIED,																												{0x28,____,____,____,____,____,____,____,____,____,____,____}},
		{"rol",		M_IMPLIED|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,														{0x2A,____,0x26,0x36,____,0x2E,0x3E,____,____,____,____,____}},
		{"ror",		M_IMPLIED|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,														{0x6A,____,0x66,0x76,____,0x6E,0x7E,____,____,____,____,____}},
		{"rti",		M_IMPLIED,																												{0x40,____,____,____,____,____,____,____,____,____,____,____}},
		{"rts",		M_IMPLIED,																												{0x60,____,____,____,____,____,____,____,____,____,____,____}},
		{"sbc",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,	{____,0xE9,0xE5,0xF5,____,0xED,0xFD,0xF9,0xE1,0xF1,____,____}},
		{"sec",		M_IMPLIED,																												{0x38,____,____,____,____,____,____,____,____,____,____,____}},
		{"sed",		M_IMPLIED,																												{0xF8,____,____,____,____,____,____,____,____,____,____,____}},
		{"sei",		M_IMPLIED,																												{0x78,____,____,____,____,____,____,____,____,____,____,____}},
		{"sta",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_EXTENDED_OFF_Y|M_INDIRECT_OFF_X|M_INDIRECT_OFF_Y,				{____,____,0x85,0x95,____,0x8D,0x9D,0x99,0x81,0x91,____,____}},
		{"stx",		M_ZEROPAGE|M_ZEROPAGE_OFF_Y|M_EXTENDED,																					{____,____,0x86,____,0x96,0x8E,____,____,____,____,____,____}},
		{"sty",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED,																					{____,____,0x84,0x94,____,0x8C,____,____,____,____,____,____}},
		{"tax",		M_IMPLIED,																												{0xAA,____,____,____,____,____,____,____,____,____,____,____}},
		{"tay",		M_IMPLIED,																												{0xA8,____,____,____,____,____,____,____,____,____,____,____}},
		{"tsx",		M_IMPLIED,																												{0xBA,____,____,____,____,____,____,____,____,____,____,____}},
		{"txa",		M_IMPLIED,																												{0x8A,____,____,____,____,____,____,____,____,____,____,____}},
		{"txs",		M_IMPLIED,																												{0x9A,____,____,____,____,____,____,____,____,____,____,____}},
		{"tya",		M_IMPLIED,																												{0x98,____,____,____,____,____,____,____,____,____,____,____}},
	};

// additional opcodes which are only valid for the 65C02
static OPCODE
	Additional65C02Opcodes[]=
	{
		{"bit",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,													{____,0x89,0x24,0x34,____,0x2C,0x3C,____,____,____,____,____}},
		{"bra",		M_RELATIVE,																												{____,____,____,____,____,____,____,____,____,____,____,0x80}},
		{"dea",		M_IMPLIED,																												{0x3A,____,____,____,____,____,____,____,____,____,____,____}},
		{"ina",		M_IMPLIED,																												{0x1A,____,____,____,____,____,____,____,____,____,____,____}},
		{"phx",		M_IMPLIED,																												{0xDA,____,____,____,____,____,____,____,____,____,____,____}},
		{"phy",		M_IMPLIED,																												{0x5A,____,____,____,____,____,____,____,____,____,____,____}},
		{"plx",		M_IMPLIED,																												{0xFA,____,____,____,____,____,____,____,____,____,____,____}},
		{"ply",		M_IMPLIED,																												{0x7A,____,____,____,____,____,____,____,____,____,____,____}},
		{"stz",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X,																{____,____,0x64,0x74,____,0x9C,0x9E,____,____,____,____,____}},
		{"trb",		M_ZEROPAGE|M_EXTENDED,																									{____,____,0x14,____,____,0x1C,____,____,____,____,____,____}},
		{"tsb",		M_ZEROPAGE|M_EXTENDED,																									{____,____,0x04,____,____,0x0C,____,____,____,____,____,____}},
	};

static bool ParseImmediatePreamble(char *theLine,int *lineIndex)
// Expect a pound sign, step over one if found
{
	if(theLine[*lineIndex]=='#')			// does this look like a '#'?
	{
		(*lineIndex)++;						// step over it
		return(true);
	}
	return(false);
}

static bool ParseIndexX(char *theLine,int *lineIndex)
// see if next thing on the line is the X register
// return true if so, false otherwise
{
	if(theLine[*lineIndex]=='X'||theLine[*lineIndex]=='x')
	{
		if(!IsLabelChar(theLine[(*lineIndex)+1]))
		{
			(*lineIndex)++;						// step over the register
			return(true);
		}
	}
	return(false);
}

static bool ParseIndexY(char *theLine,int *lineIndex)
// see if next thing on the line is the Y register
// return true if so, false otherwise
{
	if(theLine[*lineIndex]=='Y'||theLine[*lineIndex]=='y')
	{
		if(!IsLabelChar(theLine[(*lineIndex)+1]))
		{
			(*lineIndex)++;						// step over the register
			return(true);
		}
	}
	return(false);
}

// opcode handling for 6502

enum
{
	POT_IMMEDIATE,
	POT_VALUE,					// extended, zero page, or relative	xxxx or xx
	POT_VALUE_OFF_X,			// extended, or zero page			xxxx,X or xx,X
	POT_VALUE_OFF_Y,			// extended							xxxx,Y
	POT_INDIRECT,				// extended or zero page			(xxxx) or (xx)
	POT_INDIRECT_OFF_X,			// zero page						(xx,X)
	POT_INDIRECT_OFF_Y,			// zero page						(xx),Y
};

static bool ParseValueOperand(char *theLine,int *lineIndex,int *type,int *value,bool *unresolved)
// parse the operand as a value with a possible offset
{
	if(ParseExpression(theLine,lineIndex,value,unresolved))
	{
		if(ParseComment(theLine,lineIndex))
		{
			*type=POT_VALUE;
			return(true);
		}
		else if(ParseCommaSeparator(theLine,lineIndex))
		{
			if(ParseIndexX(theLine,lineIndex))
			{
				if(ParseComment(theLine,lineIndex))
				{
					*type=POT_VALUE_OFF_X;
					return(true);
				}
			}
			else if(ParseIndexY(theLine,lineIndex))
			{
				if(ParseComment(theLine,lineIndex))
				{
					*type=POT_VALUE_OFF_Y;
					return(true);
				}
			}
		}
	}
	return(false);
}

static bool ParseIndirectValueOperand(char *theString,int *type,int *value,bool *unresolved)
// An indirect operand has been parsed
// the type tells what it looked like at the outer level
// The expression within the parenthesis still needs to be evaluated
{
	int
		expressionIndex;

	expressionIndex=0;
	if(ParseExpression(theString,&expressionIndex,value,unresolved))
	{
		if(ParseComment(theString,&expressionIndex))
		{
			return(true);		// done, expression makes sense, and we are at the end
		}
		else
		{
			if(*type==POT_INDIRECT)		// make sure there was no index register on the outside of the indirect address
			{
 				if(ParseCommaSeparator(theString,&expressionIndex))
 				{
		 			if(ParseIndexX(theString,&expressionIndex))
					{
						if(ParseComment(theString,&expressionIndex))
						{
							*type=POT_INDIRECT_OFF_X;
							return(true);
						}
					}
				}
			}
		}
	}
	return(false);
}

static bool ParseOperand(char *theLine,int *lineIndex,int *type,int *value,bool *unresolved)
// Try to parse an operand and determine its type
// return true if the parsing succeeds
{
	char
		theString[MAXSTRING];
	int
		startIndex;

	if(ParseImmediatePreamble(theLine,lineIndex))		// an immediate operand?
	{
		if(ParseExpression(theLine,lineIndex,value,unresolved))
		{
			if(ParseComment(theLine,lineIndex))
			{
				*type=POT_IMMEDIATE;
				return(true);
			}
		}
		return(false);
	}
	else
	{
		startIndex=*lineIndex;							// remember where we are, because we may need to come back here
		if(ParseParentheticString(theLine,lineIndex,theString))	// does this look like a possible indirect value?
		{
			if(ParseComment(theLine,lineIndex))
			{
				*type=POT_INDIRECT;
				*lineIndex=startIndex;
				return(ParseIndirectValueOperand(theString,type,value,unresolved));
			}
			else if(ParseCommaSeparator(theLine,lineIndex))
			{
				if(ParseIndexY(theLine,lineIndex))
				{
					if(ParseComment(theLine,lineIndex))
					{
						*type=POT_INDIRECT_OFF_Y;
						return(ParseIndirectValueOperand(theString,type,value,unresolved));
					}
				}
			}
			else
			{
				*lineIndex=startIndex;					// value does not look indirect, so try direct approach
				return(ParseValueOperand(theLine,lineIndex,type,value,unresolved));
			}
		}
		else
		{
			return(ParseValueOperand(theLine,lineIndex,type,value,unresolved));
		}
	}
	return(false);
}

static bool HandleImmediate(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// an immediate addressing mode was located
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_IMMEDIATE)
	{
		CheckByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_IMMEDIATE],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleZeroPage(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with zero page mode output only
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE)
	{
		CheckUnsignedByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_ZEROPAGE],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleExtended(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with extended mode output only
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_EXTENDED)
	{
		CheckUnsignedWordRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_EXTENDED],listingRecord))
		{
			if(GenerateByte(value&0xFF,listingRecord))
			{
				fail=!GenerateByte(value>>8,listingRecord);
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleZeroPageOrExtended(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a zero page or extended address has been parsed
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE)
	{
		if(((value>=0)&&(value<256))||!(theOpcode->typeMask&M_EXTENDED))
		{
			fail=!HandleZeroPage(theOpcode,value,unresolved,listingRecord);
		}
		else
		{
			fail=!HandleExtended(theOpcode,value,unresolved,listingRecord);
		}
	}
	else
	{
		fail=!HandleExtended(theOpcode,value,unresolved,listingRecord);
	}
	return(!fail);
}

static bool HandleRelative(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a relative operand has been parsed
{
	bool
		fail;
	int
		offset;

	fail=false;
	if(GenerateByte(theOpcode->baseOpcode[OT_RELATIVE],listingRecord))
	{
		offset=0;
		if(!unresolved&&currentSegment)
		{
			offset=value-(currentSegment->currentPC+currentSegment->codeGenOffset)-1;
			Check8RelativeRange(offset,true,true);
		}
		fail=!GenerateByte(offset,listingRecord);
	}
	else
	{
		fail=true;
	}
	return(!fail);
}

static bool HandleValue(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a value has been parsed, it might be relative, zero page, or extended
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_RELATIVE)
	{
		fail=!HandleRelative(theOpcode,value,unresolved,listingRecord);
	}
	else
	{
		fail=!HandleZeroPageOrExtended(theOpcode,value,unresolved,listingRecord);
	}
	return(!fail);
}

static bool HandleZeroPageOffX(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with zero page offset by X
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE_OFF_X)
	{
		CheckUnsignedByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_ZEROPAGE_OFF_X],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleExtendedOffX(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with extended mode offset by X
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_EXTENDED_OFF_X)
	{
		CheckUnsignedWordRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_EXTENDED_OFF_X],listingRecord))
		{
			if(GenerateByte(value&0xFF,listingRecord))
			{
				fail=!GenerateByte(value>>8,listingRecord);
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleValueOffX(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// possible extended or zeropage value offset by X
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE_OFF_X)
	{
		if(((value>=0)&&(value<256))||!(theOpcode->typeMask&M_EXTENDED_OFF_X))
		{
			fail=!HandleZeroPageOffX(theOpcode,value,unresolved,listingRecord);
		}
		else
		{
			fail=!HandleExtendedOffX(theOpcode,value,unresolved,listingRecord);
		}
	}
	else
	{
		fail=!HandleExtendedOffX(theOpcode,value,unresolved,listingRecord);
	}
	return(!fail);
}

static bool HandleZeroPageOffY(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with zero page offset by Y
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE_OFF_Y)
	{
		CheckUnsignedByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_ZEROPAGE_OFF_Y],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleExtendedOffY(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// deal with extended mode offset by Y
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_EXTENDED_OFF_Y)
	{
		CheckUnsignedWordRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_EXTENDED_OFF_Y],listingRecord))
		{
			if(GenerateByte(value&0xFF,listingRecord))
			{
				fail=!GenerateByte(value>>8,listingRecord);
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleValueOffY(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// possible extended or zero page value offset by Y
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_ZEROPAGE_OFF_Y)
	{
		if(((value>=0)&&(value<256))||!(theOpcode->typeMask&M_EXTENDED_OFF_Y))
		{
			fail=!HandleZeroPageOffY(theOpcode,value,unresolved,listingRecord);
		}
		else
		{
			fail=!HandleExtendedOffY(theOpcode,value,unresolved,listingRecord);
		}
	}
	else
	{
		fail=!HandleExtendedOffY(theOpcode,value,unresolved,listingRecord);
	}
	return(!fail);
}

static bool HandleIndirect(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a indirect value has been parsed, it must be indirect word
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_INDIRECT_WORD)
	{
		CheckUnsignedWordRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_INDIRECT_WORD],listingRecord))
		{
			if(GenerateByte(value&0xFF,listingRecord))
			{
				fail=!GenerateByte(value>>8,listingRecord);
			}
			else
			{
				fail=true;
			}
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleIndirectOffX(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a indirect value offset by X has been parsed, it must be zero page
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_INDIRECT_OFF_X)
	{
		CheckUnsignedByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_INDIRECT_OFF_X],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleIndirectOffY(OPCODE *theOpcode,int value,bool unresolved,LISTING_RECORD *listingRecord)
// a indirect value offset by Y has been parsed, it must be zero page
{
	bool
		fail;

	fail=false;
	if(theOpcode->typeMask&M_INDIRECT_OFF_Y)
	{
		CheckUnsignedByteRange(value,true,true);
		if(GenerateByte(theOpcode->baseOpcode[OT_INDIRECT_OFF_Y],listingRecord))
		{
			fail=!GenerateByte(value,listingRecord);
		}
		else
		{
			fail=true;
		}
	}
	else
	{
		ReportBadOperands();
	}
	return(!fail);
}

static bool HandleOpcode(void *theOpcode,char *theLine,int *lineIndex,LISTING_RECORD *listingRecord)
// look at the type of opcode available, parse operands as allowed
// return false only if there was a 'hard' error
{
	OPCODE
		*actualOpcode;
	bool
		fail;
	int
		elementType;
	int
		value;
	bool
		unresolved;

	fail=false;
	actualOpcode=(OPCODE *)theOpcode;
	if(!ParseComment(theLine,lineIndex))
	{
		if(ParseOperand(theLine,lineIndex,&elementType,&value,&unresolved))
		{
			switch(elementType)
			{
				case POT_IMMEDIATE:
					return(HandleImmediate(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_VALUE:
					return(HandleValue(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_VALUE_OFF_X:
					return(HandleValueOffX(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_VALUE_OFF_Y:
					return(HandleValueOffY(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_INDIRECT:
					return(HandleIndirect(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_INDIRECT_OFF_X:
					return(HandleIndirectOffX(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_INDIRECT_OFF_Y:
					return(HandleIndirectOffY(actualOpcode,value,unresolved,listingRecord));
					break;
			}
		}
		else
		{
			ReportBadOperands();
		}
	}
	else
	{
		if(actualOpcode->typeMask&M_IMPLIED)
		{
			fail=!GenerateByte(actualOpcode->baseOpcode[OT_IMPLIED],listingRecord);
		}
		else if(actualOpcode->typeMask&M_IMPLIED_2)
		{
			fail=!GenerateByte(actualOpcode->baseOpcode[OT_IMPLIED_2],listingRecord);
			fail|=!GenerateByte(0x00,listingRecord);								// two-byte opcode, second byte is ignored
		}
		else
		{
			ReportBadOperands();
		}
	}
	return(!fail);
}

static void *MatchOpcode(char *theOpcode)
// match opcodes for this processor, return NULL if none matched
{
	void
		*result;

	result=NULL;
	if(currentProcessor->processorData)
	{
		result=STFindDataForName(*((SYMTABLE **)(currentProcessor->processorData)),theOpcode);	// search enhanced opcodes first
	}
	if(!result)
	{
		result=STFindDataForName(opcodeSymbols,theOpcode);		// fallback to here if nothing located
	}
	return(result);
}

static bool HandlePseudoOpcode(PSEUDO_OPCODE *theOpcode,char *theLine,int *lineIndex,bool haveLabel,bool isLocal,char *lineLabel,LISTING_RECORD *listingRecord)
// look at the type of opcode available, parse operands as allowed
// return false only if there was a 'hard' error
{
	return(theOpcode->theFunction(theOpcode,theLine,lineIndex,haveLabel,isLocal,lineLabel,listingRecord));
}

static PSEUDO_OPCODE *MatchPseudoOpcode(char *theOpcode)
// match pseudo opcodes for this processor, return NULL if none matched
{
	return((PSEUDO_OPCODE *)STFindDataForName(pseudoOpcodeSymbols,theOpcode));
}

static bool SelectProcessor(PROCESSOR *theProcessor)
// A processor in this family is being selected to assemble with
{
	currentProcessor=theProcessor;
	return(true);
}

static void DeselectProcessor(PROCESSOR *theProcessor)
// A processor in this family is being deselected
{
}

static void UnInitFamily()
// undo what InitFamily did
{
	STDisposeSymbolTable(opcode65C02Symbols);
	STDisposeSymbolTable(opcodeSymbols);
	STDisposeSymbolTable(pseudoOpcodeSymbols);
}

static bool InitFamily()
// initialize symbol tables
{
	unsigned int
		i;
	bool
		fail;

	fail=false;
	currentProcessor=NULL;

	if((pseudoOpcodeSymbols=STNewSymbolTable()))
	{
		for(i=0;!fail&&(i<sizeof(pseudoOpcodes)/sizeof(PSEUDO_OPCODE));i++)
		{
			if(!STAddEntryAtEnd(pseudoOpcodeSymbols,pseudoOpcodes[i].name,&pseudoOpcodes[i]))
			{
				fail=true;
			}
		}
		if(!fail)
		{
			if((opcodeSymbols=STNewSymbolTable()))
			{
				for(i=0;!fail&&(i<sizeof(Opcodes)/sizeof(OPCODE));i++)
				{
					if(!STAddEntryAtEnd(opcodeSymbols,Opcodes[i].name,&Opcodes[i]))
					{
						fail=true;
					}
				}
				if(!fail)
				{
					if((opcode65C02Symbols=STNewSymbolTable()))
					{
						for(i=0;!fail&&(i<sizeof(Additional65C02Opcodes)/sizeof(OPCODE));i++)
						{
							if(!STAddEntryAtEnd(opcode65C02Symbols,Additional65C02Opcodes[i].name,&Additional65C02Opcodes[i]))
							{
								fail=true;
							}
						}
						if(!fail)
						{
							return(true);
						}
						STDisposeSymbolTable(opcode65C02Symbols);
					}
				}
				STDisposeSymbolTable(opcodeSymbols);
			}
		}
		STDisposeSymbolTable(pseudoOpcodeSymbols);
	}
	return(false);
}

// processors handled here (the constuctors for these variables link them to the global
// list of processors that the assembler knows how to handle)

static PROCESSOR_FAMILY
	processorFamily("Rockwell 6502",InitFamily,UnInitFamily,SelectProcessor,DeselectProcessor,MatchPseudoOpcode,HandlePseudoOpcode,MatchOpcode,HandleOpcode);

static PROCESSOR
	processors[]=
	{
		PROCESSOR(&processorFamily,"6502",NULL),
		PROCESSOR(&processorFamily,"65c02",&opcode65C02Symbols),
	};