public WriteOperationArgument(Token tok)
{
if (tok.Type == TokenType.Identifier)
{
if (tok.Value.StartsWith("arg"))
{
Type = OperationSourceType.Argument;
ParentArgIdx = (byte)(Utils.SingleDigitParse(tok.Value[3]) - 1);
}
else
{
throw new Exception("Unknown identifier for a write operation argument!");
}
}
else
{
Type = OperationSourceType.Constant;
if (tok.Type != TokenType.Number)
throw new Exception("Expected either an argument or a number!");
Constant = (byte)tok.NumberValue.Value;
}
}
public BitRange(Token[] toks, ref int curIdx)
{
Token tok;
tok = toks[curIdx];
if (tok.Type != TokenType.Number)
throw new Exception("Expected a number for the bit range!");
EndIdx = tok.NumberValue.Value;
curIdx++;
tok = toks[curIdx];
if (tok.Type == TokenType.Dot)
{
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.Dot)
throw new Exception("Expected a second dot for the elips statement!");
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.Number)
throw new Exception("Expected a number for the start of the bit range!");
StartIdx = tok.NumberValue.Value;
curIdx++;
tok = toks[curIdx];
}
else
{
StartIdx = 0;
EndIdx--;
}
if (tok.Type != TokenType.RSqBracket)
throw new Exception("Expected the closing of the square bracket!");
curIdx++;
}
public WriteOperation(Token[] toks, InstructionForm ParentForm)
{
// As a note, all operations should be 4 characters,
// if they are unable to be 4 characters, then they
// should be sets of 4 characters seperated in
// some way. (this allows for the write operations to
// be aligned in the cpud file)
Token tok = toks[0];
switch (toks.Length)
{
case 1:
if (tok.Type == TokenType.Number)
{
this.Type = WriteOperationType.Byte;
this.ByteValue = (byte)tok.NumberValue.Value;
}
else if (tok.Value.StartsWith("arg"))
{
this.ArgIdx = (byte)(Utils.SingleDigitParse(tok.Value[3]) - 1);
if (!ParentForm[ArgIdx].ArgType.HasSize)
{
this.Type = WriteOperationType.Arg;
}
else
{
switch(ParentForm[ArgIdx].ArgType.Size)
{
case 1:
this.Type = WriteOperationType.Imm8;
break;
case 2:
this.Type = WriteOperationType.Imm16;
break;
case 4:
this.Type = WriteOperationType.Imm32;
break;
default:
throw new Exception("Unknown arg type!");
}
}
}
else // Prefix
{
this.Type = WriteOperationType.Prefix;
this.SelectedPrefix = PrefixRegistry.GetPrefixName(tok.Value);
if (this.SelectedPrefix == null)
throw new Exception("Unknown write operation '" + tok.Value + "'!");
}
break;
case 3:
this.Type = WriteOperationType.BytePlusArg;
this.ArgIdx = (byte)(Utils.SingleDigitParse(toks[2].Value[3]) - 1);
this.ByteValue = (byte)tok.NumberValue.Value;
break;
case 4:
if (tok.Value == "evil")
{
if (toks[1].Type != TokenType.LSqBracket)
throw new Exception("Expected an opening square bracket before the exception's message!");
if (toks[3].Type != TokenType.RSqBracket)
throw new Exception("Expected the closing square bracket after the exception's message!");
this.Type = WriteOperationType.Throw;
this.MessageThrown = toks[2].Value;
}
else if (tok.Value.StartsWith("arg"))
{
if (toks[1].Type != TokenType.LSqBracket)
throw new Exception("Expected an opening square bracket before the argument write operation!");
if (toks[3].Type != TokenType.RSqBracket)
throw new Exception("Expected the closing square bracket after the argument write operation!");
this.ArgIdx = (byte)(Utils.SingleDigitParse(tok.Value[3]) - 1);
this.Type = WriteOperationType.Arg;
this.WriteArguments.Add(new WriteOperationArgument(toks[2]));
}
else
{
throw new Exception("Unknown write operation type!");
}
break;
default:
if (tok.Value.StartsWith("arg"))
{
if (toks[1].Type != TokenType.LSqBracket)
throw new Exception("Expected an opening square bracket before the argument write operation!");
this.Type = WriteOperationType.Arg;
this.ArgIdx = (byte)(Utils.SingleDigitParse(tok.Value[3]) - 1);
for (int i = 2; i < toks.Length - 1; i += 2)
{
this.WriteArguments.Add(new WriteOperationArgument(toks[i]));
if (i + 1 < toks.Length - 1 && toks[i + 1].Type != TokenType.Comma)
throw new Exception("Expected a comma!");
}
if (toks[toks.Length - 1].Type != TokenType.RSqBracket)
throw new Exception("Expected the closing square bracket after the argument write operation!");
}
else
{
throw new Exception("Unknown number of tokens passed in!");
}
break;
}
}
private static void DumpTokens(Token[] toks)
{
StreamWriter rtr = new StreamWriter("TokenDump.txt", false);
rtr.WriteLine("Writing a total of " + toks.Length.ToString() + " tokens.");
rtr.WriteLine();
for (int i = 0; i < toks.Length; i++)
{
rtr.WriteLine(toks[i].ToString());
}
rtr.Flush();
rtr.Close();
}
public BitPatternInvokeArgumentEntry(BitPattern parent, Token[] toks, ref int curIdx)
{
Token tok;
tok = toks[curIdx];
if (tok.Type != TokenType.Identifier)
throw new Exception("Expected an identifier for the name of the argument to map to!");
Name = tok.Value;
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.Equal)
throw new Exception("Expected an equals sign before the value to pass for the argument!");
curIdx++;
ArgValue = new BitPatternPieceOperation(parent, toks, ref curIdx);
}
public BitPattern(Token[] toks, ref int curIdx)
{
Token tok;
tok = toks[curIdx];
if (tok.Type != TokenType.Identifier)
throw new Exception("Expected an identifier for the name of the bit pattern!");
this.Name = tok.Value;
curIdx++;
tok = toks[curIdx];
while (tok.Type == TokenType.LParen)
{
curIdx++;
BitPatternPiece pc = new BitPatternPiece(this, toks, ref curIdx);
TotalLength += pc.TotalLength;
Pieces.Add(pc);
tok = toks[curIdx];
}
if (tok.Type != TokenType.EOL)
throw new Exception("Expected an EOL at the end of the bit pattern!");
curIdx++;
}
public BitPatternPiece(BitPattern parent, Token[] toks, ref int curIdx)
{
Token tok;
tok = toks[curIdx];
while (tok.Type != TokenType.RParen)
{
var bpp = new BitPatternPieceOperation(parent, toks, ref curIdx);
TotalLength += bpp.Length;
Operations.Add(bpp);
tok = toks[curIdx];
}
curIdx++;
}
public BitPatternPieceOperation(BitPattern parent, Token[] toks, ref int curIdx)
{
Parent = parent;
Token tok;
tok = toks[curIdx];
if (tok.Type == TokenType.Identifier)
{
OpType = OperationType.Arg;
if (!int.TryParse(tok.Value.Substring(1), out ArgIdx))
throw new Exception("Unknown argument '" + tok.Value + "'!");
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
throw new Exception("Expected the opening square bracket for the bit pattern operation selector!");
curIdx++;
Range = new BitRange(toks, ref curIdx);
parent.RequestArg(ArgIdx, Range.EndIdx);
}
else if (tok.Type == TokenType.Number)
{
OpType = OperationType.Literal;
Literal = tok.NumberValue.Value;
Number n = tok.NumberValue;
curIdx++;
tok = toks[curIdx];
if (n.Format == NumberFormat.Binary)
{
if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, n.LiteralLength - 1);
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, Utils.GetHighestBitIndexSet(Literal));
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type == TokenType.LParen)
{
curIdx++;
OpType = OperationType.BinaryOp;
tok = toks[curIdx];
switch(tok.Type)
{
case TokenType.Star:
BinaryOp = CodeBinaryOperatorType.Multiply;
break;
case TokenType.Plus:
BinaryOp = CodeBinaryOperatorType.Add;
break;
default:
throw new Exception("Unknown math operation to perform!");
}
curIdx++;
LHand = new BitPatternPieceOperation(parent, toks, ref curIdx);
RHand = new BitPatternPieceOperation(parent, toks, ref curIdx);
tok = toks[curIdx];
if (tok.Type != TokenType.RParen)
throw new Exception("Expected a closing parenthesis!");
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
{
Range = new BitRange(0, 32);
}
else
{
curIdx++;
Range = new BitRange(toks, ref curIdx);
}
}
else if (tok.Type == TokenType.Cash)
{
InvokedPatternArgMapping = new List<BitPatternInvokeArgumentEntry>();
OpType = OperationType.PatternInvoke;
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.Identifier)
throw new Exception("Expected an identifier for the bit pattern to invoke!");
InvokedPattern = BitPatternRegistry.GetPattern(tok.Value);
curIdx++;
tok = toks[curIdx];
if (tok.Type != TokenType.LSqBracket)
throw new Exception("Expected a left square bracket for the arguments to the bit operation!");
curIdx++;
tok = toks[curIdx];
bool expectsArg = true;
bool first = true;
while(tok.Type != TokenType.RSqBracket)
{
if (!expectsArg)
throw new Exception("Expected a closing square bracket for the arguments to the bit operation!");
InvokedPatternArgMapping.Add(new BitPatternInvokeArgumentEntry(parent, toks, ref curIdx));
tok = toks[curIdx];
if (tok.Type == TokenType.Comma)
{
curIdx++;
tok = toks[curIdx];
}
else
{
expectsArg = false;
}
first = false;
}
if (expectsArg && !first)
throw new Exception("Expected another argument!");
curIdx++;
}
else
{
throw new Exception("Unsupported bit pattern operation!");
}
}
public CustomArgOperation(InstructionArgType parent, Token[] tokens)
{
this.toks = tokens;
this.ParentArg = parent;
}
