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