protected override void GenerateMethod(CodeMemberMethod method, CodeTypeDeclaration declaration)
{
if (base.IsCurrentDelegate || base.IsCurrentEnum)
{
return;
}
TextWriter output = base.Output;
MemberAttributes attributes = method.Attributes;
if (!base.IsCurrentInterface)
{
if (method.PrivateImplementationType == null)
{
this.OutputMemberAccessModifier(attributes);
this.OutputVTableModifier(attributes);
this.OutputMemberScopeModifier(attributes);
}
}
else
{
this.OutputVTableModifier(attributes);
}
this.OutputType(method.ReturnType);
output.Write(' ');
CodeTypeReference privateImplementationType = method.PrivateImplementationType;
if (privateImplementationType != null)
{
output.Write(privateImplementationType.BaseType);
output.Write('.');
}
output.Write(this.GetSafeName(method.Name));
this.GenerateGenericsParameters(method.TypeParameters);
output.Write('(');
this.OutputParameters(method.Parameters);
output.Write(')');
this.GenerateGenericsConstraints(method.TypeParameters);
if (CSharpCodeGenerator.IsAbstract(attributes) || declaration.IsInterface)
{
output.WriteLine(';');
}
else
{
this.OutputStartBrace();
base.Indent++;
base.GenerateStatements(method.Statements);
base.Indent--;
output.WriteLine('}');
}
}
public void Write(CodeMemberMethod mthd)
{
if (Operations.Count == 1 && Operations[0].OpType == BitPatternPieceOperation.OperationType.PatternInvoke)
{
mthd.Statements.Add(Operations[0].GetExpression());
}
else
{
CodeExpression expr = null;
uint curLength = 0;
for(int i = Operations.Count - 1; i >= 0; i--)
{
if (expr == null)
{
expr = Utils.WrapInCast(Operations[i].GetExpression(), (byte)TotalLength);
}
else
{
expr = new CodeBinaryOperatorExpression(
Utils.WrapInCast(
new CodeBinaryOperatorExpression(
Utils.WrapInCast(Operations[i].GetExpression(), (byte)TotalLength),
CodeBinaryOperatorType.ShiftLeft,
new CodePrimitiveExpression((int)curLength)
),
(byte)TotalLength
),
CodeBinaryOperatorType.BitwiseOr,
expr
);
}
curLength += Operations[i].Length;
}
expr = Utils.WrapInCast(expr, (byte)TotalLength);
CodeExpression stat = null;
switch (TotalLength)
{
case 0:
stat = null;
break;
case 8:
stat = new CodeMethodInvokeExpression(
StaticTypeReferences.Emit_StreamArg,
"WriteImm8",
Utils.WrapInCast(expr, 8)
);
break;
case 16:
stat = new CodeMethodInvokeExpression(
StaticTypeReferences.Emit_StreamArg,
"WriteImm16",
Utils.WrapInCast(expr, 16)
);
break;
case 32:
stat = new CodeMethodInvokeExpression(
StaticTypeReferences.Emit_StreamArg,
"WriteImm32",
Utils.WrapInCast(expr, 32)
);
break;
default:
throw new Exception("Unknown total size for a bit pattern piece! The total number of bits must be 8, 16 or 32!");
}
if (stat != null)
{
mthd.Statements.Add(stat);
}
}
}
public void Write(CodeTypeDeclaration td)
{
CodeMemberMethod mthd = new CodeMemberMethod();
mthd.Name = Name;
mthd.Attributes = MemberAttributes.Public;
mthd.Attributes |= MemberAttributes.Static;
mthd.Parameters.Add(new CodeParameterDeclarationExpression(StaticTypeReferences.Stream, StaticTypeReferences.Emit_StreamArgName));
foreach (BitPatternArgument arg in Args)
{
CodeTypeReference pt = null;
if (arg.Size <= 8)
pt = StaticTypeReferences.Byte;
else if (arg.Size <= 16)
pt = StaticTypeReferences.UShort;
else if (arg.Size <= 32)
pt = StaticTypeReferences.UInt;
else if (arg.Size <= 64)
pt = StaticTypeReferences.ULong;
else
throw new Exception("Geeze, that's a giant argument!");
mthd.Parameters.Add(new CodeParameterDeclarationExpression(pt, arg.Name));
}
foreach (BitPatternPiece pc in Pieces)
{
pc.Write(mthd);
}
td.Members.Add(mthd);
}
public void Write(string outDir, CodeNamespace nmspc)
{
ExpandForms();
EvaluateOverrides();
bool lonely = FinalForms.Count == 1;
CodeTypeDeclaration td = new CodeTypeDeclaration(FileName);
td.Attributes = MemberAttributes.Final;
td.Attributes |= MemberAttributes.Public;
td.IsClass = true;
td.BaseTypes.Add(StaticTypeReferences.Instruction);
td.Documentation.Add(new CodeDocumentationSummaryNode(LinesOfDocumentation));
foreach (InstructionForm f in FinalForms)
{
f.RequestFields();
}
foreach (var v in FieldDeclarations)
{
td.Members.Add(v);
}
foreach (InstructionForm f in FinalForms)
{
f.WriteConstructors(td, FileName);
}
CodeMemberMethod mth = new CodeMemberMethod();
mth.Documentation.AddRange(
new CodeDocumentationSummaryNode("Write this instruction to a stream."),
new CodeDocumentationParameterNode(StaticTypeReferences.Emit_StreamArgName, "The stream to write to.")
);
mth.Name = "Emit";
mth.Parameters.Add(new CodeParameterDeclarationExpression(StaticTypeReferences.Stream, StaticTypeReferences.Emit_StreamArgName));
mth.Attributes = MemberAttributes.Public;
mth.Attributes |= MemberAttributes.Override;
mth.Attributes |= MemberAttributes.Sealed;
mth.ReturnType = StaticTypeReferences.Void;
CodeSwitchStatement instructionFormSwitch = null;
if (!lonely)
{
instructionFormSwitch = new CodeSwitchStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "InstructionForm"));
mth.Statements.Add(instructionFormSwitch);
}
foreach (InstructionForm f in FinalForms)
{
if (NeedsEmission(f))
{
CodeScopeStatement con = new CodeScopeStatement();
if (lonely)
{
mth.Statements.Add(con);
}
else
{
CodeCaseStatement cas = new CodeCaseStatement(
new CodeFieldReferenceExpression(StaticTypeReferences.InstructionFormExpression, f.GetInstructionCaseString())
);
cas.Statements.Add(con);
cas.Statements.Add(new CodeBreakStatement());
instructionFormSwitch.Cases.Add(cas);
}
f.WriteEmit(con, false);
}
}
if (!lonely)
{
CodeDefaultCaseStatement defStat = new CodeDefaultCaseStatement();
defStat.Statements.Add(
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
StaticTypeReferences.Exception,
new CodePrimitiveExpression("Unknown Instruction Form!")
)
)
);
instructionFormSwitch.Cases.Add(defStat);
}
td.Members.Add(mth);
instructionFormSwitch = null;
FormsEmitted = new Dictionary<InstructionArgSet, bool>();
mth = new CodeMemberMethod();
bool hasSyntax = StaticTypeReferences.AssemblySyntaxClassName != null;
if (hasSyntax)
{
mth.Documentation.AddRange(
new CodeDocumentationSummaryNode(
"Get a string representation of this instruction in the",
"specified assembly syntax."
),
new CodeDocumentationParameterNode(StaticTypeReferences.ToString_SyntaxArgName, "The syntax to get the string representation in.")
);
}
else
{
mth.Documentation.Add(new CodeDocumentationSummaryNode("Get a string representation of this instruction."));
}
mth.Name = "ToString";
mth.Attributes = MemberAttributes.Public;
mth.Attributes |= MemberAttributes.Override;
mth.Attributes |= MemberAttributes.Sealed;
mth.ReturnType = StaticTypeReferences.String;
if (!hasSyntax)
{
if (!lonely)
{
instructionFormSwitch = new CodeSwitchStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "InstructionForm"));
mth.Statements.Add(instructionFormSwitch);
}
foreach (InstructionForm f in FinalForms)
{
if (NeedsEmission(f))
{
CodeScopeStatement con = new CodeScopeStatement();
if (lonely)
{
mth.Statements.Add(con);
}
else
{
CodeCaseStatement cas = new CodeCaseStatement(
new CodeFieldReferenceExpression(
StaticTypeReferences.InstructionFormExpression,
f.GetInstructionCaseString()
)
);
cas.Statements.Add(con);
instructionFormSwitch.Cases.Add(cas);
}
f.WriteToString(con);
}
}
if (!lonely)
{
CodeDefaultCaseStatement defStat = new CodeDefaultCaseStatement();
defStat.Statements.Add(
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
StaticTypeReferences.Exception,
new CodePrimitiveExpression("Unknown Instruction Form!")
)
)
);
instructionFormSwitch.Cases.Add(defStat);
}
}
else
{
mth.Parameters.Add(new CodeParameterDeclarationExpression(StaticTypeReferences.AssemblySyntax, StaticTypeReferences.ToString_SyntaxArgName));
CodeSwitchStatement sw = new CodeSwitchStatement(StaticTypeReferences.ToString_SyntaxArg);
mth.Statements.Add(sw);
CodeCaseStatement cs = new CodeCaseStatement(
new CodeFieldReferenceExpression(
StaticTypeReferences.AssemblySyntaxExpression,
"NASM"
)
);
if (!lonely)
{
instructionFormSwitch = new CodeSwitchStatement(new CodeFieldReferenceExpression(new CodeThisReferenceExpression(), "InstructionForm"));
cs.Statements.Add(instructionFormSwitch);
}
foreach (InstructionForm f in FinalForms)
{
if (NeedsEmission(f))
{
CodeScopeStatement con = new CodeScopeStatement();
if (lonely)
{
cs.Statements.Add(con);
}
else
{
CodeCaseStatement cas = new CodeCaseStatement(
new CodeFieldReferenceExpression(StaticTypeReferences.InstructionFormExpression, f.GetInstructionCaseString())
);
cas.Statements.Add(con);
instructionFormSwitch.Cases.Add(cas);
}
f.WriteToString(con);
}
}
if (!lonely)
{
CodeDefaultCaseStatement defStat = new CodeDefaultCaseStatement();
defStat.Statements.Add(
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
StaticTypeReferences.Exception,
new CodePrimitiveExpression("Unknown Instruction Form!")
)
)
);
instructionFormSwitch.Cases.Add(defStat);
}
sw.Cases.Add(cs);
cs = new CodeCaseStatement(
new CodeFieldReferenceExpression(
StaticTypeReferences.AssemblySyntaxExpression,
"GAS"
)
);
sw.Cases.Add(cs);
CodeDefaultCaseStatement def = new CodeDefaultCaseStatement();
def.Statements.Add(
new CodeThrowExceptionStatement(
new CodeObjectCreateExpression(
StaticTypeReferences.Exception,
new CodePrimitiveExpression("Unknown Instruction Form!")
)
)
);
sw.Cases.Add(def);
}
td.Members.Add(mth);
nmspc.Types.Add(td);
}
