public static string ReplaceStringLiteralsWithVariables(string text, IEnumerable<string> macros, Func<int, int, string, string, string> onReplace)
{
var setting = new CompilerSettings();
foreach (var macro in macros) setting.ConditionalSymbols.Add(macro);
var tree = SyntaxTree.Parse(text, string.Empty, setting);
tree.Freeze();
var doc = new StringBuilderDocument(text);
using (var editor = new DocumentScript(doc, FormattingOptionsFactory.CreateAllman(), TextEditorOptions.Default)) {
var originDoc = editor.OriginalDocument;
foreach (var node in tree.Descendants.OfType<PrimitiveExpression>().Where(e => e.Value is string)) {
var line = originDoc.GetLineByNumber(node.StartLocation.Line);
var result = onReplace(node.StartLocation.Line, node.StartLocation.Column, originDoc.GetText(line), node.Value as string);
if (result != null) {
var names = result.Split('.');
Expression exp = new IdentifierExpression(names.First());
foreach (var name in names.Skip(1)) exp = exp.Member(name);
editor.Replace(node, exp);
}
}
}
return doc.Text;
}
public static SyntaxTree Parse(ITextSource textSource, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default(CancellationToken))
{
cancellationToken.ThrowIfCancellationRequested();
var parser = new CSharpParser(settings);
return(parser.Parse(textSource, fileName));
}
public CSharpProjectContent()
{
this.unresolvedFiles = new Dictionary<string, IUnresolvedFile>(Platform.FileNameComparer);
this.assemblyReferences = new List<IAssemblyReference>();
this.compilerSettings = new CompilerSettings();
compilerSettings.Freeze();
}
public CSharpProjectContent()
{
this.unresolvedFiles = new Dictionary <string, IUnresolvedFile>(Platform.FileNameComparer);
this.assemblyReferences = new List <IAssemblyReference>();
this.compilerSettings = new CompilerSettings();
compilerSettings.Freeze();
}
protected CSharpProjectContent(CSharpProjectContent pc)
{
this.assemblyName = pc.assemblyName;
this.location = pc.location;
this.parsedFiles = new Dictionary <string, IParsedFile>(pc.parsedFiles, Platform.FileNameComparer);
this.assemblyReferences = new List <IAssemblyReference>(pc.assemblyReferences);
this.compilerSettings = pc.compilerSettings;
}
protected CSharpProjectContent(CSharpProjectContent pc)
{
this.assemblyName = pc.assemblyName;
this.parsedFiles = new Dictionary<string, IParsedFile>(pc.parsedFiles, Platform.FileNameComparer);
this.assemblyReferences = new List<IAssemblyReference>(pc.assemblyReferences);
this.compilerSettings = pc.CompilerSettings;
this.Location = pc.Location;
}
protected CSharpProjectContent(CSharpProjectContent pc)
{
this.assemblyName = pc.assemblyName;
this.fullAssemblyName = pc.fullAssemblyName;
this.projectFileName = pc.projectFileName;
this.location = pc.location;
this.unresolvedFiles = new Dictionary<string, IUnresolvedFile>(pc.unresolvedFiles, Platform.FileNameComparer);
this.assemblyReferences = new List<IAssemblyReference>(pc.assemblyReferences);
this.compilerSettings = pc.compilerSettings;
}
public static CompilationUnit Parse(Stream stream, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default(CancellationToken))
{
var parser = new CSharpParser();
if (settings != null)
{
parser.CompilerSettings = settings;
}
return(parser.Parse(stream, fileName, 0));
}
public CSharpProject(CSharpSolution solution, string title, string fileName)
{
Files = new List<CSharpFile>();
CompilerSettings = new CompilerSettings();
Solution = solution;
Title = title;
FileName = fileName;
LoadCSharpProject(solution, fileName);
}
public static ICSharpCode.NRefactory.CSharp.CompilerSettings GetCompilerArguments(MonoDevelop.Projects.Project project)
{
var compilerArguments = new ICSharpCode.NRefactory.CSharp.CompilerSettings();
// compilerArguments.TabSize = 1;
if (project == null || MonoDevelop.Ide.IdeApp.Workspace == null)
{
compilerArguments.AllowUnsafeBlocks = true;
return(compilerArguments);
}
var configuration = project.GetConfiguration(MonoDevelop.Ide.IdeApp.Workspace.ActiveConfiguration) as DotNetProjectConfiguration;
if (configuration == null)
{
return(compilerArguments);
}
foreach (var sym in configuration.GetDefineSymbols())
{
compilerArguments.ConditionalSymbols.Add(sym);
}
var par = configuration.CompilationParameters as CSharpCompilerParameters;
if (par == null)
{
return(compilerArguments);
}
compilerArguments.AllowUnsafeBlocks = par.UnsafeCode;
compilerArguments.LanguageVersion = ConvertLanguageVersion(par.LangVersion);
compilerArguments.CheckForOverflow = par.GenerateOverflowChecks;
compilerArguments.WarningLevel = par.WarningLevel;
compilerArguments.TreatWarningsAsErrors = par.TreatWarningsAsErrors;
if (!string.IsNullOrEmpty(par.NoWarnings))
{
foreach (var warning in par.NoWarnings.Split(';', ',', ' ', '\t'))
{
int w;
try {
w = int.Parse(warning);
} catch (Exception) {
continue;
}
compilerArguments.DisabledWarnings.Add(w);
}
}
return(compilerArguments);
}
public static CompilerSettings ToCompilerSettings(StructEx.CompilerSettings settings)
{
var compilerSettings = new CompilerSettings
{
AllowUnsafeBlocks = settings.AllowUnsafeBlocks,
CheckForOverflow = settings.CheckForOverflow
};
foreach(var symbol in settings.ConditionalSymbols)
{
compilerSettings.ConditionalSymbols.Add(symbol);
}
return compilerSettings;
}
public static void EnumStringLiterals(string fileName, IEnumerable<string> macros, Action<string, int, int, int, int, string> callback)
{
var setting = new CompilerSettings();
foreach (var macro in macros) setting.ConditionalSymbols.Add(macro);
var parser = new CSharpParser(setting);
var tree = parser.Parse(File.ReadAllText(fileName, Encoding.Default), fileName);
if (tree.Errors.Count > 0)
{
throw new Exception("Compile failed: " + string.Join("\n", tree.Errors.Select(e => e.Message)));
}
foreach (var node in tree.Descendants.OfType<PrimitiveExpression>().Where(n => n.Value is string))
{
callback(fileName, node.StartLocation.Line, node.StartLocation.Column, node.EndLocation.Line, node.EndLocation.Column, node.Value as string);
}
}
public static SyntaxTree Parse(Stream stream, string fileName = "", CompilerSettings settings = null, CancellationToken cancellationToken = default(CancellationToken))
{
var parser = new CSharpParser(settings);
return(parser.Parse(stream, fileName));
}
protected override object CreateCompilerSettings()
{
// This method gets called when the project content is first created;
// or when any of the ReparseSensitiveProperties has changed.
CompilerSettings settings = new CompilerSettings();
settings.AllowUnsafeBlocks = GetBoolProperty("AllowUnsafeBlocks") ?? false;
settings.CheckForOverflow = GetBoolProperty("CheckForOverflowUnderflow") ?? false;
string symbols = GetEvaluatedProperty("DefineConstants");
if (symbols != null) {
foreach (string symbol in symbols.Split(new char[] { ';', ',' }, StringSplitOptions.RemoveEmptyEntries)) {
settings.ConditionalSymbols.Add(symbol.Trim());
}
}
settings.Freeze();
compilerSettings = settings;
return settings;
}
void SetCompilerSettings(Microsoft.Build.Evaluation.Project p)
{
CompilerSettings = new CompilerSettings
{
AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false,
CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false
};
string[] defines = p.GetPropertyValue("DefineConstants")
.Split(new [] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string define in defines)
CompilerSettings.ConditionalSymbols.Add(define);
var config = ConfigurationLoader.Config;
foreach (var define in config.Defines)
CompilerSettings.ConditionalSymbols.Add(define);
}
public CSharpParser CreateParser()
{
var settings = new CompilerSettings();
return new CSharpParser(settings);
}
public CSharpProject(ISolution solution, string title, string fileName, Guid id)
{
_solution = solution;
Title = title;
FileName = fileName.ForceNativePathSeparator();
ProjectId = id;
Files = new List<CSharpFile>();
var p = new Microsoft.Build.Evaluation.Project(FileName);
AssemblyName = p.GetPropertyValue("AssemblyName");
_compilerSettings = new CompilerSettings
{
AllowUnsafeBlocks = GetBoolProperty(p, "AllowUnsafeBlocks") ?? false,
CheckForOverflow = GetBoolProperty(p, "CheckForOverflowUnderflow") ?? false,
};
string[] defines = p.GetPropertyValue("DefineConstants").Split(new[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string define in defines)
_compilerSettings.ConditionalSymbols.Add(define);
foreach (var item in p.GetItems("Compile"))
{
try
{
string path = Path.Combine(p.DirectoryPath, item.EvaluatedInclude).ForceNativePathSeparator();
if (File.Exists(path))
{
Files.Add(new CSharpFile(this, new FileInfo(path).FullName));
}
else
{
Console.WriteLine("File does not exist - " + path);
}
}
catch (NullReferenceException e)
{
Console.WriteLine(e);
}
}
References = new List<IAssemblyReference>();
string mscorlib = FindAssembly(AssemblySearchPaths, "mscorlib");
if (mscorlib != null)
AddReference(LoadAssembly(mscorlib));
else
Console.WriteLine("Could not find mscorlib");
bool hasSystemCore = false;
foreach (var item in p.GetItems("Reference"))
{
string assemblyFileName = null;
if (item.HasMetadata("HintPath"))
{
assemblyFileName = Path.Combine(p.DirectoryPath, item.GetMetadataValue("HintPath")).ForceNativePathSeparator();
if (!File.Exists(assemblyFileName))
assemblyFileName = null;
}
//If there isn't a path hint or it doesn't exist, try searching
if (assemblyFileName == null)
assemblyFileName = FindAssembly(AssemblySearchPaths, item.EvaluatedInclude);
//If it isn't in the search paths, try the GAC
if (assemblyFileName == null)
assemblyFileName = FindAssemblyInNetGac(item.EvaluatedInclude);
if (assemblyFileName != null)
{
if (Path.GetFileName(assemblyFileName).Equals("System.Core.dll", StringComparison.OrdinalIgnoreCase))
hasSystemCore = true;
Console.WriteLine("Loading assembly " + item.EvaluatedInclude);
try
{
AddReference(LoadAssembly(assemblyFileName));
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
else
Console.WriteLine("Could not find referenced assembly " + item.EvaluatedInclude);
}
if (!hasSystemCore && FindAssembly(AssemblySearchPaths, "System.Core") != null)
AddReference(LoadAssembly(FindAssembly(AssemblySearchPaths, "System.Core")));
foreach (var item in p.GetItems("ProjectReference"))
AddReference(new ProjectReference(_solution, item.GetMetadataValue("Name")));
this.ProjectContent = new CSharpProjectContent()
.SetAssemblyName(AssemblyName)
.AddAssemblyReferences(References)
.AddOrUpdateFiles(Files.Select(f => f.ParsedFile));
}
public CSharpProject(
ICSharpFileFactory cSharpFileFactory,
MicrosoftBuildProject msBuildProject,
string title)
{
Title = title;
AssemblyName = msBuildProject.AssemblyName;
FileName = msBuildProject.FileName;
CompilerSettings =
#region new CompilerSettings
new CompilerSettings
{
AllowUnsafeBlocks = msBuildProject.AllowUnsafeBlocks,
CheckForOverflow = msBuildProject.CheckForOverflowUnderflow,
};
CompilerSettings.ConditionalSymbols.AddRange(msBuildProject.DefineConstants);
#endregion
ProjectContent = new CSharpProjectContent();
ProjectContent = ProjectContent.SetAssemblyName(msBuildProject.AssemblyName);
ProjectContent = ProjectContent.SetProjectFileName(msBuildProject.FileName.FullPath);
ProjectContent = ProjectContent.SetCompilerSettings(CompilerSettings);
Files = msBuildProject.CompiledFileNames.Select(
f => cSharpFileFactory.BuildCSharpFile(this, new FilePath(f))).ToList();
ProjectContent = ProjectContent.AddOrUpdateFiles(
Files.Select(f => f.UnresolvedTypeSystemForFile));
ProjectContent = ProjectContent.AddAssemblyReferences(msBuildProject.ReferencedAssemblies);
}
// could depend just on IDocument
SyntaxTree ParseDocument(ITextEditor editor, out IList<AstNode> parsedSpecials)
{
parsedSpecials = null;
CompilerSettings compilerSettings = new CompilerSettings();
var parser = new CSharpParser();
if (parser == null) return null;
var syntaxTree = parser.Parse(editor.Document.CreateReader());
if (syntaxTree == null) return null;
parsedSpecials = new List<AstNode>(syntaxTree.Descendants.OfType<Comment>());
return syntaxTree;
}
