public static string GenerateText(TypeDeclaration type, OrderedPartCollection<AbstractDynamicCompilationExtension> extensions)
{
var unit = new CompilationUnit();
var namespaces = new HashSet<string>
{
typeof (SystemTime).Namespace,
typeof (AbstractViewGenerator).Namespace,
typeof (Enumerable).Namespace,
typeof (IEnumerable<>).Namespace,
typeof (IEnumerable).Namespace,
typeof (int).Namespace,
typeof (LinqOnDynamic).Namespace,
typeof(Field).Namespace,
};
foreach (var extension in extensions)
{
foreach (var ns in extension.Value.GetNamespacesToImport())
{
namespaces.Add(ns);
}
}
foreach (var ns in namespaces)
{
unit.AddChild(new Using(ns));
}
unit.AddChild(type);
var output = new CSharpOutputVisitor();
unit.AcceptVisitor(output, null);
return output.Text;
}
public static string ToText(AbstractNode node)
{
var output = new CSharpOutputVisitor();
node.AcceptVisitor(output, null);
return output.Text;
}
public static string ToText(INode node)
{
var output = new CSharpOutputVisitor();
node.AcceptVisitor(output, null);
return(output.Text);
}
void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
{
StringWriter w = new StringWriter();
CSharpOutputVisitor output = new CSharpOutputVisitor(w, new CSharpFormattingOptions());
compilationUnit.AcceptVisitor(output, null);
csharpCodeTextBox.Text = w.ToString();
}
void CSharpGenerateCodeButtonClick(object sender, EventArgs e)
{
var w = new StringWriter();
var output = new CSharpOutputVisitor(w, new CSharpFormattingOptions());
unit.AcceptVisitor(output, null);
editor.Text = w.ToString();
}
public override void WriteIdentifier(Identifier identifier)
{
if (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier))
{
output.Write('@');
}
var definition = GetCurrentDefinition();
string name = TextWriterTokenWriter.EscapeIdentifier(identifier.Name);
switch (definition)
{
case IType t:
output.WriteReference(t, name, true);
return;
case IMember m:
output.WriteReference(m, name, true);
return;
}
var member = GetCurrentMemberReference();
switch (member)
{
case IType t:
output.WriteReference(t, name, false);
return;
case IMember m:
output.WriteReference(m, name, false);
return;
}
var localDefinition = GetCurrentLocalDefinition();
if (localDefinition != null)
{
output.WriteLocalReference(name, localDefinition, isDefinition: true);
return;
}
var localRef = GetCurrentLocalReference();
if (localRef != null)
{
output.WriteLocalReference(name, localRef);
return;
}
if (firstUsingDeclaration && !lastUsingDeclaration)
{
output.MarkFoldStart(defaultCollapsed: !settings.ExpandUsingDeclarations);
firstUsingDeclaration = false;
}
output.Write(name);
}
public static string ToText(AstNode node)
{
var stringWriter = new StringWriter();
var output = new CSharpOutputVisitor(stringWriter, FormattingOptionsFactory.CreateSharpDevelop());
node.AcceptVisitor(output);
return(stringWriter.GetStringBuilder().ToString());
}
public static IDictionary <AstNode, ISegment> WriteNode(StringWriter writer, AstNode node, CSharpFormattingOptions policy, BotTimeICSharpCode.AvalonEdit.TextEditorOptions options)
{
var formatter = new SegmentTrackingOutputFormatter(writer);
//formatter.IndentationString = options.IndentationString;
var visitor = new CSharpOutputVisitor(formatter, policy);
node.AcceptVisitor(visitor);
return(formatter.Segments);
}
public string OutputNode (ProjectDom dom, INode node, string indent)
{
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor ();
CSharpFormatter.SetFormatOptions (outputVisitor, dom != null && dom.Project != null ? dom.Project.Policies : null);
int col = CSharpFormatter.GetColumn (indent, 0, 4);
outputVisitor.OutputFormatter.IndentationLevel = System.Math.Max (0, col / 4);
node.AcceptVisitor (outputVisitor, null);
return outputVisitor.Text;
}
protected internal string GetCode(INode node)
{
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
PrettyPrintOptions options = (PrettyPrintOptions)outputVisitor.Options;
options.SpacesAfterComma = false;
node.AcceptVisitor(outputVisitor, null);
return(outputVisitor.Text);
}
protected string GenerateParams(Type eventType, bool paramNames)
{
CSharpOutputVisitor v = new CSharpOutputVisitor();
MethodDeclaration md = ConvertEventInvokeMethodToNRefactory(CurrentClassPart, eventType, "name");
if (md != null) {
v.AppendCommaSeparatedList(md.Parameters);
}
return v.Text;
}
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;
}
static int Main(string[] args)
{
try {
File.Delete("conversion.log");
List <string> map = new List <string>()
{
"..\\Controller\\Profiler",
"..\\Controller\\Data\\UnmanagedCallTreeNode",
"..\\Controller\\structs"
};
foreach (string path in map)
{
CSharpParser parser = new CSharpParser();
#if DEBUG
parser.CompilerSettings.ConditionalSymbols.Add("DEBUG");
#endif
string filePath = path + ".cs";
if (File.Exists(filePath))
{
using (StreamReader reader = new StreamReader(filePath)) {
SyntaxTree syntaxTree = parser.Parse(reader, filePath);
if (parser.HasErrors)
{
string message = "Parser errors in file " + filePath + ":\n";
foreach (Error error in parser.Errors)
{
message += error.Message + "\n";
}
Console.WriteLine(message);
File.WriteAllText(path + "64.cs", message);
return(2);
}
syntaxTree.AcceptVisitor(new Converter());
using (StreamWriter writer = new StreamWriter(path + "64.cs")) {
CSharpOutputVisitor output = new CSharpOutputVisitor(writer, FormattingOptionsFactory.CreateSharpDevelop());
syntaxTree.AcceptVisitor(output);
}
}
}
}
return(0);
} catch (Exception e) {
try {
File.WriteAllText("conversion.log", e.ToString());
} catch (Exception) {
return(-2);
}
return(-1);
}
}
public override void WriteIdentifier(Identifier identifier, TextTokenType tokenType)
{
if (tokenType == TextTokenType.Text)
{
tokenType = TextTokenHelper.GetTextTokenType(identifier.AnnotationVT <TextTokenType>() ?? identifier.Annotation <object>());
}
if (tokenType != TextTokenType.Keyword && (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)))
{
output.Write('@', TextTokenType.Operator);
}
var definition = GetCurrentDefinition(identifier);
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType, false);
return;
}
object memberRef = GetCurrentMemberReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType);
return;
}
definition = GetCurrentLocalDefinition();
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenType);
return;
}
memberRef = GetCurrentLocalReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenType, true);
return;
}
if (firstUsingDeclaration)
{
output.MarkFoldStart(defaultCollapsed: true);
firstUsingDeclaration = false;
}
var s = identifier.Name;
if (identifier.Annotation <IdentifierFormatted>() == null)
{
s = IdentifierEscaper.Escape(s);
}
output.Write(s, tokenType);
}
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;
}
string AddInteger <T>(string input, int number) where T : Expression
{
Expression e = ParseUtilCSharp.ParseExpression <T>(input);
e = Expression.AddInteger(e, number);
CSharpOutputVisitor v = new CSharpOutputVisitor();
e.AcceptVisitor(v, null);
return(v.Text);
}
void TestProgram(string program)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(StripWhitespace(program), StripWhitespace(outputVisitor.Text));
}
public static IReadOnlyDictionary <AstNode, ISegment> WriteNode(StringWriter writer, AstNode node, CSharpFormattingOptions policy, ITextEditorOptions editorOptions)
{
var formatter = new SegmentTrackingOutputFormatter(writer);
formatter.IndentationString = editorOptions.IndentationString;
var visitor = new CSharpOutputVisitor(formatter, policy);
node.AcceptVisitor(visitor);
return(formatter.Segments);
}
public override void WriteIdentifier(Identifier identifier)
{
if (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier))
{
output.Write('@');
}
var definition = GetCurrentDefinition();
if (definition != null)
{
MemberReference cecil = SymbolToCecil(definition);
if (cecil != null)
{
output.WriteDefinition(identifier.Name, cecil, false);
return;
}
}
var member = GetCurrentMemberReference();
if (member != null)
{
MemberReference cecil = SymbolToCecil(member);
if (cecil != null)
{
output.WriteReference(identifier.Name, cecil);
return;
}
}
var localDefinition = GetCurrentLocalDefinition();
if (localDefinition != null)
{
output.WriteDefinition(identifier.Name, localDefinition);
return;
}
var localRef = GetCurrentLocalReference();
if (localRef != null)
{
output.WriteReference(identifier.Name, localRef, true);
return;
}
if (firstUsingDeclaration)
{
output.MarkFoldStart(defaultCollapsed: true);
firstUsingDeclaration = false;
}
output.Write(identifier.Name);
}
public override void WriteIdentifier(Identifier identifier, TextTokenKind tokenKind)
{
if (tokenKind == TextTokenKind.Text)
{
tokenKind = TextTokenKindUtils.GetTextTokenType(identifier.AnnotationVT <TextTokenKind>() ?? identifier.Annotation <object>());
}
if (tokenKind != TextTokenKind.Keyword && (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)))
{
output.Write("@", TextTokenKind.Operator);
}
var definition = GetCurrentDefinition(identifier);
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenKind, false);
return;
}
object memberRef = GetCurrentMemberReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenKind);
return;
}
definition = GetCurrentLocalDefinition();
if (definition != null)
{
output.WriteDefinition(IdentifierEscaper.Escape(identifier.Name), definition, tokenKind);
return;
}
memberRef = GetCurrentLocalReference();
if (memberRef != null)
{
output.WriteReference(IdentifierEscaper.Escape(identifier.Name), memberRef, tokenKind, true);
return;
}
if (firstUsingDeclaration)
{
firstUsingDeclaration = false;
}
var s = identifier.Name;
if (identifier.Annotation <IdentifierFormatted>() == null)
{
s = IdentifierEscaper.Escape(s);
}
output.Write(s, tokenKind);
}
protected string GenerateParams(Type eventType, bool paramNames)
{
CSharpOutputVisitor v = new CSharpOutputVisitor();
MethodDeclaration md = ConvertEventInvokeMethodToNRefactory(CurrentClassPart, eventType, "name");
if (md != null)
{
v.AppendCommaSeparatedList(md.Parameters);
}
return(v.Text);
}
public static string PrettyPrint(this INode code)
{
if (code == null)
{
return(string.Empty);
}
CSharpOutputVisitor csOutVisitor = new CSharpOutputVisitor();
code.AcceptVisitor(csOutVisitor, null);
return(csOutVisitor.Text);
}
public void TestProgram(string input, string expectedOutput)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(input));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
parser.CompilationUnit.AcceptVisitor(new VBNetToCSharpConvertVisitor(), null);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput, outputVisitor.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 string OutputNode(ProjectDom dom, INode node, string indent)
{
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
CSharpFormatter.SetFormatOptions(outputVisitor, dom != null && dom.Project != null ? dom.Project.Policies : null);
int col = CSharpFormatter.GetColumn(indent, 0, 4);
outputVisitor.OutputFormatter.IndentationLevel = System.Math.Max(0, col / 4);
node.AcceptVisitor(outputVisitor, null);
return(outputVisitor.Text);
}
public String ToCSharp2()
{
IOutputAstVisitor outputVisitor = new CSharpOutputVisitor();
SetPrettyPrintOptions(outputVisitor);
using (SpecialNodesInserter.Install(specials, outputVisitor)) {
unit.AcceptVisitor(outputVisitor, null);
}
return(outputVisitor.Text);
}
// Add a value tag
private void AddValueTag(CSharpOutputVisitor formatter)
{
if (valueText.Count == 0)
{
formatter.WriteComment(CommentType.Documentation, " <value>To fill.</value>");
return;
}
formatter.WriteComment(CommentType.Documentation, " <value>");
WriteMultipleDocumentationLine(formatter, ref valueText);
formatter.WriteComment(CommentType.Documentation, " </value>");
}
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);
}
public string OutputNode(AstNode node)
{
using (var stringWriter = new System.IO.StringWriter()) {
var formatter = new TextWriterOutputFormatter(stringWriter);
// formatter.Indentation = indentLevel;
stringWriter.NewLine = Document.Editor.EolMarker;
var visitor = new CSharpOutputVisitor(formatter, FormattingOptionsFactory.CreateMono());
node.AcceptVisitor(visitor);
return(stringWriter.ToString());
}
}
private void FormatDocument_Click(object sender, RoutedEventArgs e)
{
CSharpFormattingOptions policy = FormattingOptionsFactory.CreateAllman();
CSharpParser parser = new CSharpParser();
SyntaxTree tree = parser.Parse(scriptTextBox.Text);
StringWriter writer = new StringWriter();
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor(writer, policy);
outputVisitor.VisitSyntaxTree(tree);
scriptTextBox.Text = writer.ToString();
}
void TestExpression(string expression)
{
// SEMICOLON HACK : without a trailing semicolon, parsing expressions does not work correctly
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(expression + ";"));
Expression e = parser.ParseExpression();
Assert.AreEqual("", parser.Errors.ErrorOutput);
Assert.IsNotNull(e, "ParseExpression returned null");
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
e.AcceptVisitor(outputVisitor, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(StripWhitespace(expression), StripWhitespace(outputVisitor.Text));
}
public static CSharpMethodBodyStatistics GetBodyStatistics(this MethodDeclaration declaration)
{
using (var writer = new StringWriter()) {
var visitor = new CSharpOutputVisitor(writer, FormattingOptionsFactory.CreateAllman());
declaration.AcceptVisitor(visitor);
var bodyAsString = writer.ToString();
return(new CSharpMethodBodyStatistics(
bodyAsString.Split(new[] { Environment.NewLine }, StringSplitOptions.None).Length,
bodyAsString.Length,
bodyAsString.GetHashCode()));
}
}
private static string GenerateCode(INode unit /*, bool installSpecials*/)
{
CSharpOutputVisitor visitor = new CSharpOutputVisitor();
// if (installSpecials)
// {
// SpecialNodesInserter.Install(this.specialsList, visitor);
// }
unit.AcceptVisitor(visitor, null);
return(visitor.Text);
}
void TestProgram(string program)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(StripWhitespace(program), StripWhitespace(outputVisitor.Text));
}
private static string GenerateCode(INode unit/*, bool installSpecials*/)
{
CSharpOutputVisitor visitor = new CSharpOutputVisitor();
// if (installSpecials)
// {
// SpecialNodesInserter.Install(this.specialsList, visitor);
// }
unit.AcceptVisitor(visitor, null);
return visitor.Text;
}
void TestExpression(string expression)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(expression + ";"));
Expression e = parser.ParseExpression();
Assert.AreEqual("", parser.Errors.ErrorOutput);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
e.AcceptVisitor(outputVisitor, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(StripWhitespace(expression), StripWhitespace(outputVisitor.Text));
}
public override void WriteIdentifier(Identifier identifier)
{
WriteIndentation();
if (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier))
{
textWriter.Write('@');
column++;
}
textWriter.Write(identifier.Name);
column += identifier.Name.Length;
isAtStartOfLine = false;
}
public override void WriteIdentifier(Identifier identifier, object data)
{
WriteIndentation();
if (!BoxedTextColor.Keyword.Equals(data) && (identifier.IsVerbatim || CSharpOutputVisitor.IsKeyword(identifier.Name, identifier)))
{
textWriter.Write('@');
column++;
}
textWriter.Write(identifier.Name);
column += identifier.Name.Length;
isAtStartOfLine = false;
}
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);
}
static string OutputNode(MonoDevelop.Ide.Gui.Document doc, AstNode node)
{
using (var stringWriter = new System.IO.StringWriter()) {
// formatter.Indentation = indentLevel;
var formatter = new TextWriterTokenWriter(stringWriter);
stringWriter.NewLine = doc.Editor.EolMarker;
var visitor = new CSharpOutputVisitor(formatter, doc.GetFormattingOptions());
node.AcceptVisitor(visitor);
return(stringWriter.ToString());
}
}
public static string GenerateText(TypeDeclaration type)
{
var unit = new CompilationUnit();
unit.AddChild(new Using(typeof (AbstractViewGenerator).Namespace));
unit.AddChild(new Using(typeof (Enumerable).Namespace));
unit.AddChild(new Using(typeof (int).Namespace));
unit.AddChild(new Using(typeof (LinqOnDynamic).Namespace));
unit.AddChild(type);
var output = new CSharpOutputVisitor();
unit.AcceptVisitor(output, null);
return output.Text;
}
void TestProgram(string program)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(program));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
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();
}
public static string csharpCode(this INode iNode)
{
try
{
var outputVisitor = new CSharpOutputVisitor();
iNode.AcceptVisitor(outputVisitor, null);
return outputVisitor.Text;
}
catch (Exception ex)
{
ex.log("in CSharpSourceCode_ExtensionMethods.csharpCode");
return "error creating source code for iNode. Error message was: ".format(ex.Message) ;
}
}
public void TestProgram(string input, string expectedOutput)
{
IParser parser = ParserFactory.CreateParser(SupportedLanguage.VBNet, new StringReader(input));
parser.Parse();
Assert.AreEqual("", parser.Errors.ErrorOutput);
parser.CompilationUnit.AcceptVisitor(new VBNetConstructsConvertVisitor(), null);
parser.CompilationUnit.AcceptVisitor(new ToCSharpConvertVisitor(), null);
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
outputVisitor.Options.IndentationChar = ' ';
outputVisitor.Options.IndentSize = 2;
outputVisitor.VisitCompilationUnit(parser.CompilationUnit, null);
Assert.AreEqual("", outputVisitor.Errors.ErrorOutput);
Assert.AreEqual(expectedOutput.Replace("\r", ""), outputVisitor.Text.Replace("\r", ""));
}
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 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);
}
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);
}
}
public void NestedInterfaceInGenericClass()
{
// See SD2-1626
DefaultProjectContent pc = new DefaultProjectContent();
pc.ReferencedContents.Add(SharedProjectContentRegistryForTests.Instance.Mscorlib);
DefaultCompilationUnit cu = new DefaultCompilationUnit(pc);
DefaultClass container = new DefaultClass(cu, "TestClass");
container.TypeParameters.Add(new DefaultTypeParameter(container, "T", 0));
DefaultClass innerClass = new DefaultClass(cu, container);
innerClass.FullyQualifiedName = "TestClass.INestedInterface";
innerClass.ClassType = ClassType.Interface;
innerClass.TypeParameters.Add(new DefaultTypeParameter(innerClass, "T", 0));
innerClass.Properties.Add(new DefaultProperty(innerClass, "P") {
ReturnType = new GenericReturnType(innerClass.TypeParameters[0]),
CanGet = true
});
container.InnerClasses.Add(innerClass);
pc.AddClassToNamespaceList(container);
DefaultClass targetClass = new DefaultClass(cu, "TargetClass");
List<AbstractNode> nodes = new List<AbstractNode>();
IReturnType interf = new SearchClassReturnType(pc, targetClass, 0, 0, "TestClass.INestedInterface", 1);
interf = new ConstructedReturnType(interf, new IReturnType[] { SharedProjectContentRegistryForTests.Instance.Mscorlib.GetClass("System.String", 0).DefaultReturnType });
CSharpCodeGenerator codeGen = new CSharpCodeGenerator();
codeGen.ImplementInterface(nodes, interf, true, targetClass);
Assert.AreEqual(1, nodes.Count);
CSharpOutputVisitor output = new CSharpOutputVisitor();
output.Options.IndentationChar = ' ';
output.Options.IndentSize = 2;
nodes[0].AcceptVisitor(output, null);
Assert.AreEqual("string TestClass<string>.INestedInterface.P {\n get {\n throw new NotImplementedException();\n }\n}", output.Text.Replace("\r", "").Trim());
}
public override IOutputAstVisitor CreateOutputVisitor()
{
CSharpOutputVisitor v = new CSharpOutputVisitor();
PrettyPrintOptions pOpt = v.Options;
BraceStyle braceStyle;
if (this.Options.BracesOnSameLine) {
braceStyle = BraceStyle.EndOfLine;
} else {
braceStyle = BraceStyle.NextLine;
}
pOpt.StatementBraceStyle = braceStyle;
pOpt.EventAddBraceStyle = braceStyle;
pOpt.EventRemoveBraceStyle = braceStyle;
pOpt.PropertyBraceStyle = braceStyle;
pOpt.PropertyGetBraceStyle = braceStyle;
pOpt.PropertySetBraceStyle = braceStyle;
pOpt.IndentationChar = this.Options.IndentString[0];
pOpt.IndentSize = this.Options.IndentString.Length;
pOpt.TabSize = this.Options.IndentString.Length;
return v;
}
public static string GenerateCode(CompilationUnit compilationUnit)
{
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor();
outputVisitor.VisitCompilationUnit(compilationUnit, null);
return outputVisitor.Text;
}
public virtual void PrintPreprocessingDirective(PreprocessingDirective directive, bool forceWriteInPreviousBlock)
{
if (!directive.Expression.IsNull) {
CSharpOutputVisitor visitor = new CSharpOutputVisitor();
directive.Expression.AcceptVisitor(visitor, null);
WriteLineInPreviousLine(directive.Cmd + " " + visitor.Text, forceWriteInPreviousBlock);
} else if (string.IsNullOrEmpty(directive.Arg))
WriteLineInPreviousLine(directive.Cmd, forceWriteInPreviousBlock);
else
WriteLineInPreviousLine(directive.Cmd + " " + directive.Arg, forceWriteInPreviousBlock);
}
protected NodeOutput OutputNode(int indentLevel, AstNode node, bool startWithNewLine = false)
{
var stringWriter = new StringWriter ();
var formatter = new SegmentTrackingTokenWriter(stringWriter);
formatter.Indentation = indentLevel;
formatter.IndentationString = Options.TabsToSpaces ? new string (' ', Options.IndentSize) : "\t";
stringWriter.NewLine = Options.EolMarker;
if (startWithNewLine)
formatter.NewLine ();
var visitor = new CSharpOutputVisitor (formatter, formattingOptions);
node.AcceptVisitor (visitor);
string text = stringWriter.ToString().TrimEnd();
return new NodeOutput(text, formatter.NewSegments);
}
string GetFormattedText (PolicyContainer policyParent, string input)
{
hasErrors = false;
if (string.IsNullOrEmpty (input))
return input;
CSharpOutputVisitor outputVisitor = new CSharpOutputVisitor ();
SetFormatOptions (outputVisitor, policyParent);
outputVisitor.OutputFormatter.IndentationLevel = startIndentLevel;
using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) {
parser.Parse ();
hasErrors = parser.Errors.Count != 0;
// if (hasErrors)
// Console.WriteLine (parser.Errors.ErrorOutput);
IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials ();
if (parser.Errors.Count == 0) {
using (SpecialNodesInserter.Install (specials, outputVisitor)) {
parser.CompilationUnit.AcceptVisitor (outputVisitor, null);
}
return outputVisitor.Text;
}
}
// Console.WriteLine ("trying to parse block.");
using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) {
BlockStatement blockStatement = parser.ParseBlock ();
hasErrors = parser.Errors.Count != 0;
// if (hasErrors)
// Console.WriteLine (parser.Errors.ErrorOutput);
IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials ();
if (parser.Errors.Count == 0) {
StringBuilder result = new StringBuilder ();
using (var inserter = SpecialNodesInserter.Install (specials, outputVisitor)) {
foreach (ICSharpCode.NRefactory.Ast.INode node in blockStatement.Children) {
node.AcceptVisitor (outputVisitor, null);
// result.AppendLine (outputVisitor.Text);
}
if (!outputVisitor.OutputFormatter.LastCharacterIsNewLine)
outputVisitor.OutputFormatter.NewLine ();
inserter.Finish ();
result.AppendLine (outputVisitor.Text);
}
return result.ToString ();
}
}
// Console.WriteLine ("trying to parse expression.");
using (ICSharpCode.NRefactory.IParser parser = ParserFactory.CreateParser (SupportedLanguage.CSharp, new StringReader (input))) {
Expression expression = parser.ParseExpression ();
hasErrors = parser.Errors.Count != 0;
// if (hasErrors)
// Console.WriteLine (parser.Errors.ErrorOutput);
IList<ISpecial> specials = parser.Lexer.SpecialTracker.RetrieveSpecials ();
if (parser.Errors.Count == 0) {
using (SpecialNodesInserter.Install (specials, outputVisitor)) {
expression.AcceptVisitor (outputVisitor, null);
}
return outputVisitor.Text;
}
}
return input;
}
public static void SetFormatOptions (CSharpOutputVisitor outputVisitor, PolicyContainer policyParent)
{
IEnumerable<string> types = DesktopService.GetMimeTypeInheritanceChain (MimeType);
TextStylePolicy currentPolicy = policyParent != null ? policyParent.Get<TextStylePolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<TextStylePolicy> (types);
CSharpFormattingPolicy codePolicy = policyParent != null ? policyParent.Get<CSharpFormattingPolicy> (types) : MonoDevelop.Projects.Policies.PolicyService.GetDefaultPolicy<CSharpFormattingPolicy> (types);
outputVisitor.Options.IndentationChar = currentPolicy.TabsToSpaces ? ' ' : '\t';
outputVisitor.Options.TabSize = currentPolicy.TabWidth;
outputVisitor.Options.IndentSize = currentPolicy.TabWidth;
outputVisitor.Options.EolMarker = TextStylePolicy.GetEolMarker(currentPolicy.EolMarker);
CodeFormatDescription descr = CSharpFormattingPolicyPanel.CodeFormatDescription;
Type optionType = outputVisitor.Options.GetType ();
foreach (CodeFormatOption option in descr.AllOptions) {
KeyValuePair<string, string> val = descr.GetValue (codePolicy, option);
PropertyInfo info = optionType.GetProperty (option.Name);
if (info == null) {
System.Console.WriteLine ("option : " + option.Name + " not found.");
continue;
}
object cval = null;
if (info.PropertyType.IsEnum) {
cval = Enum.Parse (info.PropertyType, val.Key);
} else if (info.PropertyType == typeof(bool)) {
cval = Convert.ToBoolean (val.Key);
} else {
cval = Convert.ChangeType (val.Key, info.PropertyType);
}
//System.Console.WriteLine("set " + option.Name + " to " + cval);
info.SetValue (outputVisitor.Options, cval, null);
}
}
private string LinqQueryToImplicitClass()
{
var parser = ParserFactory.CreateParser(SupportedLanguage.CSharp, new StringReader(source));
var block = parser.ParseBlock();
var visitor = new TransformVisitor();
block.AcceptVisitor(visitor, null);
VariableDeclaration variable = GetVariableDeclaration(block);
Name = variable.Name;
var type = new TypeDeclaration(Modifiers.Public, new List<AttributeSection>())
{
BaseTypes =
{
new TypeReference("AbstractViewGenerator")
},
Name = Name,
Type = ClassType.Class
};
var ctor = new ConstructorDeclaration(Name,
Modifiers.Public,
new List<ParameterDeclarationExpression>(), null);
type.Children.Add(ctor);
ctor.Body = new BlockStatement();
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(source, source))));
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(new TypeReference("System.Collections.Generic.IEnumerable<"+rootQueryType+">"), rootQueryName)
},
ExpressionBody = variable.Initializer
})));
var unit = new CompilationUnit();
unit.AddChild(new Using(typeof(AbstractViewGenerator).Namespace));
unit.AddChild(new Using(typeof(System.Linq.Enumerable).Namespace));
unit.AddChild(type);
var output = new CSharpOutputVisitor();
unit.AcceptVisitor(output, null);
return output.Text;
}
string GetShortType(IType type, CSharpResolver state)
{
var builder = new TypeSystemAstBuilder (state);
var shortType = builder.ConvertType (type);
using (var w = new System.IO.StringWriter ()) {
var visitor = new CSharpOutputVisitor (w, FormattingPolicy);
shortType.AcceptVisitor (visitor, null);
return w.ToString ();
}
}
public static string ToCSharp(this Expression expression)
{
var output = new CSharpOutputVisitor();
expression.AcceptVisitor(output, null);
return (output.Text);
}
internal static void Print(AstNode node)
{
var v = new CSharpOutputVisitor (Console.Out, new CSharpFormattingOptions ());
node.AcceptVisitor (v, null);
}
// this should use CodeGenerator and build a BlockStatement to work for both C# and VB
string GetSwitchBodyCode(IReturnType enumType, string indent, CodeGenerator generator)
{
if (generator == null)
return string.Empty;
ParseInformation parseInfo = ParserService.GetParseInformation(this.Editor.FileName);
var visitor = new CSharpOutputVisitor();
CodeGenerator.ConvertType(enumType, this.classFinderContext).AcceptVisitor(visitor, null);
var qualifiedEnumType = visitor.Text;
StringBuilder sb = new StringBuilder();
bool first = true;
foreach (var enumCase in GetEnumCases(enumType)) {
string qualifiedName = qualifiedEnumType + "." + enumCase.Name;
sb.AppendLine(string.Format((first ? "" : indent) + "case {0}:", qualifiedName));
sb.AppendLine(indent + context.Tab);
sb.AppendLine(indent + context.Tab + "break;");
first = false;
}
sb.AppendLine(indent + "default:");
sb.Append(string.Format(indent + context.Tab + "throw new Exception(\"Invalid value for {0}\");", enumType.Name));
return sb.ToString();
}
internal static void Print(AstNode node)
{
var v = new CSharpOutputVisitor (Console.Out, FormattingOptionsFactory.CreateMono ());
node.AcceptVisitor (v);
}
