string CreateCode(INode node, IOutputAstVisitor outputVisitor)
{
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
node.AcceptVisitor(outputVisitor, null);
}
return(outputVisitor.Text);
}
public override string AddBaseTypeToClass(string existingCode, IClass targetClass, IClass newBaseType)
{
NR.IParser parser = ParseFile(null, existingCode);
if (parser == null)
{
return(null);
}
AddTypeToBaseTypesVisitor addTypeToBaseTypesVisitor = new AddTypeToBaseTypesVisitor(targetClass, newBaseType);
parser.CompilationUnit.AcceptVisitor(addTypeToBaseTypesVisitor, null);
// now use an output visitor for the appropriate language (based on
// extension of the existing code file) to format the new interface.
IOutputAstVisitor output = GetOutputVisitor();
// run the output visitor with the specials inserter to insert comments
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(), output)) {
parser.CompilationUnit.AcceptVisitor(output, null);
}
parser.Dispose();
if (output.Errors.Count > 0)
{
ShowSourceCodeErrors(null, output.Errors.ErrorOutput);
return(null);
}
return(output.Text);
}
public override void Run()
{
IViewContent content = WorkbenchSingleton.Workbench.ActiveViewContent;
if (content != null && content.PrimaryFileName != null && content is IEditable)
{
IParser p = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(((IEditable)content).Text));
p.Parse();
if (p.Errors.Count > 0)
{
MessageService.ShowError("${res:ICSharpCode.SharpDevelop.Commands.Convert.CorrectSourceCodeErrors}\n" + p.Errors.ErrorOutput);
return;
}
ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor output = new ICSharpCode.NRefactory.PrettyPrinter.CSharpOutputVisitor();
List <ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials;
PreprocessingDirective.VBToCSharp(specials);
IAstVisitor v = new VBNetToCSharpConvertVisitor(ParserService.CurrentProjectContent,
ParserService.GetParseInformation(content.PrimaryFileName));
v.VisitCompilationUnit(p.CompilationUnit, null);
using (SpecialNodesInserter.Install(specials, output)) {
output.VisitCompilationUnit(p.CompilationUnit, null);
}
FileService.NewFile("Generated.cs", output.Text);
}
}
private static string GenerateCode(string sourceCode, SupportedLanguage language)
{
using (IParser parser = ParserFactory.CreateParser(language, new StringReader(sourceCode)))
{
parser.Parse();
if (parser.Errors.Count == 0)
{
IList <ISpecial> savedSpecialsList = new ISpecial[0];
IOutputAstVisitor targetVisitor;
if (language == SupportedLanguage.CSharp)
{
targetVisitor = new VBNetOutputVisitor();
}
else
{
targetVisitor = new CSharpOutputVisitor();
}
using (SpecialNodesInserter.Install(savedSpecialsList, targetVisitor))
{
parser.CompilationUnit.AcceptVisitor(targetVisitor, null);
}
return(targetVisitor.Text);
}
StringBuilder errorBuilder = new StringBuilder();
return(parser.Errors.ErrorOutput);
}
}
public override void Run()
{
IWorkbenchWindow window = WorkbenchSingleton.Workbench.ActiveWorkbenchWindow;
if (window != null && window.ViewContent is IEditable)
{
IParser p = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(((IEditable)window.ViewContent).Text));
p.Parse();
if (p.Errors.Count > 0)
{
MessageService.ShowError("${res:ICSharpCode.SharpDevelop.Commands.Convert.CorrectSourceCodeErrors}\n" + p.Errors.ErrorOutput);
return;
}
VBNetOutputVisitor vbv = new VBNetOutputVisitor();
List <ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials;
PreprocessingDirective.CSharpToVB(specials);
new CSharpToVBNetConvertVisitor().VisitCompilationUnit(p.CompilationUnit, null);
using (SpecialNodesInserter.Install(specials, vbv)) {
vbv.VisitCompilationUnit(p.CompilationUnit, null);
}
FileService.NewFile("Generated.VB", "VBNET", vbv.Text);
}
}
void VB2CS(string input, string expectedOutput)
{
SnippetParser parser = new SnippetParser(SupportedLanguage.VBNet);
INode node = parser.Parse(input);
// parser.Errors.ErrorOutput contains syntax errors, if any
Assert.IsNotNull(node);
Assert.AreEqual("", parser.Errors.ErrorOutput);
// parser.Specials is the list of comments, preprocessor directives etc.
PreprocessingDirective.VBToCSharp(parser.Specials);
// Convert VB.NET constructs to C#:
node.AcceptVisitor(new VBNetConstructsConvertVisitor(), null);
node.AcceptVisitor(new ToCSharpConvertVisitor(), null);
CSharpOutputVisitor output = new CSharpOutputVisitor();
using (SpecialNodesInserter.Install(parser.Specials, output))
{
node.AcceptVisitor(output, null);
}
// output.Errors.ErrorOutput contains conversion errors/warnings, if any
// output.Text contains the converted code
Assert.AreEqual("", output.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput, output.Text);
}
void GenerateCode(IOutputAstVisitor outputVisitor)
{
// re-insert the comments we saved from the parser into the output
using (SpecialNodesInserter.Install(savedSpecialsList, outputVisitor)) {
astView.Unit.AcceptVisitor(outputVisitor, null);
}
codeTextBox.Text = outputVisitor.Text.Replace("\t", " ");
}
void TestProgram(SupportedLanguage sourceLanguage, string sourceCode, string expectedOutput)
{
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(projectContentRegistry.Mscorlib);
pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("System.Windows.Forms", "System.Windows.Forms"));
if (sourceLanguage == SupportedLanguage.VBNet)
{
pc.ReferencedContents.Add(projectContentRegistry.GetProjectContentForReference("Microsoft.VisualBasic", "Microsoft.VisualBasic"));
pc.DefaultImports = new DefaultUsing(pc);
pc.DefaultImports.Usings.Add("System");
pc.DefaultImports.Usings.Add("Microsoft.VisualBasic");
}
pc.Language = sourceLanguage == SupportedLanguage.CSharp ? LanguageProperties.CSharp : LanguageProperties.VBNet;
HostCallback.GetCurrentProjectContent = delegate {
return(pc);
};
ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser(sourceLanguage, new StringReader(sourceCode));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
NRefactoryASTConvertVisitor visitor = new NRefactoryASTConvertVisitor(pc);
visitor.VisitCompilationUnit(parser.CompilationUnit, null);
visitor.Cu.FileName = sourceLanguage == SupportedLanguage.CSharp ? "a.cs" : "a.vb";
foreach (IClass c in visitor.Cu.Classes)
{
pc.AddClassToNamespaceList(c);
}
ParseInformation parseInfo = new ParseInformation();
parseInfo.SetCompilationUnit(visitor.Cu);
if (sourceLanguage == SupportedLanguage.CSharp)
{
CSharpToVBNetConvertVisitor convertVisitor = new CSharpToVBNetConvertVisitor(pc, parseInfo);
convertVisitor.RootNamespaceToRemove = "RootNamespace";
parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
}
else
{
VBNetToCSharpConvertVisitor convertVisitor = new VBNetToCSharpConvertVisitor(pc, parseInfo);
parser.CompilationUnit.AcceptVisitor(convertVisitor, null);
}
IOutputAstVisitor outputVisitor = sourceLanguage == SupportedLanguage.CSharp ? (IOutputAstVisitor) new VBNetOutputVisitor() : new CSharpOutputVisitor();
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.IndentSize = 2;
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(),
outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput.Replace("\r", ""), outputVisitor.Text.Trim().Replace("\r", ""));
}
public void rewriteCode_CSharp(CompilationUnit unit, IList <ISpecial> specials)
{
var outputVisitor = new CSharpOutputVisitor();
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
unit.AcceptVisitor(outputVisitor, null);
}
//codeTextBox.Text = outputVisitor.Text.Replace("\t", " ");
CSharpCode = outputVisitor.Text;
}
protected void ConvertFile(FileProjectItem sourceItem, FileProjectItem targetItem,
string sourceExtension, string targetExtension,
SupportedLanguage sourceLanguage, IOutputAstVisitor outputVisitor)
{
FixExtensionOfExtraProperties(targetItem, sourceExtension, targetExtension);
if (sourceExtension.Equals(Path.GetExtension(sourceItem.FileName), StringComparison.OrdinalIgnoreCase))
{
string code = ParserService.GetParseableFileContent(sourceItem.FileName);
IParser p = ParserFactory.CreateParser(sourceLanguage, new StringReader(code));
p.Parse();
if (p.Errors.Count > 0)
{
conversionLog.AppendLine();
conversionLog.AppendLine(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.Convert.IsNotConverted}",
new string[, ] {
{ "FileName", sourceItem.FileName }
}));
conversionLog.AppendLine(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.Convert.ParserErrorCount}",
new string[, ] {
{ "ErrorCount", p.Errors.Count.ToString() }
}));
conversionLog.AppendLine(p.Errors.ErrorOutput);
base.ConvertFile(sourceItem, targetItem);
return;
}
List <ISpecial> specials = p.Lexer.SpecialTracker.CurrentSpecials;
ConvertAst(p.CompilationUnit, specials, sourceItem);
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
outputVisitor.VisitCompilationUnit(p.CompilationUnit, null);
}
p.Dispose();
if (outputVisitor.Errors.Count > 0)
{
conversionLog.AppendLine();
conversionLog.AppendLine(StringParser.Parse("${res:ICSharpCode.SharpDevelop.Commands.Convert.ConverterErrorCount}",
new string[, ] {
{ "FileName", sourceItem.FileName },
{ "ErrorCount", outputVisitor.Errors.Count.ToString() }
}));
conversionLog.AppendLine(outputVisitor.Errors.ErrorOutput);
}
targetItem.Include = Path.ChangeExtension(targetItem.Include, targetExtension);
File.WriteAllText(targetItem.FileName, outputVisitor.Text);
}
else
{
base.ConvertFile(sourceItem, targetItem);
}
}
public String ToCSharp2()
{
IOutputAstVisitor outputVisitor = new CSharpOutputVisitor();
SetPrettyPrintOptions(outputVisitor);
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
unit.AcceptVisitor(outputVisitor, null);
}
return(outputVisitor.Text);
}
public void rewriteCode_VBNet(CompilationUnit unit, IList <ISpecial> specials)
{
var outputVisitor = new VBNetOutputVisitor();
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
unit.AcceptVisitor(outputVisitor, null);
}
//codeTextBox.Text = outputVisitor.Text.Replace("\t", " ");
VBNetCode = outputVisitor.Text;
// PublicDI.log.debug(recreatedCode);
}
void GenerateCodeButtonClick(object sender, EventArgs e)
{
if (syntaxTree.Unit != null)
{
VBNetOutputVisitor visitor = new VBNetOutputVisitor();
// re-insert the comments we saved from the parser into the output
using (SpecialNodesInserter.Install(savedSpecials, visitor)) {
syntaxTree.Unit.AcceptVisitor(visitor, null);
}
codeView.Text = visitor.Text.Replace("\t", " ");
}
}
public static string ConvertVBNET2CS(string vbcode)
{
var snippetParser = new SnippetParser(SupportedLanguage.VBNet);
var node = snippetParser.Parse(vbcode);
node.AcceptVisitor(new ToVBNetConvertVisitor(), null);
var csharpOutputVisitor = new CSharpOutputVisitor();
using (SpecialNodesInserter.Install(snippetParser.Specials, csharpOutputVisitor))
node.AcceptVisitor(csharpOutputVisitor, null);
return(csharpOutputVisitor.Text);
}
protected override string GenerateCode(INode unit, bool installSpecials)
{
CSharpOutputVisitor visitor = new CSharpOutputVisitor();
if (installSpecials)
{
SpecialNodesInserter.Install(this.specialsList, visitor);
}
unit.AcceptVisitor(visitor, null);
return(visitor.Text);
}
public static string ConvertCS2VBNET(string cscode)
{
var snippetParser = new SnippetParser(SupportedLanguage.CSharp);
var node = snippetParser.Parse(cscode);
node.AcceptVisitor(new ToVBNetConvertVisitor(), null);
var netOutputVisitor = new VBNetOutputVisitor();
using (SpecialNodesInserter.Install(snippetParser.Specials, netOutputVisitor))
node.AcceptVisitor(netOutputVisitor, null);
return(netOutputVisitor.Text);
}
private void GenerateCode()
{
foreach (Source entry in Sources.Values)
{
if (entry.CodeFile)
{
CSharpOutputVisitor csharpOutputVisitor = new CSharpOutputVisitor();
SpecialNodesInserter.Install(entry.Parser.Lexer.SpecialTracker.RetrieveSpecials(), csharpOutputVisitor);
csharpOutputVisitor.VisitCompilationUnit(entry.CompilationUnit, null);
entry.Code = csharpOutputVisitor.Text;
}
}
}
private void Generate(SupportedLanguage language, TextReader inputstream, OutputClass output)
{
IParser parser = ParserFactory.CreateParser(language, inputstream);
parser.Parse();
if (parser.Errors.Count > 0)
{
new ExceptionDialog(null, "Error Parsing Input Code").ShowDialog();
}
else if (output.CodeDomProvider != null)
{
CodeDomVisitor visitor = new CodeDomVisitor();
visitor.VisitCompilationUnit(parser.CompilationUnit, null);
for (int i = visitor.codeCompileUnit.Namespaces.Count - 1; i >= 0; i--)
{
if (visitor.codeCompileUnit.Namespaces[i].Types.Count == 0)
{
visitor.codeCompileUnit.Namespaces.RemoveAt(i);
}
}
CodeGeneratorOptions options = new CodeGeneratorOptions();
options.BlankLinesBetweenMembers = true;
StringWriter writer = new StringWriter();
output.CodeDomProvider.GenerateCodeFromCompileUnit(visitor.codeCompileUnit, writer, options);
this.scintillaOutput.Text = writer.ToString();
writer.Close();
}
else
{
AbstractAstTransformer transformer = output.CreateTransformer();
List <ISpecial> currentSpecials = parser.Lexer.SpecialTracker.CurrentSpecials;
if ((language == SupportedLanguage.CSharp) && (transformer is ToVBNetConvertVisitor))
{
PreprocessingDirective.CSharpToVB(currentSpecials);
}
else if ((language == SupportedLanguage.VBNet) && (transformer is ToCSharpConvertVisitor))
{
PreprocessingDirective.VBToCSharp(currentSpecials);
}
parser.CompilationUnit.AcceptVisitor(transformer, null);
IOutputAstVisitor outputVisitor = output.CreatePrettyPrinter();
using (SpecialNodesInserter.Install(currentSpecials, outputVisitor))
{
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
this.scintillaOutput.Text = outputVisitor.Text;
}
}
void TestProgramCS2VB(string programCS, string programVB)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(programCS));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor();
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(),
outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(programVB.Replace("\r", ""), outputVisitor.Text.TrimEnd().Replace("\r", ""));
parser.Dispose();
}
public void InsertAfterCurrentMethod()
{
IOutputAstVisitor outputVisitor = this.GetOutputVisitor();
using (SpecialNodesInserter.Install(this.specialsList, outputVisitor)) {
string code = "\r\n\r\n" + GenerateCode(this.extractedMethod, true);
code = code.TrimEnd('\r', '\n', ' ', '\t');
Dom.IMember p = GetParentMember(this.textEditor, start.Line, start.Column);
int offset = textEditor.Document.PositionToOffset(p.BodyRegion.EndLine, p.BodyRegion.EndColumn);
textEditor.Document.Insert(offset, code);
}
}
static int Main(string[] args)
{
File.Delete("conversion.log");
try {
List <string> map = new List <string>()
{
"..\\Controller\\Profiler",
"..\\Controller\\Data\\UnmanagedCallTreeNode",
"..\\Controller\\structs"
};
foreach (string path in map)
{
using (IParser parser = ParserFactory.CreateParser(path + ".cs"))
{
parser.Parse();
if (parser.Errors.Count > 0)
{
string message = "Parser errors in file " + path + ":\n" + parser.Errors.ErrorOutput;
Console.WriteLine(message);
File.WriteAllText(path + "64.cs", message);
return(2);
}
var specials = parser.Lexer.SpecialTracker.RetrieveSpecials().Where(item => item is PreprocessingDirective);
parser.CompilationUnit.AcceptVisitor(new Converter(), null);
CSharpOutputVisitor output = new CSharpOutputVisitor();
SpecialNodesInserter.Install(specials, output);
parser.CompilationUnit.AcceptVisitor(output, null);
if (!File.Exists(path + "64.cs") || File.ReadAllText(path + "64.cs") != output.Text)
{
File.WriteAllText(path + "64.cs", output.Text);
}
}
}
return(0);
} catch (Exception e) {
File.WriteAllText("conversion.log", e.ToString());
return(-1);
}
}
void TestProgram(string program)
{
VBParser parser = ParserFactory.CreateParser(new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor();
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.TabSize = 2;
outputVisitor.Options.IndentSize = 2;
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(),
outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(program.Replace("\r", ""), outputVisitor.Text.TrimEnd().Replace("\r", ""));
parser.Dispose();
}
void TestProgramCS2VB(string programCS, string programVB)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(programCS));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor();
List <ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
PreprocessingDirective.CSharpToVB(specials);
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.IndentSize = 2;
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(programVB.Replace("\r", ""), outputVisitor.Text.TrimEnd().Replace("\r", ""));
parser.Dispose();
}
public void InsertAfterCurrentMethod()
{
IOutputAstVisitor outputVisitor = this.GetOutputVisitor();
using (SpecialNodesInserter.Install(this.specialsList, outputVisitor)) {
string code = "\r\n\r\n" + GenerateCode(this.extractedMethod, true);
code = code.TrimEnd('\r', '\n', ' ', '\t');
Dom.IMember p = GetParentMember(this.textEditor, this.currentSelection.StartPosition.Line + 1, this.currentSelection.StartPosition.Column + 1);
TextLocation loc = new ICSharpCode.TextEditor.TextLocation(
p.BodyRegion.EndColumn - 1, p.BodyRegion.EndLine - 1);
int offset = textEditor.Document.PositionToOffset(loc);
textEditor.Document.Insert(offset, code);
}
}
public void FormatCode()
{
TextReader r = new StringReader(this.syntaxBoxControl1.Document.Text);
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, r);
parser.Parse();
List <ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
try {
if (parser.Errors.Count == 0)
{
CSharpOutputVisitor ov = new CSharpOutputVisitor();
SpecialNodesInserter.Install(specials, ov);
foreach (INode c in parser.CompilationUnit.Children)
{
c.AcceptVisitor(ov, null);
}
this.syntaxBoxControl1.Document.Text = ov.Text;
}
} catch (Exception) {}
}
public void TestProgram(string input, string expectedOutput)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(input));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
var specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
PreprocessingDirective.CSharpToVB(specials);
parser.CompilationUnit.AcceptVisitor(new CSharpConstructsConvertVisitor(), null);
parser.CompilationUnit.AcceptVisitor(new ToVBNetConvertVisitor(), null);
VBNetOutputVisitor outputVisitor = new VBNetOutputVisitor();
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.IndentSize = 2;
outputVisitor.Options.OutputByValModifier = true;
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
}
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput.Replace("\r", ""), outputVisitor.Text.Replace("\r", ""));
}
public void Uninternalize(string file)
{
using (var parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(File.ReadAllText(file))))
{
parser.Parse();
if (parser.Errors.Count > 0)
{
Console.WriteLine(parser.Errors.ErrorOutput);
return;
}
var specials = parser.Lexer.SpecialTracker.RetrieveSpecials();
parser.CompilationUnit.AcceptVisitor(new UninternalizerVisitor(), null);
var visitor = new CSharpOutputVisitor();
using (SpecialNodesInserter.Install(specials, visitor))
parser.CompilationUnit.AcceptVisitor(visitor, null);
File.WriteAllText(file, visitor.Text);
}
}
void RunButtonClick(object sender, EventArgs e)
{
StringReader input = new StringReader(inputTextBox.Text);
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, input);
parser.Parse();
if (parser.Errors.Count > 0)
{
outputTextBox.Text = parser.Errors.ErrorOutput;
return;
}
CompilationUnit cu = parser.CompilationUnit;
cu.AcceptVisitor(new WrapperGeneratorVisitor(), null);
IOutputAstVisitor output = new CSharpOutputVisitor(); //new VBNetOutputVisitor();
// SpecialNodesInserter will re-insert the comments into the generated code
using (SpecialNodesInserter.Install(parser.Lexer.SpecialTracker.RetrieveSpecials(), output)) {
cu.AcceptVisitor(output, null);
}
outputTextBox.Text = output.Text;
}
string Output(IParser parser)
{
IOutputASTVisitor visitor = CreateOutputVisitor();
visitor.Options = CreatePrettyPrintOptions();
List <ISpecial> specials = parser.Lexer.SpecialTracker.CurrentSpecials;
SpecialNodesInserter sni = new SpecialNodesInserter(specials,
new SpecialOutputVisitor(visitor.OutputFormatter));
visitor.NodeTracker.NodeVisiting += sni.AcceptNodeStart;
visitor.NodeTracker.NodeVisited += sni.AcceptNodeEnd;
visitor.NodeTracker.NodeChildrenVisited += sni.AcceptNodeEnd;
visitor.NodeTracker.NodeVisited += delegate(INode node) {
if (IsMemberDeclaration(node))
{
visitor.OutputFormatter.NewLine();
}
};
parser.CompilationUnit.AcceptVisitor(visitor, null);
sni.Finish();
return(visitor.Text);
}
public override string CreateNewFileLikeExisting(string existingFileContent, string codeForNewType)
{
NR.IParser parser = ParseFile(existingFileContent);
if (parser == null)
{
return(null);
}
RemoveTypesVisitor visitor = new RemoveTypesVisitor();
parser.CompilationUnit.AcceptVisitor(visitor, null);
List <NR.ISpecial> comments = new List <NR.ISpecial>();
foreach (NR.ISpecial c in parser.Lexer.SpecialTracker.CurrentSpecials)
{
if (c.StartPosition.Y <= visitor.includeCommentsUpToLine ||
c.StartPosition.Y > visitor.includeCommentsAfterLine)
{
comments.Add(c);
}
}
IOutputAstVisitor outputVisitor = (language == NR.SupportedLanguage.CSharp) ? new CSharpOutputVisitor() : (IOutputAstVisitor) new VBNetOutputVisitor();
using (SpecialNodesInserter.Install(comments, outputVisitor)) {
parser.CompilationUnit.AcceptVisitor(outputVisitor, null);
}
string expectedText;
if (language == NR.SupportedLanguage.CSharp)
{
expectedText = "using " + RemoveTypesVisitor.DummyIdentifier + ";";
}
else
{
expectedText = "Imports " + RemoveTypesVisitor.DummyIdentifier;
}
using (StringWriter w = new StringWriter()) {
using (StringReader r1 = new StringReader(outputVisitor.Text)) {
string line;
while ((line = r1.ReadLine()) != null)
{
string trimLine = line.TrimStart();
if (trimLine == expectedText)
{
string indentation = line.Substring(0, line.Length - trimLine.Length);
using (StringReader r2 = new StringReader(codeForNewType)) {
while ((line = r2.ReadLine()) != null)
{
w.Write(indentation);
w.WriteLine(line);
}
}
}
else
{
w.WriteLine(line);
}
}
}
if (visitor.firstType)
{
w.WriteLine(codeForNewType);
}
return(w.ToString());
}
}