public override bool Matches(MatcherData data)
{
Instruction next = data.Code.Peek();
Instruction target = next.GetBranchTarget();
return(target != null && target.Offset > next.Offset);
}
public bool TryGetMatcherData(string referenceName, int matcherIndex, out MatcherData matcherData)
{
matcherData = _statMatchersList
.Where(r => r.ReferenceNames.Contains(referenceName))
.SelectMany(r => r.Data)
.ElementAtOrDefault(matcherIndex);
return(matcherData != null);
}
public override void Build(CodeWriter writer, MatcherData data)
{
data.Code.Dequeue();
if (data.Stack.Any())
{
writer.WriteLine($"return {data.Stack.Pop()};");
}
//else writer.WriteLine("return;");
}
public override bool Matches(MatcherData data)
{
Instruction instruction = data.Code.Peek();
return(instruction.OpCode == OpCodes.Ldarg_0 ||
instruction.OpCode == OpCodes.Ldarg_1 ||
instruction.OpCode == OpCodes.Ldarg_2 ||
instruction.OpCode == OpCodes.Ldarg_3 ||
instruction.OpCode == OpCodes.Ldarg_S);
}
public string ExpandsCorrectly(string inputRegex)
{
var inputData = new MatcherData(inputRegex, new ModifierBuilder());
var statMatchers = MockStatMatchers(true, inputData);
var sut = CreateSut(statMatchers);
var data = sut.First();
return(data.Regex);
}
public override bool Matches(MatcherData data)
{
Instruction next = data.Code.Peek();
return(next.OpCode == OpCodes.Dup ||
next.OpCode == OpCodes.Pop ||
next.OpCode == OpCodes.Ldstr ||
next.OpCode == OpCodes.Starg ||
next.OpCode == OpCodes.Starg_S);
}
public override bool Matches(MatcherData data)
{
Instruction next = data.Code.Peek();
if (data.Code.Any(i => i.Operand == next))
{
return(true); // Found a branch pointing to this instruction
}
return(false);
}
public override bool Matches(MatcherData data)
{
Instruction next = data.Code.Peek();
return(next.OpCode == OpCodes.Add ||
next.OpCode == OpCodes.Sub ||
next.OpCode == OpCodes.Mul ||
next.OpCode == OpCodes.Div ||
next.OpCode == OpCodes.Cgt ||
next.OpCode == OpCodes.Ceq ||
next.OpCode == OpCodes.Clt);
}
public override bool Matches(MatcherData data)
{
Instruction next = data.Code.Peek();
return(next.OpCode == OpCodes.Ldc_I4_0 ||
next.OpCode == OpCodes.Ldc_I4_1 ||
next.OpCode == OpCodes.Ldc_I4_2 ||
next.OpCode == OpCodes.Ldc_I4_3 ||
next.OpCode == OpCodes.Ldc_I4_4 ||
next.OpCode == OpCodes.Ldc_I4_5 ||
next.OpCode == OpCodes.Ldc_I4_6 ||
next.OpCode == OpCodes.Ldc_I4_7 ||
next.OpCode == OpCodes.Ldc_I4_8 ||
next.OpCode == OpCodes.Ldc_I4_S);
}
public override void Build(CodeWriter writer, MatcherData data)
{
Instruction instruction = data.Code.Dequeue();
int val;
if (instruction.OpCode == OpCodes.Ldc_I4_0)
{
val = 0;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_1)
{
val = 1;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_2)
{
val = 2;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_3)
{
val = 3;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_4)
{
val = 4;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_5)
{
val = 5;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_6)
{
val = 6;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_7)
{
val = 7;
}
else if (instruction.OpCode == OpCodes.Ldc_I4_8)
{
val = 8;
}
else
{
val = Convert.ToInt32(instruction.Operand);
}
data.Stack.Push(val.ToString());
}
public string ExpandsReferencesRecursively(string inputRegex)
{
var inputData = new MatcherData(inputRegex, new ModifierBuilder());
var statMatchers = MockStatMatchers(true, inputData);
var referencedRegexes = Mock.Of <IReferencedRegexes>(r =>
r.GetRegexes("Matchers1") == new[] { "0+", "[1-9]" } &&
r.GetRegexes("Matchers2") == new[] { "a" } &&
r.GetRegexes("Matchers3") == new[] { "({Matchers2})", "c", "d ({Matchers1}) ({Matchers2})" } &&
r.GetRegexes("Matchers4") == new[] { "({Matchers2})" } &&
r.GetRegexes("Matchers5") == new[] { "({Matchers1})", "({Matchers2})", "({Matchers3})", "({Matchers4})" } &&
r.GetRegexes("Matchers6") == new[] { "({Matchers2}) ({Matchers2}) ({Matchers2}) ({Matchers2})" });
var sut = CreateSut(statMatchers, referencedRegexes);
var data = sut.First();
return(data.Regex);
}
public override void Build(CodeWriter writer, MatcherData data)
{
Instruction next = data.Code.Dequeue();
if (next.OpCode == OpCodes.Dup)
{
data.Stack.Push(data.Stack.Peek());
}
else if (next.OpCode == OpCodes.Pop)
{
writer.WriteLine($"{data.Stack.Pop()};");
}
else if (next.OpCode == OpCodes.Ldstr)
{
data.Stack.Push($"\"{data.Code.Dequeue().Operand as string}\"");
}
else if (next.OpCode == OpCodes.Starg || next.OpCode == OpCodes.Starg_S)
{
writer.WriteLine($"{(next.Operand as ParameterDefinition).Name} = {data.Stack.Pop()};");
}
}
private ActionResult FindNextPage(bool isResult = false)
{
MatcherData matcherData = SesionMatcherData;
if (matcherData.Men == null)
{
return(RedirectToAction("Men"));
}
else if (matcherData.Women == null)
{
return(RedirectToAction("Women"));
}
else if (isResult)
{
matcherData.Matched = MatcherPeople.MatchCouple(matcherData.Men, matcherData.Women);
return(View(matcherData));
}
else
{
return(RedirectToAction("Result"));
}
}
private void MatchSucceedUIData(List <Matcher> matchers)
{
DataManager clientData = DataManager.GetInstance();
allMatchers = matchers;
clientData.SetMatchers(allMatchers);
long id = clientData.GetPlayerAccountId();
MatchSide myselfSide = matchers.Find(p => p.playerId == id).side;
bool myselfReady = matchers.Find(p => p.playerId == id).ready;
view.intoGameButton.interactable = !myselfReady;
List <MatcherData> friendData = new List <UI.FightMatchController.MatcherData>();
List <MatcherData> enemyData = new List <UI.FightMatchController.MatcherData>();
List <Matcher> friends = matchers.FindAll(p => p.side == myselfSide);
List <Matcher> enemys = matchers.FindAll(p => p.side != myselfSide);
long myId = DataManager.GetInstance().GetPlayerId();
foreach (Matcher friend in friends)
{
MatcherData data = new MatcherData(friend.name, friend.portrait, friend.ready, friend.playerId == myId, friend.playerId);
friendData.Add(data);
}
foreach (Matcher enemy in enemys)
{
MatcherData data = new MatcherData(enemy.name, enemy.portrait, enemy.ready, false, enemy.playerId);
enemyData.Add(data);
}
view.friendDatas = friendData;
view.enemyDatas = enemyData;
view.InitSucceedItem();
}
public override void Build(CodeWriter writer, MatcherData data)
{
string b = data.Stack.Pop();
string a = data.Stack.Pop();
string op = "";
Instruction instruction = data.Code.Dequeue();
if (instruction.OpCode == OpCodes.Add)
{
op = "+";
}
else if (instruction.OpCode == OpCodes.Sub)
{
op = "-";
}
else if (instruction.OpCode == OpCodes.Mul)
{
op = "*";
}
else if (instruction.OpCode == OpCodes.Div)
{
op = "/";
}
else if (instruction.OpCode == OpCodes.Cgt)
{
op = ">";
}
else if (instruction.OpCode == OpCodes.Ceq)
{
op = "==";
}
else if (instruction.OpCode == OpCodes.Clt)
{
op = "<";
}
data.Stack.Push($"({a} {op} {b})");
}
public override void Build(CodeWriter writer, MatcherData data)
{
int arg;
Instruction i = data.Code.Dequeue();
if (i.OpCode == OpCodes.Ldarg_0)
{
arg = 0;
}
else if (i.OpCode == OpCodes.Ldarg_1)
{
arg = 1;
}
else if (i.OpCode == OpCodes.Ldarg_2)
{
arg = 2;
}
else if (i.OpCode == OpCodes.Ldarg_3)
{
arg = 3;
}
else
{
arg = (int)i.Operand;
}
if (data.Method.HasThis)
{
arg--;
}
if (arg == -1)
{
data.Stack.Push("this");
}
else
{
data.Stack.Push(data.Method.Parameters[arg].Name);
}
}
public override void Build(CodeWriter writer, MatcherData data)
{
Instruction call = data.Code.Dequeue();
MethodReference reference = call.Operand as MethodReference;
// Get passed parameters
string[] args = new string[reference.Parameters.Count];
for (int i = 0; i < reference.Parameters.Count; i++)
{
args[i] = data.Stack.Pop();
}
// TODO: Come up with a better naming scheme
string built = $"{data.Namer.GetName(reference.DeclaringType)}.{reference.Name}({string.Join(", ", args)})";
if (reference.ReturnType.FullName == "System.Void")
{
writer.WriteLine($"{built};");
}
else
{
data.Stack.Push(built);
}
}
public abstract bool Matches(MatcherData data);
public override void Build(CodeWriter writer, MatcherData data)
{
Instruction next = data.Code.Peek();
Instruction branch = data.Code.LastOrDefault(i => i.Operand == next);
if (branch != null)
{
List <Instruction> loopCode = new List <Instruction>();
while (data.Code.Peek() != branch)
{
loopCode.Add(data.Code.Dequeue());
}
CodeBuilder builder = new CodeBuilder(data.Method, data.Namer, loopCode);
builder.Data.Stack = data.Stack;
writer.WriteLine("do");
writer.WriteLine("{");
writer.AddIndent();
builder.Build(writer);
writer.RemoveIndent();
writer.WriteLine("}");
data.Code.Dequeue();
if (branch.OpCode == OpCodes.Brtrue || branch.OpCode == OpCodes.Brtrue_S)
{
writer.WriteLine($"while ({data.Stack.Pop()});");
}
else if (branch.OpCode == OpCodes.Brfalse || branch.OpCode == OpCodes.Brfalse_S)
{
writer.WriteLine($"while (!{data.Stack.Pop()});");
}
else
{
string b = data.Stack.Pop();
string a = data.Stack.Pop();
if (branch.OpCode == OpCodes.Beq || branch.OpCode == OpCodes.Beq_S)
{
writer.WriteLine($"while ({a} == {b});");
}
else if (branch.OpCode == OpCodes.Bne_Un || branch.OpCode == OpCodes.Bne_Un_S)
{
writer.WriteLine($"while ({a} != {b});");
}
else if (branch.OpCode == OpCodes.Blt || branch.OpCode == OpCodes.Blt_S || branch.OpCode == OpCodes.Blt_Un || branch.OpCode == OpCodes.Blt_Un_S)
{
writer.WriteLine($"while ({a} < {b});");
}
else if (branch.OpCode == OpCodes.Ble || branch.OpCode == OpCodes.Ble_S || branch.OpCode == OpCodes.Ble_Un || branch.OpCode == OpCodes.Ble_Un_S)
{
writer.WriteLine($"while ({a} <= {b});");
}
else if (branch.OpCode == OpCodes.Bgt || branch.OpCode == OpCodes.Bgt_S || branch.OpCode == OpCodes.Bgt_Un || branch.OpCode == OpCodes.Bgt_Un_S)
{
writer.WriteLine($"while ({a} > {b});");
}
else if (branch.OpCode == OpCodes.Bge || branch.OpCode == OpCodes.Bge_S || branch.OpCode == OpCodes.Bge_Un || branch.OpCode == OpCodes.Bge_Un_S)
{
writer.WriteLine($"while ({a} >= {b});");
}
}
}
}
public override void Build(CodeWriter writer, MatcherData data)
{
data.Stack.Push($"!{data.Stack.Pop()}");
data.Code.Dequeue();
}
public override bool Matches(MatcherData data)
{
return(data.Code.Peek().OpCode == OpCodes.Ret);
}
private static string GetRemaining(MatcherData matcherData, string stat, Match match)
{
return(stat.Substring(0, match.Index)
+ match.Result(matcherData.MatchSubstitution)
+ stat.Substring(match.Index + match.Length));
}
public override void Build(CodeWriter writer, MatcherData data)
{
Instruction branch = data.Code.Dequeue();
Instruction target = branch.GetBranchTarget();
if (target != null)
{
// Check if else
//if ()
if (branch.OpCode == OpCodes.Brtrue || branch.OpCode == OpCodes.Brtrue_S)
{
writer.WriteLine($"if (!{data.Stack.Pop()})");
}
else if (branch.OpCode == OpCodes.Brfalse || branch.OpCode == OpCodes.Brfalse_S)
{
writer.WriteLine($"if ({data.Stack.Pop()})");
}
else
{
string b = data.Stack.Pop();
string a = data.Stack.Pop();
if (branch.OpCode == OpCodes.Beq || branch.OpCode == OpCodes.Beq_S)
{
writer.WriteLine($"if ({a} != {b})");
}
else if (branch.OpCode == OpCodes.Bne_Un || branch.OpCode == OpCodes.Bne_Un_S)
{
writer.WriteLine($"if ({a} == {b})");
}
else if (branch.OpCode == OpCodes.Blt || branch.OpCode == OpCodes.Blt_S || branch.OpCode == OpCodes.Blt_Un || branch.OpCode == OpCodes.Blt_Un_S)
{
writer.WriteLine($"if ({a} >= {b})");
}
else if (branch.OpCode == OpCodes.Ble || branch.OpCode == OpCodes.Ble_S || branch.OpCode == OpCodes.Ble_Un || branch.OpCode == OpCodes.Ble_Un_S)
{
writer.WriteLine($"if ({a} > {b})");
}
else if (branch.OpCode == OpCodes.Bgt || branch.OpCode == OpCodes.Bgt_S || branch.OpCode == OpCodes.Bgt_Un || branch.OpCode == OpCodes.Bgt_Un_S)
{
writer.WriteLine($"if ({a} <= {b})");
}
else if (branch.OpCode == OpCodes.Bge || branch.OpCode == OpCodes.Bge_S || branch.OpCode == OpCodes.Bge_Un || branch.OpCode == OpCodes.Bge_Un_S)
{
writer.WriteLine($"if ({a} < {b})");
}
}
writer.WriteLine("{");
writer.AddIndent();
List <Instruction> loopCode = new List <Instruction>();
while (data.Code.Peek() != target)
{
loopCode.Add(data.Code.Dequeue());
}
CodeBuilder builder = new CodeBuilder(data.Method, data.Namer, loopCode);
builder.Data.Stack = data.Stack;
builder.Build(writer);
writer.RemoveIndent();
writer.WriteLine("}");
}
}
public ActionResult Result()
{
MatcherData matcherData = SesionMatcherData;
return(FindNextPage(true));
}
public abstract void Build(CodeWriter writer, MatcherData data);