//	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 Sunplus SPCxxxx (crippled 6502 core)

#include	"include.h"

static SYMTABLE
	*pseudoOpcodeSymbols,
	*opcodeSymbols;

// 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_EXTENDED				4								// xxxx
#define	OT_EXTENDED_OFF_X		5								// xxxx,X
#define	OT_INDIRECT_OFF_X		6								// (xx,X)
#define	OT_INDIRECT_WORD		7								// (xxxx)
#define	OT_RELATIVE				8								// one byte relative offset

#define	OT_NUM					OT_RELATIVE+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_EXTENDED				(1<<OT_EXTENDED)
#define	M_EXTENDED_OFF_X		(1<<OT_EXTENDED_OFF_X)
#define	M_INDIRECT_OFF_X		(1<<OT_INDIRECT_OFF_X)
#define	M_INDIRECT_WORD			(1<<OT_INDIRECT_WORD)
#define	M_RELATIVE				(1<<OT_RELATIVE)

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

// prototypes for the handler functions which need to be declared before we can build
// the opcode table

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

// differences between this and a 6502:
//	no Y register
//	no asl/lsr instructions
//	no decimal flag (so no cld/sed instructions)
//	many instructions have fewer supported address modes
//	opcodes are all different (except for brk = 0x00)
//

static OPCODE
	Opcodes[]=
	{
//																											imp   imm  zp   zpx  ext  extx indx indw rel
		{"adc",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x56,0x17,____,____,____,____,____,____}},
		{"and",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x54,0x15,____,____,____,____,____,____}},
		{"bcc",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x28}},
		{"bcs",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x38}},
		{"beq",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x3a}},
		{"bit",		M_ZEROPAGE|M_EXTENDED,																	{____,____,0x11,____,0x51,____,____,____,____}},
		{"bmi",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x18}},
		{"bne",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x2a}},
		{"bpl",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x08}},
		{"brk",		M_IMPLIED,																				{0x00,____,____,____,____,____,____,____,____}},
		{"bvc",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x0a}},
		{"bvs",		M_RELATIVE,																				{____,____,____,____,____,____,____,____,0x1a}},
		{"clc",		M_IMPLIED,																				{0x48,____,____,____,____,____,____,____,____}},
		{"cli",		M_IMPLIED,																				{0x4a,____,____,____,____,____,____,____,____}},
		{"clv",		M_IMPLIED,																				{0x78,____,____,____,____,____,____,____,____}},
		{"cmp",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X,												{____,0x66,0x27,0x2f,____,____,____,____,____}},
		{"cpx",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x32,0x33,____,____,____,____,____,____}},
		{"dec",		M_ZEROPAGE|M_ZEROPAGE_OFF_X,															{____,____,0xa3,0xab,____,____,____,____,____}},
		{"dex",		M_IMPLIED,																				{0xe2,____,____,____,____,____,____,____,____}},
		{"eor",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x46,0x07,____,____,____,____,____,____}},
		{"inc",		M_ZEROPAGE,																				{____,____,0xb3,____,____,____,____,____,____}},
		{"inx",		M_IMPLIED,																				{0x72,____,____,____,____,____,____,____,____}},
		{"jmp",		M_EXTENDED|M_INDIRECT_WORD,																{____,____,____,____,0x43,____,____,0x53,____}},
		{"jsr",		M_EXTENDED,																				{____,____,____,____,0x10,____,____,____,____}},
		{"lda",		M_IMMEDIATE|M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_EXTENDED|M_EXTENDED_OFF_X|M_INDIRECT_OFF_X,	{____,0x74,0x35,0x3d,0x75,0x7d,0x34,____,____}},
		{"ldx",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0xb0,0xb1,____,____,____,____,____,____}},
		{"nop",		M_IMPLIED,																				{0xf2,____,____,____,____,____,____,____,____}},
		{"ora",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x44,0x05,____,____,____,____,____,____}},
		{"pha",		M_IMPLIED,																				{0x42,____,____,____,____,____,____,____,____}},
		{"php",		M_IMPLIED,																				{0x40,____,____,____,____,____,____,____,____}},
		{"pla",		M_IMPLIED,																				{0x52,____,____,____,____,____,____,____,____}},
		{"plp",		M_IMPLIED,																				{0x50,____,____,____,____,____,____,____,____}},
		{"rol",		M_IMPLIED|M_ZEROPAGE,																	{0xd0,____,0x91,____,____,____,____,____,____}},
		{"ror",		M_IMPLIED|M_ZEROPAGE,																	{0xd2,____,0x93,____,____,____,____,____,____}},
		{"rti",		M_IMPLIED,																				{0x02,____,____,____,____,____,____,____,____}},
		{"rts",		M_IMPLIED,																				{0x12,____,____,____,____,____,____,____,____}},
		{"sbc",		M_IMMEDIATE|M_ZEROPAGE,																	{____,0x76,0x37,____,____,____,____,____,____}},
		{"sec",		M_IMPLIED,																				{0x58,____,____,____,____,____,____,____,____}},
		{"sei",		M_IMPLIED,																				{0x5a,____,____,____,____,____,____,____,____}},
		{"sta",		M_ZEROPAGE|M_ZEROPAGE_OFF_X|M_INDIRECT_OFF_X,											{____,____,0x25,0x2d,____,____,0x24,____,____}},
		{"stx",		M_ZEROPAGE|M_EXTENDED,																	{____,____,0xa1,____,0xe1,____,____,____,____}},
		{"tax",		M_IMPLIED,																				{0xf0,____,____,____,____,____,____,____,____}},
		{"tsx",		M_IMPLIED,																				{0xf8,____,____,____,____,____,____,____,____}},
		{"txa",		M_IMPLIED,																				{0xe0,____,____,____,____,____,____,____,____}},
		{"txs",		M_IMPLIED,																				{0xe8,____,____,____,____,____,____,____,____}},
	};

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);
}

