string CreateCode(INode node, IOutputAstVisitor outputVisitor)
{
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
node.AcceptVisitor(outputVisitor, null);
}
return(outputVisitor.Text);
}
public string Convert()
{
TextReader Reader = this.GetReader();
IParser Parser = ParserFactory.CreateParser(this.From, Reader);
Parser.Parse();
if (Parser.Errors.Count > 0)
{
Log(Level.Error, Parser.Errors.ErrorOutput);
throw new BuildException("Errors parsing code.", this.Location);
}
CompilationUnit Tree = Parser.CompilationUnit;
IOutputAstVisitor OutputVisitor = null;
switch (this.To)
{
case SupportedLanguage.CSharp:
OutputVisitor = new CSharpOutputVisitor();
break;
case SupportedLanguage.VBNet:
OutputVisitor = new VBNetOutputVisitor();
break;
}
Tree.AcceptVisitor(OutputVisitor, null);
return(OutputVisitor.Text);
}
/// <summary>
/// Registers a new <see cref="CodeCommentDecorator"/> with the specified <paramref name="outputVisitor"/>.
/// </summary>
public static CodeCommentDecorator Install(IOutputAstVisitor outputVisitor)
{
var ccd = new CodeCommentDecorator(outputVisitor.OutputFormatter);
outputVisitor.BeforeNodeVisit += ccd.AcceptNodeStart;
outputVisitor.AfterNodeVisit += ccd.AcceptNodeEnd;
return ccd;
}
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);
}
/// <summary>
/// Registers a new SpecialNodesInserter with the output visitor.
/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
/// when the output is finished.
/// </summary>
public static SpecialNodesInserter Install(IEnumerable<ISpecial> specials, IOutputAstVisitor outputVisitor)
{
SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
outputVisitor.AfterNodeVisit += sni.AcceptNodeEnd;
return sni;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionItem" /> class.
/// </summary>
/// <param name="key">The resource key.</param>
/// <param name="description">The resource description.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
public ResourceCodeCompletionItem(string key, string description, IOutputAstVisitor outputVisitor)
: base(key)
{
this.Description = description;
this.Image = ClassBrowserIconService.Const;
this.outputVisitor = outputVisitor;
}
public override string GenerateCode(AbstractNode node, string indentation)
{
IOutputAstVisitor visitor = CreateOutputVisitor();
int indentCount = 0;
foreach (char c in indentation)
{
if (c == '\t')
{
indentCount += 4;
}
else
{
indentCount += 1;
}
}
visitor.OutputFormatter.IndentationLevel = indentCount / 4;
if (node is Statement)
{
visitor.OutputFormatter.Indent();
}
node.AcceptVisitor(visitor, null);
string text = visitor.Text;
if (node is Statement && !text.EndsWith("\n"))
{
text += Environment.NewLine;
}
return(text);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionItem" /> class.
/// </summary>
/// <param name="key">The resource key.</param>
/// <param name="description">The resource description.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
public ResourceCodeCompletionItem(string key, string description, IOutputAstVisitor outputVisitor)
: base(key)
{
this.Description = description;
this.Image = ClassBrowserIconService.Const;
this.outputVisitor = outputVisitor;
}
/// <summary>
/// Generates the completion items.
/// </summary>
private void GenerateCompletionItems(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
this.Items.Add(new NewResourceCodeCompletionItem(content, outputVisitor, preEnteredName));
foreach (KeyValuePair<string, object> entry in content.Data) {
this.Items.Add(new ResourceCodeCompletionItem(entry.Key, ResourceResolverService.FormatResourceDescription(content, entry.Key), outputVisitor));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionItemList" /> class.
/// </summary>
/// <param name="content">The resource file content to be presented to the user.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
/// <param name="preEnteredName">The type name which should be pre-entered in the 'add new' dialog box if the user selects the 'add new' entry.</param>
public ResourceCodeCompletionItemList(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
if (content == null) {
throw new ArgumentNullException("content");
}
this.GenerateCompletionItems(content, outputVisitor, preEnteredName);
}
void txtNameTextChanged(object sender, EventArgs e)
{
declaration.Name = this.txtName.Text;
IOutputAstVisitor visitor = this.generator.Invoke();
declaration.AcceptVisitor(visitor, null);
this.txtPreview.Text = visitor.Text;
}
/// <summary>
/// Registers a new SpecialNodesInserter with the output visitor.
/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
/// when the output is finished.
/// </summary>
public static SpecialNodesInserter Install(IEnumerable <ISpecial> specials, IOutputAstVisitor outputVisitor)
{
SpecialNodesInserter sni = new SpecialNodesInserter(specials, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
outputVisitor.AfterNodeVisit += sni.AcceptNodeEnd;
return(sni);
}
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", " ");
}
public OutputClass(string name, AbstractAstTransformer visitor, IOutputAstVisitor prettyprinter, int savefilterindex)
{
this.name = string.Empty;
this.name = name;
this.transformer = visitor;
this.prettyprinter = prettyprinter;
this.savefilterindex = savefilterindex;
}
/// <summary>
/// Registers a new SpecialNodesInserter with the output visitor.
/// Make sure to call Finish() (or Dispose()) on the returned SpecialNodesInserter
/// when the output is finished.
/// </summary>
public static SpecialNodesByMapInserter Install(Hashtable specialsMap, IOutputAstVisitor outputVisitor)
{
SpecialNodesByMapInserter sni = new SpecialNodesByMapInserter(specialsMap, new SpecialOutputVisitor(outputVisitor.OutputFormatter));
outputVisitor.BeforeNodeVisit += sni.AcceptNodeStart;
outputVisitor.AfterNodeVisit += sni.AcceptNodeEnd;
return(sni);
}
/// <summary>
/// Registers a new <see cref="CodeCommentDecorator"/> with the specified <paramref name="outputVisitor"/>.
/// </summary>
public static CodeCommentDecorator Install(IOutputAstVisitor outputVisitor)
{
var ccd = new CodeCommentDecorator(outputVisitor.OutputFormatter);
outputVisitor.BeforeNodeVisit += ccd.AcceptNodeStart;
outputVisitor.AfterNodeVisit += ccd.AcceptNodeEnd;
return(ccd);
}
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", ""));
}
/// <summary>
/// Generates the completion items.
/// </summary>
private void GenerateCompletionItems(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
this.Items.Add(new NewResourceCodeCompletionItem(content, outputVisitor, preEnteredName));
foreach (KeyValuePair <string, object> entry in content.Data)
{
this.Items.Add(new ResourceCodeCompletionItem(entry.Key, ResourceResolverService.FormatResourceDescription(content, entry.Key), outputVisitor));
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionItemList" /> class.
/// </summary>
/// <param name="content">The resource file content to be presented to the user.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
/// <param name="preEnteredName">The type name which should be pre-entered in the 'add new' dialog box if the user selects the 'add new' entry.</param>
public ResourceCodeCompletionItemList(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
this.GenerateCompletionItems(content, outputVisitor, preEnteredName);
}
public override string GenerateInterfaceForClass(string newInterfaceName, string existingCode, IList <IMember> membersToKeep, IClass sourceClass, bool preserveComments)
{
Modifiers modifiers = CodeGenerator.ConvertModifier(sourceClass.Modifiers, new ClassFinder(membersToKeep[0]));
// keep only visibility modifiers and 'unsafe' modifier
// -> remove abstract,sealed,static
modifiers &= Modifiers.Visibility | Modifiers.Unsafe;
TypeDeclaration interfaceDef = new TypeDeclaration(modifiers, new List <AttributeSection>());
interfaceDef.Name = newInterfaceName;
interfaceDef.Type = NR.Ast.ClassType.Interface;
interfaceDef.Templates = CodeGenerator.ConvertTemplates(sourceClass.TypeParameters, new ClassFinder(membersToKeep[0]));
foreach (IMember member in membersToKeep)
{
AttributedNode an = CodeGenerator.ConvertMember(member, new ClassFinder(member));
INode node = null;
if (an is MethodDeclaration)
{
MethodDeclaration m = an as MethodDeclaration;
m.Body = BlockStatement.Null;
m.Modifier = Modifiers.None;
node = m;
}
else
{
if (an is PropertyDeclaration)
{
PropertyDeclaration p = an as PropertyDeclaration;
p.GetRegion.Block = BlockStatement.Null;
p.SetRegion.Block = BlockStatement.Null;
p.Modifier = Modifiers.None;
node = p;
}
}
if (node == null)
{
throw new NotSupportedException();
}
interfaceDef.AddChild(node);
}
IOutputAstVisitor printer = this.GetOutputVisitor();
interfaceDef.AcceptVisitor(printer, null);
string codeForNewInterface = printer.Text;
// wrap the new code in the same comments/usings/namespace as the the original class file.
string newFileContent = CreateNewFileLikeExisting(existingCode, codeForNewInterface);
return(newFileContent);
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionDataProvider" /> class.
/// </summary>
/// <param name="content">The resource file content to be presented to the user.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
/// <param name="preEnteredName">The type name which should be pre-entered in the 'add new' dialog box if the user selects the 'add new' entry.</param>
public ResourceCodeCompletionDataProvider(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
if (content == null) {
throw new ArgumentNullException("content");
}
this.content = content;
this.outputVisitor = outputVisitor;
this.preEnteredName = preEnteredName;
this.InsertSpace = false;
}
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);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionDataProvider" /> class.
/// </summary>
/// <param name="content">The resource file content to be presented to the user.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
/// <param name="preEnteredName">The type name which should be pre-entered in the 'add new' dialog box if the user selects the 'add new' entry.</param>
public ResourceCodeCompletionDataProvider(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
{
if (content == null)
{
throw new ArgumentNullException("content");
}
this.content = content;
this.outputVisitor = outputVisitor;
this.preEnteredName = preEnteredName;
this.InsertSpace = false;
}
private void SetPrettyPrintOptions(IOutputAstVisitor outputVisitor)
{
PrettyPrintOptions options = outputVisitor.Options as PrettyPrintOptions;
options.NamespaceBraceStyle = BraceStyle.EndOfLine;
options.ClassBraceStyle = BraceStyle.EndOfLine;
options.MethodBraceStyle = BraceStyle.EndOfLine;
options.PropertyBraceStyle = BraceStyle.EndOfLine;
options.PropertyGetBraceStyle = BraceStyle.EndOfLine;
options.PropertySetBraceStyle = BraceStyle.EndOfLine;
options.ConstructorBraceStyle = BraceStyle.EndOfLine;
options.TabSize = 8;
options.IndentSize = 4;
options.IndentationChar = ' ';
}
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;
}
}
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);
}
}
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 ExtractMethodForm(MethodDeclaration declaration, Func <IOutputAstVisitor> generator)
{
//
// The InitializeComponent() call is required for Windows Forms designer support.
//
InitializeComponent();
SetTranslation(this);
this.declaration = declaration;
this.generator = generator;
IOutputAstVisitor visitor = this.generator.Invoke();
body = declaration.Body;
declaration.Body = new BlockStatement();
declaration.AcceptVisitor(visitor, null);
this.txtName.Text = this.declaration.Name;
this.txtPreview.Text = visitor.Text;
this.txtName.SelectAll();
}
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());
}
}
public NewResourceCodeCompletionData(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
: base(StringParser.Parse("${res:Hornung.ResourceToolkit.CodeCompletion.AddNewEntry}"), String.Format(CultureInfo.CurrentCulture, StringParser.Parse("${res:Hornung.ResourceToolkit.CodeCompletion.AddNewDescription}"), content.FileName), outputVisitor)
{
this.content = content;
this.preEnteredName = preEnteredName;
}
public NewResourceCodeCompletionData(IResourceFileContent content, IOutputAstVisitor outputVisitor, string preEnteredName)
: base(StringParser.Parse("${res:Hornung.ResourceToolkit.CodeCompletion.AddNewEntry}"), String.Format(CultureInfo.CurrentCulture, StringParser.Parse("${res:Hornung.ResourceToolkit.CodeCompletion.AddNewDescription}"), content.FileName), outputVisitor)
{
this.content = content;
this.preEnteredName = preEnteredName;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionData" /> class.
/// </summary>
/// <param name="key">The resource key.</param>
/// <param name="description">The resource description.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
public ResourceCodeCompletionData(string key, string description, IOutputAstVisitor outputVisitor)
: base(key, description, ClassBrowserIconService.GotoArrowIndex)
{
this.outputVisitor = outputVisitor;
}
string CreateCode(INode node, IOutputAstVisitor outputVisitor)
{
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
node.AcceptVisitor(outputVisitor, null);
}
return outputVisitor.Text;
}
/// <summary>
/// Initializes a new instance of the <see cref="ResourceCodeCompletionData" /> class.
/// </summary>
/// <param name="key">The resource key.</param>
/// <param name="description">The resource description.</param>
/// <param name="outputVisitor">The NRefactory output visitor to be used to generate the inserted code. If <c>null</c>, the key is inserted literally.</param>
public ResourceCodeCompletionData(string key, string description, IOutputAstVisitor outputVisitor)
: base(key, description, ClassBrowserIconService.GotoArrowIndex)
{
this.outputVisitor = outputVisitor;
}
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);
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);
}
}
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", " ");
}
