public static void WriteFormEnum(CodeNamespace n) { // For those architectures that don't have // instruction forms. if (RegisteredForms.Count > 0) { CodeTypeDeclaration decl = new CodeTypeDeclaration(StaticTypeReferences.InstructionFormClassName); decl.Attributes = MemberAttributes.Assembly; decl.IsEnum = true; CodeTypeReference enumType = null; if (RegisteredForms.Count < ushort.MaxValue) { if (RegisteredForms.Count < byte.MaxValue) { enumType = StaticTypeReferences.Byte; } else { enumType = StaticTypeReferences.UShort; } } else { throw new Exception("Yikes that IS a lot of forms!"); } decl.BaseTypes.Add(enumType); foreach (string f in RegisteredForms.Keys) { decl.Members.Add(new CodeMemberField(enumType, f)); } n.Types.Add(decl); } }
protected override void AddDefaultImports(CodeNamespace n) { n.Imports.Add(new CodeNamespaceImport("std.conv")); n.Imports.Add(new CodeNamespaceImport("std.string")); n.Imports.Add(new CodeNamespaceImport(RootNamespace + ".Core")); if (n.Name != RootNamespace) { n.Imports.Add(new CodeNamespaceImport(RootNamespace + ".Instructions.Core")); } string cun = n.Name; string filNam; if (cun != RootNamespace) { int li = cun.LastIndexOf('.'); filNam = cun.Substring(li + 1); cun = cun.Substring(0, li) + ".Instructions"; } else { cun += ".Instructions"; filNam = "Core"; } n.Name = cun + "." + filNam; GeneratedNamespaces.Add(n.Name); }
protected override void AddDefaultImports(CodeNamespace n) { n.Imports.Add(new CodeNamespaceImport("System")); if (n.Name != RootNamespace) { n.Imports.Add(new CodeNamespaceImport(RootNamespace)); } }
public void AddRange(CodeNamespace[] value) { if (value == null) { throw new ArgumentNullException("value"); } for (int i = 0; i < value.Length; i++) { Add(value[i]); } }
public virtual CodeNamespace GetNamespace(string name) { CodeNamespace nm; if (!Namespaces.TryGetValue(name, out nm)) { CodeCompileUnit cu = new CodeCompileUnit(); CodeNamespace n = new CodeNamespace(name); AddDefaultImports(n); cu.Namespaces.Add(n); CompileUnits.Add(cu); Namespaces[name] = n; nm = n; } return nm; }
public void Write(CodeNamespace n) { CodeTypeDeclaration decl = new CodeTypeDeclaration(Name); decl.TypeAttributes = TypeAttributes.Public; decl.Attributes = MemberAttributes.Public; decl.IsEnum = true; if (BaseTypeID != -1) { decl.BaseTypes.Add(FieldTypeRegistry.Fields[BaseTypeID].CodeType); } if (Documentation != null) { decl.Documentation.Add(new CodeDocumentationSummaryNode(Documentation)); } foreach (var m in Members) { CodeMemberField fld = new CodeMemberField(decl.Name, m.Name); if (m.Documentation != null) fld.Documentation.Add(new CodeDocumentationSummaryNode(m.Documentation)); if (m.Value != null) { if (m.ShowValueAsHex) { fld.InitExpression = new CodePrimitiveExpression(m.Value.Value); ((CodePrimitiveExpression)fld.InitExpression).PrintAsHex = true; } else { fld.InitExpression = new CodePrimitiveExpression((int)m.Value.Value); } } decl.Members.Add(fld); } n.Types.Add(decl); }
protected override void GenerateNamespaceStart(CodeNamespace ns) { base.Output.Write("module "); base.Output.Write(ns.Name); base.Output.WriteLine(";"); base.Output.WriteLine(); }
protected override void GenerateNamespaceEnd(CodeNamespace ns) { }
public void Insert(int index, CodeNamespace value) { List.Insert(index, value); }
public int IndexOf(CodeNamespace value) { return List.IndexOf(value); }
protected override void GenerateNamespaceStart(CodeNamespace ns) { TextWriter output = base.Output; string name = ns.Name; if (name != null && name.Length != 0) { output.Write("namespace "); output.Write(this.GetSafeName(name)); this.OutputStartBrace(); base.Indent++; } }
protected abstract void AddDefaultImports(CodeNamespace n);
public static void WritePatterns(CodeNamespace nmspc) { if (Patterns.Count > 0) { CodeTypeDeclaration td = new CodeTypeDeclaration("BitPatterns"); td.Attributes = MemberAttributes.Static; td.Attributes |= MemberAttributes.Public; td.TypeAttributes = TypeAttributes.Class; td.TypeAttributes |= TypeAttributes.Public; // Deal with aliases. Dictionary<BitPattern, bool> pats = new Dictionary<BitPattern, bool>(); foreach (BitPattern pat in Patterns.Values) { if (!pats.ContainsKey(pat)) { pat.Write(td); pats[pat] = true; } } nmspc.Types.Add(td); } }
protected override void GenerateNamespaceEnd(CodeNamespace ns) { string name = ns.Name; if (name != null && name.Length != 0) { base.Indent--; base.Output.WriteLine("}"); } }
public void CopyTo(CodeNamespace[] array, int index) { List.CopyTo(array, index); }
public void Remove(CodeNamespace value) { List.Remove(value); }
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); }
public CodeNamespaceCollection(CodeNamespace[] value) { AddRange(value); }
// // Methods // public int Add(CodeNamespace value) { return List.Add(value); }
public static void WriteEnums(CodeNamespace n) { foreach (var e in mEntries) { e.Write(n); } }
public bool Contains(CodeNamespace value) { return List.Contains(value); }