public InstructionWidget( IInstruction op )
{
InitializeComponent();
this.Font = new Font("Lucida Console", 8.25f);
m_ItalicFont = new Font(this.Font, FontStyle.Italic);
this.Height = 15;
this.Executed = true;
m_Op = op;
Selected = false;
if (op is Scrutinizer.ISamplingInstruction)
{
Panel panel = new Panel();
m_FilterBox = CreateFilterBox(op);
m_FormatBox = CreateFormatBox(op);
panel.Anchor = AnchorStyles.Right;
panel.Width = m_FilterBox.Width + m_FormatBox.Width;
m_FilterBox.Left = m_FormatBox.Width;
panel.Controls.Add(m_FilterBox);
panel.Controls.Add(m_FormatBox);
this.Controls.Add(panel);
}
else if (op is Scrutinizer.ITextureInstruction)
{
m_FormatBox = CreateFormatBox(op);
m_FormatBox.Anchor = AnchorStyles.Right;
this.Controls.Add(m_FormatBox);
}
}
public InstructionWidget( IInstruction op )
{
InitializeComponent();
this.Font = new Font("Lucida Console", 8.25f);
this.Height = 15;
m_Op = op;
this.Brush = Brushes.Black;
if (op is Scrutinizer.ITexelLoadInstruction)
{
ComboBox cb = CreateFormatBox(op);
cb.Anchor = AnchorStyles.Right;
this.Controls.Add(cb);
}
if (op is Scrutinizer.ISamplingInstruction)
{
Panel panel = new Panel();
ComboBox cbFilter = CreateFilterBox(op);
ComboBox cbFormat = CreateFormatBox(op);
panel.Anchor = AnchorStyles.Right;
panel.Width = cbFilter.Width + cbFormat.Width;
cbFilter.Left = cbFormat.Width;
panel.Controls.Add(cbFilter);
panel.Controls.Add(cbFormat);
this.Controls.Add(panel);
}
}
public void Execute(IInstruction instruction)
{
var jtype = instruction as JTypeInstruction;
if (jtype != null)
JTypeExecutors[jtype.JumpType](jtype);
else
{
var itype = instruction as ITypeInstruction;
if (itype != null)
{
var cl = ITypeExecutors[itype.Opcode];
cl(itype);
}
else
{
var rtype = instruction as RTypeInstruction;
if (rtype != null)
RTypeExecutors[rtype.Function](rtype);
else
{
var coins = instruction as CoProcessorInstruction;
if (coins != null)
CoProcessorExecutors[coins.Format](coins);
}
}
}
}
public SprocketScript(string source, string descriptiveName, string scriptIdentificationString)
{
this.source = source;
this.identifier = new ExecutionState.ScriptRecursionIdentifier(descriptiveName, scriptIdentificationString);
TokenList tokens;
try
{
tokens = Tokeniser.Extract(source);
}
catch (TokeniserException ex)
{
Token falseToken = new Token(source.Substring(ex.Position, 1), TokenType.FreeText, ex.Position);
Token token = new Token(GetErrorHTML(ex.Message, falseToken, null), TokenType.FreeText, 0);
tokens = new TokenList(new List<Token>(new Token[] { token }));
instruction = new ShowInstruction();
instruction.Build(tokens);
hasError = true;
exception = ex;
return;
}
try
{
instruction = TokenParser.BuildInstruction(tokens);
}
catch (TokenParserException ex)
{
Token token = new Token(GetErrorHTML(ex.Message, ex.Token, null), TokenType.FreeText, 0);
tokens = new TokenList(new List<Token>(new Token[] { token }));
instruction = new ShowInstruction();
instruction.Build(tokens);
hasError = true;
}
}
public void Parse_All()
{
var reader = ConsolePlatformTester.LoadInput("input.simple.txt");
var actual = Instruction.Read(reader).ToArray();
var expected = new IInstruction[]
{
// Settings
new HandsPerLevelInstruction(10),
new StartingStackInstruction(2000),
new YourBotInstruction(PlayerName.player1),
new TimeBankInstruction(TimeSpan.FromSeconds(10)),
new TimePerMoveInstruction(TimeSpan.FromMilliseconds(500)),
// Match
new RoundInstruction(1),
new SmallBlindInstruction(10),
new BigBlindInstruction(20),
// Player
new OnButtonInstruction(PlayerName.player2),
new StackInstruction(PlayerName.player1, 2000),
new StackInstruction(PlayerName.player2, 2000),
new PostInstruction(PlayerName.player2, 10),
new PostInstruction(PlayerName.player1, 20),
new HandInstruction(PlayerName.player1, Cards.Parse("[9c,7h]")),
new ActionInstruction(PlayerName.player2, GameAction.Call),
};
CollectionAssert.AreEqual(expected, actual.Take(expected.Length).ToArray());
Assert.AreEqual(0, actual.Length);
}
public void ResolveLables(IInstruction[] instructions)
{
if (IsResolved) return;
int pos = 0;
for(int i = 0; i < instructions.Length; i++)
{
if(this.labels.AsEnumerable().Any(x => x == instructions[i].Label))
{
if (this.additional.Length == 1)
{
this.additional[0] = (ushort) pos;
this.IsResolved = true;
} else if(this.additional.Length== 2)
{
if (this.labels.First() == instructions[i].Label)
{
this.additional[0] = (ushort)pos;
this.labels[0] = string.Empty;
}
if(this.labels[1] == instructions[i].Label)
{
this.additional[1] = (ushort) pos;
this.labels[1] = string.Empty;
}
this.IsResolved = this.labels.All(s => s == string.Empty);
}
}
pos += instructions[i].Size;
}
}
private static string GenerateFromInstruction(IInstruction instruction)
{
var bytes = instruction.GetReportData();
var sb = new StringBuilder();
sb.Append("WR ");
AppendBytesAsString(bytes, sb);
return sb.ToString();
}
public IEnumerable<IInstruction> ResolveSymbolicInstructions(IInstruction[] instructions)
{
// must go through labels first, removing them when they've been added to the symbol table
var linesWithLabelsRemoved = _hackLabelResolver.ResolveLabels(_symbolTable, instructions).ToArray();
// then go through variables, resolving them after adding to table if not already there
return _hackVariableResolver.ResolveVariables(_symbolTable, linesWithLabelsRemoved).ToArray();
}
public BreakpointViewModel(IGameBoy gameboy, IInstruction inst)
{
_gameboy = gameboy;
_instruction = inst;
OriginalAddress = inst.Address;
Address = "0x" + inst.Address.ToString("x2");
Name = inst.Name;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:B4F.TotalGiro.PortfolioComparer.PortfolioCompareSetting">PortfolioCompareSetting</see> class.
/// </summary>
/// <param name="compareAction">
/// When this argument equals 'CloseOrders' it is checked whether positions exist that do not exist in the modelportfolio.
/// When this is the case this will result in only sell close size based orders.
/// When the argument equals 'Rebalance' a normal rebalance is done.
/// However the method will generate an error when positions do exist that do not exist in the modelportfolio.
/// When the argument equals 'CashFundOrders' the remaining cash will be transferred to cash fund.
/// </param>
/// <param name="instruction">The instruction that generated the orders</param>
/// <param name="engineParams">The parameters used in porfolio compare action</param>
public PortfolioCompareSetting(PortfolioCompareAction compareAction, IInstruction instruction, InstructionEngineParameters engineParams)
{
if (instruction == null)
throw new ApplicationException("The instruction is mandatory");
this.CompareAction = compareAction;
this.Instruction = instruction;
this.EngineParams = engineParams;
}
public bool Apply(IInstruction instruction)
{
if (Mapping.ContainsKey(instruction.GetType()))
{
Mapping[instruction.GetType()].Invoke(instruction, this);
return true;
}
return false;
}
public Instruction(IInstruction src)
{
Operation = src.Operation;
Modifier = src.Modifier;
ModeA = src.ModeA;
ValueA = src.ValueA;
ModeB = src.ModeB;
ValueB = src.ValueB;
}
/// <summary>
/// This method tries to cancel the instruction (if allowed).
/// </summary>
/// <param name="instruction">The <see cref="T:B4F.TotalGiro.Accounts.Instructions.Instruction">Instruction</see> to process</param>
/// <param name="cancelOrders">The cancelled orders that might result from the processing</param>
/// <returns>true when succesfull</returns>
public bool CancelInstruction(IInstruction instruction)
{
int oldStatus = instruction.Status;
string oldMessage = instruction.Message;
int nextStatus;
nextStatus = stateMachine.SetStatus(getStateTable(instruction.InstructionType), (int)oldStatus, (int)InstructionEvents.evCancel, (IStateMachineClient)instruction);
if (nextStatus != 0)
instruction.Status = nextStatus;
return (instruction.Status != oldStatus || instruction.Message != oldMessage);
}
public override void Given()
{
this.StubbedRover = stub_a<IRover>();
this.StubbedPlateau = stub_a<IPlateau>();
this.StubbedInstruction = stub_a<IInstruction>();
this.StubbedPositionChecks = stub_a<List<IPositionCheck>>();
this.PlateauController = new PlateauController(this.StubbedPlateau);
this.PlateauController.PositionChecks = this.StubbedPositionChecks;
this.StubbedRover.Instruction = this.StubbedInstruction;
}
public EngineInstruction(int address, IRunningWarrior owner)
{
Operation = Operation.DAT;
Modifier = Modifier.F;
ModeA = Mode.Direct;
ValueA = 0;
ModeB = Mode.Direct;
ValueB = 0;
OriginalInstruction = null;
Address = address;
OriginalOwner = owner;
}
private void LogInstruction(IInstruction instruction, byte opCode)
{
var instructionSize = instruction.Variants[opCode].InstructionSize();
var instructionBytes = mem.SequenceFrom(state.Pc).Take(instructionSize).ToArray();
Console.WriteLine("{0:X2} {1,-10}{2,-32}A:{3:X2} X:{4:X2} Y:{5:X2} P:{6:X2} SP:{7:X2}", // TODO: Cycle and scanline goes at the end
state.Pc,
string.Join(" ", instructionBytes.Select(x => x.ToString("X2"))),
instruction.Disassemble(instructionBytes),
state.A,
state.X,
state.Y,
state.StatusRegister,
state.Sp);
}
/// <summary>
/// Creates a new Program
/// </summary>
/// <param name="processor">the processor for this program</param>
/// <param name="instructions">the program instructions</param>
/// <param name="debugInfo">optional program debug information</param>
public Program(Processor processor, IList<IInstruction> instructions,
ProgramDebugInfo debugInfo = null)
{
this.DebugInfo = debugInfo;
this.Processor = processor;
// Check instructions size
if (instructions.Count > processor.RomSize)
{
throw new ArgumentException("Number of instructions > size of instruction ROM");
}
// Create new readonly instructions array
IInstruction[] instructionArray = new IInstruction[processor.RomSize];
instructions.CopyTo(instructionArray, 0);
this.Instructions = new ReadOnlyCollection<IInstruction>(instructionArray);
}
public SprocketScript(string source)
{
this.source = source;
List<Token> tokens = Tokeniser.Extract(source);
try
{
instruction = TokenParser.BuildInstruction(tokens);
}
catch (TokenParserException ex)
{
tokens.Clear();
tokens.Add(new Token(GetErrorHTML(ex.Message, ex.Token), TokenType.StringLiteral, 0));
instruction = new ShowInstruction();
int n = 0;
instruction.Build(tokens, ref n);
}
}
public void ResolveLables(IInstruction[] instructions)
{
// if (IsResolved) return;
// int pos = 0;
// for (int i = 0; i < instructions.Length; i++)
// {
// if (this.labels.AsEnumerable().Any(x => x == instructions[i].Label))
// {
// if (this.additional.Length == 1)
// {
// this.additional[0] = (ushort)pos;
// this.IsResolved = true;
// }
// }
// pos += instructions[i].Size;
// }
}
public UInt32 disassemble(ulong offset, out IInstruction instr, ref DISASM_INOUT_PARAMS param)
{
byte[] bt = assembly.ReadBytes(offset, 10);
dsm = new TUP.AsmResolver.ASM.x86Disassembler(bt);
dsm.CurrentOffset = 0;
Instr instr1 = new Instr();
instr1.Addr = offset;
instr1.ins = dsm.DisassembleNextInstruction();
instr1.bytes = assembly.ReadBytes(offset, instr1.ins.Size);
if (instr1.bytes[0] == 0xFF)
if (instr1.bytes[1] == 0x15)
if (instr1.ins.Operand1 != null)
instr1.disp.value.d64 = ((Offset)instr1.ins.Operand1.Value).Va;//Call ExitProcess probably
instr = instr1;
return (UInt32)instr1.ins.Size;
}
private ComboBox CreateFilterBox( IInstruction op )
{
ComboBox cb = new ComboBox();
foreach (string s in Enum.GetNames(typeof(Scrutinizer.TextureFilter)))
cb.Items.Add(s);
cb.Width = 96;
cb.SelectedIndex = (int)Scrutinizer.TextureFilter.TRILINEAR;
cb.DropDownStyle = ComboBoxStyle.DropDownList;
cb.SelectedIndexChanged += delegate(object s, EventArgs e)
{
if (op is ISamplingInstruction)
{
ISamplingInstruction samp = op as ISamplingInstruction;
samp.Filter = (TextureFilter)cb.SelectedIndex;
}
};
return cb;
}
public EngineInstruction(IInstruction src, int address, IRunningWarrior owner)
{
Operation = src.Operation;
Modifier = src.Modifier;
ModeA = src.ModeA;
ValueA = src.ValueA;
ModeB = src.ModeB;
ValueB = src.ValueB;
Address = address;
OriginalOwner = owner;
if (src is EngineInstruction)
{
EngineInstruction ei = (EngineInstruction)src;
OriginalInstruction = ei.OriginalInstruction;
}
else
{
OriginalInstruction = src;
}
}
/// <summary>
/// Adds a new instruction to the program
/// </summary>
/// <param name="instruction">instruction to add</param>
/// <param name="line">optional line number for this instruction</param>
/// <remarks>
/// <para>The instruction is inserted at <see cref="Address"/> and <see cref="Address"/> is
/// then incremented.</para>
/// <para>You are not allowed to "rewrite" instructions by decrementing Address and then
/// adding another instruction</para>
/// </remarks>
/// <exception cref="ImportException">
/// If you attempt to "rewrite" an instruction
/// </exception>
public void Add(IInstruction instruction, int? line = null)
{
// Ensure store is large enough
if (Address >= store.Count)
{
store.AddRange(Enumerable.Repeat<IInstruction>(null, Address - store.Count + 1));
}
else if (store[Address] != null)
{
throw new ImportException("You cannot insert 2 instructions at the same address");
}
// Store line number
if (line.HasValue)
lineNumbers[Address] = line.Value;
// Insert instruction
store[Address] = instruction;
Address++;
}
public EngineInstruction(IInstruction src, int address)
{
Operation = src.Operation;
Modifier = src.Modifier;
ModeA = src.ModeA;
ValueA = src.ValueA;
ModeB = src.ModeB;
ValueB = src.ValueB;
Address = address;
if (src is EngineInstruction)
{
EngineInstruction ei = (EngineInstruction)src;
OriginalInstruction = ei.OriginalInstruction;
OriginalOwner = ei.OriginalOwner;
}
else
{
OriginalInstruction = src;
OriginalOwner = null;
}
}
public InstructionViewModel(ICPU cpu, IInstruction instruction)
{
_cpu = cpu;
_instruction = instruction;
originalAddress = instruction.Address;
Address = "0x" + instruction.Address.ToString("x2");
Opcode = "0x" + instruction.OpCode.ToString("x2");
Name = instruction.Name;
Literal = "0x" + instruction.Literal.ToString("x2");
Description = instruction.Description;
if (!instruction.CB)
{
Ticks = CPUSpace.Dictionaries.CPUInstructionClocks.Get((byte)instruction.OpCode);
}
else
{
Ticks = CPUSpace.Dictionaries.CPUCBInstructionClocks.Get((byte)instruction.OpCode);
}
}
private ComboBox CreateFormatBox( IInstruction op )
{
ComboBox cb = new ComboBox();
foreach (string s in Enum.GetNames(typeof(Scrutinizer.TexelFormat)))
cb.Items.Add(s);
cb.Width = 80;
cb.SelectedIndex = (int)Scrutinizer.TexelFormat.RGBA8;
cb.DropDownStyle = ComboBoxStyle.DropDownList;
cb.SelectedIndexChanged += delegate(object s, EventArgs e)
{
if (op is ISamplingInstruction)
{
ISamplingInstruction samp = op as ISamplingInstruction;
samp.Format = (TexelFormat)cb.SelectedIndex;
}
else if( op is ITexelLoadInstruction )
{
ITexelLoadInstruction ld = op as ITexelLoadInstruction;
ld.Format = (TexelFormat)cb.SelectedIndex;
}
};
return cb;
}
public Instructions_ToggleStringModeShould()
{
_sit = new ToggleStringMode();
_runtime = MockIBefungeRunTimeFactory.Create();
}
public Instructions_LogicalNotShould()
{
_sit = new LogicalNot();
_runtime = MockIBefungeRunTimeFactory.Create();
}
protected virtual void ExecuteEditInstruction(IInstruction instruction)
{
}
//This function actually creates the object associated with each Instruction by using a long switch statement. The object
//created is polymorphed up to an IInstruction and then returned from the function to be stored in the encodedInstrs list.
//Ugly? Very. Effective? Extremely.
private IInstruction createObject(string comm, int valToUse, int currentInstruc)
{
IInstruction retVal = null;
switch (comm)
{
case "exit":
retVal = new Exit(valToUse) as IInstruction;
break;
case "swap":
retVal = new Swap() as IInstruction;
break;
case "inpt":
retVal = new Inpt() as IInstruction;
break;
case "nop":
retVal = new Nop() as IInstruction;
break;
case "pop":
retVal = new Pop() as IInstruction;
break;
case "add":
retVal = new Add() as IInstruction;
break;
case "sub":
retVal = new Sub() as IInstruction;
break;
case "mul":
retVal = new Mul() as IInstruction;
break;
case "div":
retVal = new Div() as IInstruction;
break;
case "rem":
retVal = new Rem() as IInstruction;
break;
case "and":
retVal = new And() as IInstruction;
break;
case "or":
retVal = new Or() as IInstruction;
break;
case "xor":
retVal = new Xor() as IInstruction;
break;
case "neg":
retVal = new Neg() as IInstruction;
break;
case "not":
retVal = new Not() as IInstruction;
break;
case "goto":
retVal = new Goto(valToUse) as IInstruction;
break;
case "ifeq":
retVal = new If1(0, valToUse, currentInstruc) as IInstruction;
break;
case "ifne":
retVal = new If1(1, valToUse, currentInstruc) as IInstruction;
break;
case "iflt":
retVal = new If1(2, valToUse, currentInstruc) as IInstruction;
break;
case "ifgt":
retVal = new If1(3, valToUse, currentInstruc) as IInstruction;
break;
case "ifle":
retVal = new If1(4, valToUse, currentInstruc) as IInstruction;
break;
case "ifge":
retVal = new If1(5, valToUse, currentInstruc) as IInstruction;
break;
case "ifez":
retVal = new If2(0, valToUse, currentInstruc) as IInstruction;
break;
case "ifnz":
retVal = new If2(1, valToUse, currentInstruc) as IInstruction;
break;
case "ifmi":
retVal = new If2(2, valToUse, currentInstruc) as IInstruction;
break;
case "ifpl":
retVal = new If2(3, valToUse, currentInstruc) as IInstruction;
break;
case "dup":
retVal = new Dup(valToUse) as IInstruction;
break;
case "print":
retVal = new Print() as IInstruction;
break;
case "dump":
retVal = new Dump() as IInstruction;
break;
case "push":
retVal = new Push(valToUse) as IInstruction;
break;
}
return(retVal);
}
public void ChargerProgramme(string codeDuProgramme)
{
if (codeDuProgramme is null)
{
throw new System.ArgumentOutOfRangeException(nameof(codeDuProgramme));
}
IInstruction instructionCourante = new InstructionBFDebutProgramme();
this.Instructions = instructionCourante;
Stack <InstructionBFBoucleDebut> debutBoucle = new Stack <InstructionBFBoucleDebut>();
for (int indexInstruction = 0; indexInstruction < codeDuProgramme.Length; ++ indexInstruction)
{
char instruction = codeDuProgramme[indexInstruction];
IInstruction nouvelleInstruction = null;
switch (instruction)
{
case '<' :
nouvelleInstruction = new InstructionBFDeplacementMemoireGauche();
break;
case '>' :
nouvelleInstruction = new InstructionBFDeplacementMemoireDroite();
break;
case '+' :
nouvelleInstruction = new InstructionBFModifierValeurIncrementer();
break;
case '-' :
nouvelleInstruction = new InstructionBFModifierValeurDecrementer();
break;
case '.' :
nouvelleInstruction = new InstructionBFIOEcrireCaractere();
break;
case ',' :
nouvelleInstruction = new InstructionBFIOLireCaractere();
break;
case '[' :
nouvelleInstruction = new InstructionBFBoucleDebut();
debutBoucle.Push((InstructionBFBoucleDebut)nouvelleInstruction);
break;
case ']' :
if (debutBoucle.Count == 0)
{
this.Instructions = null;
throw new SyntaxErrorException();
}
nouvelleInstruction = new InstructionBFBoucleFin() {
DebutBoucle = debutBoucle.Pop()
};
break;
default:
break;
}
if (nouvelleInstruction != null)
{
nouvelleInstruction.InformationInstruction = new InformationInstruction()
{
Instruction = instruction.ToString(),
Longueur = 1,
NumeroCaractere = indexInstruction + 1
};
instructionCourante.InstructionSuivante = nouvelleInstruction;
instructionCourante = nouvelleInstruction;
}
}
instructionCourante.InstructionSuivante = new InstructionBFFinProgramme();
if (debutBoucle.Count != 0)
{
this.Instructions = null;
throw new SyntaxErrorException();
}
}
public override bool Equals(object obj)
{
IInstruction o = obj as IInstruction;
return(Instruction.Equals(this, o, Rules.DefaultRules.CoreSize));
}
protected virtual void ExecuteCopyInstruction(IInstruction instruction)
{
}
protected virtual void ExecuteDeleteInstruction(IInstruction instruction)
{
}
protected ISExpression Closure(IInstruction body, IEnvironment e, ISExpression args)
{
return(new Closure(body, e, args));
}
/// <summary>
/// Sets the instruction.
/// </summary>
/// <param name="instruction">The instruction.</param>
/// <param name="result">The result.</param>
/// <param name="operand1">The operand1.</param>
public void SetInstruction(IInstruction instruction, Operand result, Operand operand1)
{
SetInstruction(instruction, 1, (byte)((result == null) ? 0 : 1));
Result = result;
Operand1 = operand1;
}
/// <summary>
/// Sets the instruction.
/// </summary>
/// <param name="instruction">The instruction.</param>
/// <param name="code">The code.</param>
/// <param name="block">The block.</param>
/// <param name="branchHint">if set to <c>true</c> [branch hint].</param>
public void SetInstruction(IInstruction instruction, IR.ConditionCode code, BasicBlock block, bool branchHint)
{
SetInstruction(instruction, code, block);
BranchHint = branchHint;
}
public DefTypeInstruction Id(byte id)
{
_id = new LiteralInstruction(id);
return(this);
}
public Instructions_BranchLeftOrRightShould()
{
_sit = new BranchLeftOrRight();
_runtime = MockIBefungeRunTimeFactory.Create();
}
public InstructionEventArgs(IInstruction instruction)
{
_instruction = instruction;
}
public ContiInstruction(IInstruction next)
{
Next = next;
}
public bool ExistsAndActive(IInstruction instruction)
{
Debug.Assert(instruction != null, "instruction is null");
return(_instructions.ContainsKey(instruction.Id) && _instructions[instruction.Id].Active);
}
public Instructions_Discard()
{
_sit = new Discard();
_runtime = MockIBefungeRunTimeFactory.Create();
}
public static string GetInstructionEnding(IInstruction i) => i is IOneLineInstruction ? ";" : string.Empty;
public Instructions_ModuloShould()
{
_sit = new Modulo();
_runtime = MockIBefungeRunTimeFactory.Create();
}
public virtual void AppendInstruction(IInstruction instruction)
{
_instructions.Add(instruction);
}
public TaskTween(
float duration,
IInstruction <T> instruction,
Action <T> applyAction) : base(instruction, applyAction, duration)
{
}
public override void Process(IList <IInstruction> instructions, int index)
{
IInstruction instruction = instructions[index];
switch (instruction.OpCode.Value)
{
case 0x16: // Ldc_I4_0
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 0);
break;
}
case 0x17: // Ldc_I4_1
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 1);
break;
}
case 0x18: // Ldc_I4_2
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 2);
break;
}
case 0x19: // Ldc_I4_3
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 3);
break;
}
case 0x1a: // Ldc_I4_4
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 4);
break;
}
case 0x1b: // Ldc_I4_5
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 5);
break;
}
case 0x1c: // Ldc_I4_6
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 6);
break;
}
case 0x1d: // Ldc_I4_7
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 7);
break;
}
case 0x1e: // Ldc_I4_8
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, 8);
break;
}
case 0x15: // Ldc_I4_M1
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, -1);
break;
}
case 0x1f: // Ldc_I4_S
{
instructions[index] = new Instruction(OpCodes.Ldc_I4, instruction.IP, (int)((byte)instruction.Argument));
break;
}
}
}
public GetArrayInstruction Id(IInstruction id)
{
_id = id;
return(this);
}
public ElementInstruction(IInstruction start, IInstruction <T> content, IInstruction finish)
{
_start = start;
_content = content;
_finish = finish;
}
public bool Exists(IInstruction instruction)
{
Debug.Assert(instruction != null, "instruction is null");
return(_instructions.ContainsKey(instruction.Id));
}
/// <summary>
/// Construct a control flow graph out of the method body
/// </summary>
/// <param name="instructions"></param>
public ControlFlowGraph(SortedList <ushort, IInstruction> instructions)
{
// Iterate the list of instructions building a list of call graph nodes
SortedList <ushort, CallGraphNode> nodes = new SortedList <ushort, CallGraphNode>();
List <IInstruction> nodeInstructions = new List <IInstruction>();
foreach (IInstruction instruction in instructions.Values)
{
if ((instruction.IsTarget) && (nodeInstructions.Count > 0))
{
// This is the start of a block. Create the previous block
CallGraphNode callGraphNode = new CallGraphNode(nodeInstructions);
nodes.Add(callGraphNode.StartIP, callGraphNode);
nodeInstructions = new List <IInstruction>();
}
nodeInstructions.Add(instruction);
}
// Add the last node to the list
if (nodeInstructions.Count > 0)
{
CallGraphNode callGraphNode = new CallGraphNode(nodeInstructions);
nodes.Add(callGraphNode.StartIP, callGraphNode);
}
// Link the list of nodes
for (int i = 0; i < nodes.Count; i++)
{
CallGraphNode node = nodes.Values[i];
// Examine the last instruction to determine how to link this node to others
IInstruction instruction = node.Instructions[node.Instructions.Count - 1];
switch (instruction.OpCode.FlowControl)
{
case FlowControl.Branch:
// Direct branch to a new block
node.NodeType = NodeType.OneBranch;
LinkNode(node, nodes, (ushort)instruction.Argument);
break;
case FlowControl.Cond_Branch:
if (instruction.OpCode.Value == OpCodes.Switch.Value)
{
// Conditional branch to n-blocks
node.NodeType = NodeType.MultiBranch;
foreach (ushort switchTargetIp in (ushort[])instruction.Argument)
{
LinkNode(node, nodes, switchTargetIp);
}
}
else
{
// Conditional branch to two blocks
node.NodeType = NodeType.TwoBranch;
LinkNode(node, nodes, (ushort)instruction.Argument);
}
// Add the continuation link
LinkContinuationNode(node, nodes);
break;
case FlowControl.Return:
node.NodeType = NodeType.Exit;
break;
case FlowControl.Throw:
node.NodeType = NodeType.Throw;
// End of graph
break;
case FlowControl.Break:
case FlowControl.Call:
case FlowControl.Meta:
case FlowControl.Next:
#pragma warning disable 612,618
case FlowControl.Phi:
#pragma warning restore 612,618
// Add the continuation link
node.NodeType = LinkContinuationNode(node, nodes) ? NodeType.FallThrough : NodeType.ExitBlock;
break;
default:
throw new ApplicationException("Unexpected flow control type in instruction " + instruction.OpCode.Name);
}
}
_rootNode = nodes.Values[0];
_nodes = nodes;
CheckGraph();
// Remove redundancies and add in-edge information
Optimize(nodes);
IList <IGraphNode> ln = new List <IGraphNode>();
foreach (CallGraphNode n in _nodes.Values)
{
ln.Add(n);
}
PrintGraph(ln);
CheckGraph();
// Visit the graph in depth first order and label the nodes
_depthFirstSearchLast = new CallGraphNode[nodes.Count];
_depthFirstSearchFirst = new CallGraphNode[nodes.Count];
int first = 0;
int last = nodes.Count - 1;
DepthFirstTraverse(_rootNode, ref first, ref last);
// Find the immediate dominators of each node
FindImmediateDominators();
// Check the graph for reducibility
FindDerivedSequence();
// Work out the graphs back edges
DetermineBackEdges();
ResetTraversal();
StructureCases();
StructureLoops();
StructureIfs();
}
/// <summary>
/// Eliminates the common subexpressions.
/// </summary>
/// <param name="ctx">The context.</param>
private static void EliminateCommonSubexpressions(Context ctx)
{
List <AEBinExp> AEB = new List <AEBinExp>();
List <AEBinExp> tmp;
AEBinExp aeb;
for (; !ctx.EndOfInstruction; ctx.GotoNext())
{
IInstruction instruction = ctx.Instruction; // block.Instructions[i];
RegisterOperand temp = null;
bool found = false;
if ((instruction is CIL.ArithmeticInstruction) && (instruction is CIL.BinaryInstruction))
{
tmp = new List <AEBinExp>(AEB);
while (tmp.Count > 0)
{
aeb = tmp[0];
tmp.RemoveAt(0);
// Match current instruction's expression against those
// in AEB, including commutativity
if (IsCommutative(instruction))
{
//int position = aeb.Position;
found = true;
// If no variable in tuple, create a new temporary and
// insert an instruction evaluating the expression
// and assigning it to the temporary
if (aeb.Var == null)
{
// new_tmp()
AEB.Remove(aeb);
AEB.Add(new AEBinExp(aeb.Position, aeb.Operand1, aeb.Operator, aeb.Operand2, temp));
// Insert new assignment to instruction stream in block
Context inserted = ctx.InsertBefore();
switch (aeb.Operator)
{
case Operation.Add:
inserted.SetInstruction(CIL.Instruction.Get(CIL.OpCode.Add), temp, aeb.Operand1, aeb.Operand2);
break;
case Operation.Mul:
inserted.SetInstruction(CIL.Instruction.Get(CIL.OpCode.Mul), temp, aeb.Operand1, aeb.Operand2);
break;
case Operation.Or:
inserted.SetInstruction(CIL.Instruction.Get(CIL.OpCode.Or), temp, aeb.Operand1, aeb.Operand2);
break;
case Operation.Xor:
inserted.SetInstruction(CIL.Instruction.Get(CIL.OpCode.Xor), temp, aeb.Operand1, aeb.Operand2);
break;
default:
break;
}
//block.Instructions.Insert(position, inst);
//++position;
//++i;
// Replace current instruction by one that copies
// the temporary instruction
// FIXME PG:
// block.Instructions[position] = new IR.MoveInstruction(block.Instructions[position].Results[0], temp);
// ctx.SetInstruction(IR.MoveInstruction); // FIXME PG
// ctx.Result = block.Instructions[position].Results[0]; // FIXME PG
ctx.Operand1 = temp;
}
else
{
temp = (RegisterOperand)aeb.Var;
}
// FIXME PG
// block.Instructions[i] = new IR.MoveInstruction(instruction.Results[0], temp);
}
}
if (!found)
{
Operation opr = Operation.None;
if (instruction is CIL.AddInstruction)
{
opr = Operation.Add;
}
else if (instruction is CIL.MulInstruction)
{
opr = Operation.Mul;
}
else if (instruction is IR.LogicalAndInstruction)
{
opr = Operation.And;
}
// Insert new tuple
AEB.Add(new AEBinExp(ctx.Index, ctx.Operand1, opr, ctx.Operand2, null));
}
// Remove all tuples that use the variable assigned to by
// the current instruction
tmp = new List <AEBinExp>(AEB);
while (tmp.Count > 0)
{
aeb = tmp[0];
tmp.RemoveAt(0);
if (ctx.Operand1 == aeb.Operand1 || ctx.Operand2 == aeb.Operand2)
{
AEB.Remove(aeb);
}
}
}
}
}
public GetArrayInstruction Id(byte id)
{
_id = new LiteralInstruction(id);
return(this);
}
public DefTypeInstruction NumberOfFields(IInstruction numberOfFields)
{
_numberOfFields = numberOfFields;
return(this);
}
protected void PushFrame(ISchemeVM vm, IInstruction x, IEnvironment e, Stack <ISExpression> r, Stack <IFrame> s)
{
vm.S.Push(new Frame(x, e, r, s));
}
/// <summary>
/// Sets the instruction.
/// </summary>
/// <param name="instruction">The instruction.</param>
/// <param name="result">The result.</param>
public void SetInstruction(IInstruction instruction, Operand result)
{
SetInstruction(instruction, 0, 1);
Result = result;
}
public DefTypeInstruction NumberOfFields(byte numberOfFields)
{
_numberOfFields = new LiteralInstruction(numberOfFields);
return(this);
}
/// <summary>
/// Sets the instruction.
/// </summary>
/// <param name="instruction">The instruction.</param>
/// <param name="result">The result.</param>
/// <param name="operand1">The operand1.</param>
/// <param name="operand2">The operand2.</param>
/// <param name="operand3">The operand3.</param>
public void SetInstruction(IInstruction instruction, Operand result, Operand operand1, Operand operand2, Operand operand3)
{
SetInstruction(instruction, 3, (byte)((result == null) ? 0 : 1));
Result = result;
Operand1 = operand1;
Operand2 = operand2;
Operand3 = operand3;
}
public DefTypeInstruction Id(IInstruction id)
{
_id = id;
return(this);
}