// opcode handling for Sunplus

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_INDIRECT,				// extended or zero page			(xxxx) or (xx)
	POT_INDIRECT_OFF_X,			// zero page						(xx,X)
};

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);
				}
			}
		}
	}
	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
			{
				// DEBUG something may need to happen around here so lda (ptr),x won't work but lda (this + that)*offset,x will
				//  (post-indexed indirect is not supported)
				*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 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 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_INDIRECT:
					return(HandleIndirect(actualOpcode,value,unresolved,listingRecord));
					break;
				case POT_INDIRECT_OFF_X:
					return(HandleIndirectOffX(actualOpcode,value,unresolved,listingRecord));
					break;
			}
		}
		else
		{
			ReportBadOperands();
		}
	}
	else
	{
		if(actualOpcode->typeMask&M_IMPLIED)
		{
			fail=!GenerateByte(actualOpcode->baseOpcode[OT_IMPLIED],listingRecord);
		}
		else
		{
			ReportBadOperands();
		}
	}
	return(!fail);
}

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

	result=STFindDataForName(opcodeSymbols,theOpcode);
	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
{
	return(true);
}

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

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

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

	fail=false;
	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)
				{
					return(true);
				}
				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("Sunplus SPCxxx",InitFamily,UnInitFamily,SelectProcessor,DeselectProcessor,MatchPseudoOpcode,HandlePseudoOpcode,MatchOpcode,HandleOpcode);

static PROCESSOR
	processors[]=
	{
		PROCESSOR(&processorFamily,"spc08a",NULL),
		PROCESSOR(&processorFamily,"spc21a",NULL),
		PROCESSOR(&processorFamily,"spc21a1",NULL),
		PROCESSOR(&processorFamily,"spc41a",NULL),
		PROCESSOR(&processorFamily,"spc41b",NULL),
		PROCESSOR(&processorFamily,"spc41b1",NULL),
		PROCESSOR(&processorFamily,"spc41c",NULL),
		PROCESSOR(&processorFamily,"spc81a",NULL),
		PROCESSOR(&processorFamily,"spc121a",NULL),
		PROCESSOR(&processorFamily,"spc251a",NULL),
		PROCESSOR(&processorFamily,"spc512a",NULL),
		PROCESSOR(&processorFamily,"spc500a1",NULL),
		PROCESSOR(&processorFamily,"spc1000a",NULL),
		PROCESSOR(&processorFamily,"spc2000a",NULL),
	};