static void InitializePlatformSpecificTools()
{
Alt.Sketch.Config.Font_NoAntiAliasMaxSize = 5;
#if UNITY_5
Alt.Backend.BackendManager.Clipboard = new UnityClipboard();
UnityEngine.TextAsset bindata = UnityEngine.Resources.Load("AltData.zip", typeof(UnityEngine.TextAsset)) as UnityEngine.TextAsset;
if (bindata != null)
{
System.IO.MemoryStream stream = new System.IO.MemoryStream(bindata.bytes);
VirtualFileSystem.AddZipStorage(
"AltData.zip",
stream);
}
#else
VirtualFileSystem.AddZipStorage(
"AltData.zip",
VirtualFile.OpenRead("Assets/AltData.zip"));
#endif
Alt.Sketch.Config.AppendLogo(Bitmap.FromFile("AltData/Logo/Unity.jpg"));
UnityApplication.GetOrCreateInstance();
}
public ParserResult Parse(VirtualFile file)
{
log.LogVerbose($"Parse file {file.FullName}.");
List <CodeSpecificException> codeSpecificExceptions = new();
List <ParserMessage> messages = new();
CppStreamParser parser = new();
ParseNode root = parser.Parse(file.OpenRead());
if (!parser.Succeeded)
{
messages.Add(parser.Exception == null
? new ParserMessage("CPP0004", 1, 1)
: new ParserMessage("CPP0005", parser.Exception.Row, parser.Exception.Col,
$"{Environment.NewLine}{parser.Exception.Message}"));
codeSpecificExceptions.AddRange(messages.Select(m => m.ToException(file)));
return(new ParserResult(codeSpecificExceptions));
}
string[] usings = GetUsing(root);
IDictionary <IType, CodePosition> types = GetTypes(root, usings, messages);
string[] includes = GetIncludes(root);
Dictionary <string, string> defineStatements = GetDefineStatements(root);
IEnumerable <IConstant> constants = GetConstants(root, usings);
codeSpecificExceptions.AddRange(messages.Select(m => m.ToException(file)));
return(new ParserResult(codeSpecificExceptions, types, includes, defineStatements, constants));
}
public static IntPtr fs_open(string path)
{
IntPtr fid = IntPtr.Zero;
//if (mode == "r")
{
string fn = "Data/" + path;
if (VirtualFile.Exists(fn))
{
System.IO.Stream fs = VirtualFile.OpenRead(fn);
if (fs != null)
{
fid = new IntPtr(m_LastFileID++);
byte[] buffer = new byte[fs.Length];
fs.Read(buffer, 0, (int)fs.Length);
fs.Close();
fs = new System.IO.MemoryStream(buffer, false);
m_Files.Add(fid, new FileDescription(fs));
return(fid);
}
}
}
return(fid);
}
public void LoadCache(VirtualFile cacheFile)
{
try
{
Stopwatch loadWatch = new Stopwatch();
loadWatch.Start();
using (Stream fileStream = cacheFile.OpenRead())
using (TextReader reader = new StreamReader(fileStream))
using (JsonReader jsonReader = new JsonTextReader(reader))
{
JsonSerializer serializer = CreateSerializer();
IncludeCacheEntry[] result = serializer.Deserialize <IncludeCacheEntry[]>(jsonReader);
cache = result?.ToDictionary(r => r.File, r => r) ?? new Dictionary <string, IncludeCacheEntry>();
this.cacheFile = cacheFile;
}
loadWatch.Stop();
log.LogInformation($"Successfully loaded the include cache in {loadWatch.ElapsedMilliseconds} ms.");
}
catch (Exception e)
{
log.LogError($"Error while parsing include cache file, using empty cache.{Environment.NewLine}{e}");
cache = new Dictionary <string, IncludeCacheEntry>();
this.cacheFile = cacheFile;
}
}
public void LoadCache(VirtualFile cacheFile)
{
using (Stream fileStream = cacheFile.OpenRead())
{
LoadFrom(fileStream);
}
this.cacheFile = cacheFile;
}
public async Task <VirtualFile> DownloadVersion(string version, VirtualDirectory downloadDirectory,
IProgressNotifier parentProgress = null,
string proxy = "")
{
await EnsureRepository(proxy).ConfigureAwait(false);
string actualVersion = await CheckVersion(version, proxy).ConfigureAwait(false);
CliVersionDefinition versionDefinition = repository.Version.FirstOrDefault(v => v.GetInformalVersion() == actualVersion);
if (versionDefinition == null)
{
throw new UnkownVersionException(actualVersion);
}
FileDefinition downloadFile = GetCorrectVersion();
if (downloadFile == null)
{
throw new UnsupportedSystemException(environmentService.PlatformName, environmentService.Architecture);
}
Uri downloadUri = InvalidUriFormatException.TryCreateUri(downloadFile.relPath,
InvalidUriFormatException.TryCreateUri(settingsProvider.Settings.CliRepositoryRoot));
VirtualFile result = downloadDirectory.File(downloadFile.name);
using (Stream fileStream = result.OpenWrite())
{
await Download(downloadUri, fileStream, proxy, parentProgress).ConfigureAwait(false);
}
using (Stream fileStream = result.OpenRead())
{
try
{
securityValidator.ValidateHash(fileStream, downloadFile.Fingerprint.hash, downloadFile.Fingerprint.algorithm);
}
catch (HashValidationException e)
{
e.ValidationFileName = downloadUri.AbsolutePath;
throw;
}
}
return(result);
FileDefinition GetCorrectVersion()
{
FileDefinition[] correctArchitecture = versionDefinition.File
.Where(f => f.Architecture.ToString().Equals(environmentService.Architecture,
StringComparison.OrdinalIgnoreCase))
.ToArray();
return(correctArchitecture.FirstOrDefault(f => f.OS.ToString().Equals(environmentService.PlatformName,
StringComparison.OrdinalIgnoreCase)) ??
correctArchitecture.FirstOrDefault(f => f.OS == OSDefinition.unbound));
}
}
public string MoveApplicationFile(string fileName, string newLocation)
{
VirtualFile oldFile = FileSystem.GetFile(Path.Combine(AssemblyDirectory, fileName));
VirtualFile newFile = FileSystem.GetFile(Path.Combine(AssemblyDirectory, newLocation));
using (Stream source = oldFile.OpenRead())
using (Stream destination = newFile.OpenWrite())
{
source.CopyTo(destination);
}
return(newFile.FullName);
}
private Settings LoadSettings()
{
string path = SettingsPath;
if (!fileSystem.FileExists(path))
{
log.LogInformation("No settings file found. Use default settings:");
Settings result = new Settings();
log.LogInformation(JsonConvert.SerializeObject(result, Formatting.Indented));
return(result);
}
VirtualFile file = fileSystem.GetFile(path);
using (Stream stream = file.OpenRead())
{
XDocument document = XDocument.Load(stream);
IEnumerable <string> paths = document.Descendants("SDKS").Any()
? document.Descendants("SDK").Select(d => d.Value)
: Settings.SdkPathsDefault;
IEnumerable <string> templates = document.Descendants("Templates").Any()
? document.Descendants("Template").Select(d => d.Value)
: Settings.TemplateLocationsDefault;
string attributePrefix = document.Descendants("Settings").FirstOrDefault()?
.Attribute("AttributePrefix")?.Value
?? Settings.AttributePrefixDefault;
string cliRpositoryRoot = document.Descendants("Settings").FirstOrDefault()?
.Element("CliRepositoryRoot")?.Value
?? Settings.CliRepositoryRootDefault;
string cliRpositoryFileName = document.Descendants("Settings").FirstOrDefault()?
.Element("CliRepositoryFileName")?.Value
?? Settings.CliRepositoryFileNameDefault;
string cliRpositorySignatureFileName = document.Descendants("Settings").FirstOrDefault()?
.Element("CliRepositorySignatureFileName")?.Value
?? Settings.CliRepositorySignatureFileNameDefault;
string httpProxy = document.Descendants("Settings").FirstOrDefault()?
.Element("HttpProxy")?.Value
?? Settings.HttpProxyDefault;
string logFilePath = document.Descendants("Settings").FirstOrDefault()?
.Element("LogFilePath")?.Value
?? Settings.LogFilePathDefault;
bool systemCommands = bool.TryParse(document.Descendants("Settings").FirstOrDefault()?
.Element("SystemCommands")?.Value, out bool parsed)
? parsed
: Settings.UseSystemCommandsDefault;
log.LogInformation($"Used settings {file.FullName}:");
Settings result = new Settings(attributePrefix, paths.ToArray(), cliRpositoryRoot, cliRpositoryFileName, cliRpositorySignatureFileName, httpProxy, logFilePath, templates.ToArray(), systemCommands);
log.LogInformation(JsonConvert.SerializeObject(result, Formatting.Indented));
return(result);
}
}
public override Entity Resolve(Entity owner, string key, bool fallback = false)
{
switch (key)
{
case EntityKeys.BuildTypeKey:
string buildType = GetBuildType(owner);
return(owner.Create(key, buildType));
case EntityKeys.InternalBuildSystemDirectoryKey:
VirtualDirectory directory = GetBuildSystemDirectory(owner, false);
return(owner.Create(key, directory));
case EntityKeys.InternalBuildSystemKey:
VirtualDirectory buildSystemDirectory = GetBuildSystemDirectory(owner);
JArray codeModel = GetCodeModel(owner, buildSystemDirectory);
return(owner.Create(key, codeModel, buildSystemDirectory));
case EntityKeys.InternalExternalLibrariesKey:
IEnumerable <string> externalLibraries = FindExternalLibrariesInCodeModel(owner.Value <JArray>(),
owner.Root.Name,
owner.Value <VirtualDirectory>());
return(owner.Create(key, externalLibraries.Select(l => owner.Create(key, l))));
case EntityKeys.InternalInstallationPathsKey:
IEnumerable <string> installationPaths = FindInstallationPaths(owner.Value <JArray>(),
owner.Root.Name);
return(owner.Create(key, installationPaths.Select(p => owner.Create(key, p))));
default:
VirtualFile cmakeFile = GetCMakeFile(owner);
using (Stream fileStream = cmakeFile.OpenRead())
using (StreamReader reader = new StreamReader(fileStream))
{
while (!reader.EndOfStream)
{
string line = reader.ReadLine();
if (string.IsNullOrEmpty(line))
{
continue;
}
Match projectNameMatch = projectNameFinder.Match(line);
if (projectNameMatch.Success)
{
return(owner.Create(key, projectNameMatch.Groups["name"].Value));
}
}
}
return(owner.Create(key, Path.GetFileName(owner.Path)));
}
}
public static T Load <T>(this VirtualFile file)
where T : class
{
try
{
using (Stream stream = file.OpenRead())
{
XmlSerializer xs = XmlSerializer(typeof(T));
return(xs.Deserialize(stream) as T);
}
}
catch (Exception ex)
{
// do nothing
}
return(default(T));
}
private BinaryLocator GetLocator(string baseDirectory)
{
if (locators.ContainsKey(baseDirectory))
{
return(locators[baseDirectory]);
}
if (fileSystem.FileExists(Path.Combine(baseDirectory, Constants.FileNamesFile)))
{
VirtualFile fileNamesFile = fileSystem.GetFile(Path.Combine(baseDirectory, Constants.FileNamesFile));
using (Stream stream = fileNamesFile.OpenRead())
{
XDocument document = XDocument.Load(stream);
Dictionary <string, VirtualFile> executables = new Dictionary <string, VirtualFile>();
foreach (XElement element in document.Element("names")?.Elements() ??
Enumerable.Empty <XElement>())
{
string name = element.Name.LocalName;
string partPath = element.Attribute("path")?.Value ?? string.Empty;
string path = Path.Combine(baseDirectory,
partPath.Replace("/", $"{Path.DirectorySeparatorChar}"));
if (environmentService.Platform == OSPlatform.Windows)
{
path = path + ".exe";
}
if (fileSystem.FileExists(path))
{
executables.Add(name, fileSystem.GetFile(path));
}
else
{
userInterface.WriteVerbose($"While locating binaries the following file was not found {path}.");
}
}
locators.Add(baseDirectory, new BinaryLocator(executables));
}
}
else
{
locators.Add(baseDirectory, new BinaryLocator(new Dictionary <string, VirtualFile>()));
}
return(locators[baseDirectory]);
}
public IEnumerable <Entity> FindAllEntities(string entityName, Entity owner)
{
if (!owner.HasPathCommandArgument())
{
executionContext.WriteVerbose("The executed command lacks the path argument, no project file can be loaded.");
return(Enumerable.Empty <Entity>());
}
string rootFilePath = fileSystem.GetDirectory(owner.GetPathCommandArgument(), createNew: false)
.FullName;
VirtualFile file = fileSystem.FileExists(rootFilePath)
? fileSystem.GetFile(rootFilePath)
: fileSystem.FileExists(Constants.ProjectFileName, rootFilePath)
? fileSystem.GetFile(Constants.ProjectFileName, rootFilePath)
: null;
if (file == null)
{
executionContext.WriteVerbose($"No project file found in {rootFilePath}.");
return(Enumerable.Empty <Entity>());
}
try
{
using (Stream fileStream = file.OpenRead())
using (XmlReader reader = XmlReader.Create(fileStream))
{
XmlSerializer serializer = new XmlSerializer(typeof(ProjectSettings));
ProjectSettings settings = (ProjectSettings)serializer.Deserialize(reader);
if (settings.Type != null && settings.Type.Equals(entityName, StringComparison.Ordinal))
{
return new[] { owner.Create(entityName, new ProjectDescription(settings, file.Parent, file)) }
}
;
}
}
catch (Exception e)
{
executionContext.WriteVerbose($"Error while trying to parse project settings {file.FullName}." +
$"{Environment.NewLine}{e}");
}
return(Enumerable.Empty <Entity>());
}
public static T LoadJson <T>(this VirtualFile file)
where T : class
{
try
{
using (Stream stream = file.OpenRead())
using (StreamReader sr = new StreamReader(stream))
{
JsonSerializer xs = new JsonSerializer();
return(xs.Deserialize(sr, typeof(T)) as T);
}
}
catch (Exception ex)
{
// do nothing
}
return(default(T));
}
public void DeployFiles(Entity dataModel)
{
IEnumerable <Entity> deployableEntities = dataModel.Root.Hierarchy();
ProjectEntity project = ProjectEntity.Decorate(dataModel.Root);
// get targets to deploy for
IEnumerable <Target> targets = null;
CommandEntity command = CommandEntity.Decorate(dataModel);
if (command.IsCommandArgumentSpecified(Constants.TargetArgumentName))
{
IEnumerable <string> rawTargets = command.GetMultiValueArgument(Constants.TargetArgumentName);
if (rawTargets.Any())
{
targets = targetParser.GetSpecificTargets(rawTargets, false).Select(t => t.Item1);
}
else
{
targets = targetParser.Targets(project, false).ValidTargets;
}
}
else
{
targets = targetParser.Targets(project, false).ValidTargets;
}
if (!targets.Any())
{
throw new NoTargetSpecifiedException();
}
foreach (Entity deployableEntity in deployableEntities)
{
DeployFilesFromTemplate(deployableEntity);
}
if (command.IsCommandArgumentSpecified(Constants.FilesArgumentName))
{
IEnumerable <string> files = command.GetMultiValueArgument(Constants.FilesArgumentName);
foreach (string file in files)
{
DeployFileFromArgument(file);
}
}
void DeployFileFromArgument(string file)
{
Match match = FilesDecoder.Match(file);
if (!match.Success)
{
throw new FormattableException($"The input {file} could not be parsed. Expected pattern is <fileLocation>|<destination>[|<target>]");
}
string from = match.Groups["from"].Value;
string to = match.Groups["destination"].Value;
string rawTarget = match.Groups["target"].Value;
VirtualDirectory baseDirectory = null;
string relativePath = null;
bool recreateStructure = false;
string[] path = fileSystem.GetPath(from);
int firstWildCard = path.TakeWhile(p => !p.Contains('*') && !p.Contains('?')).Count();
if (firstWildCard != path.Length)
{
baseDirectory = fileSystem.GetDirectory(Path.Combine(path.Take(firstWildCard).ToArray()), project.Path, false);
relativePath = Path.Combine(path.Skip(firstWildCard).ToArray());
recreateStructure = true;
}
if (recreateStructure)
{
IEnumerable <VirtualFile> deployFiles = baseDirectory.Files(relativePath, true).ToArray();
if (!deployFiles.Any())
{
throw new DeployFileNotFoundException(@from);
}
foreach (VirtualFile deployFile in deployFiles)
{
string structure = Path.GetDirectoryName(deployFile.GetRelativePath(baseDirectory));
string fileDestination = string.IsNullOrEmpty(structure) ? to : Path.Combine(to, structure);
DeployFile(deployFile.FullName, fileDestination);
}
}
else if (fileSystem.FileExists(from, project.Path))
{
DeployFile(from, to);
}
else
{
throw new DeployFileNotFoundException(@from);
}
void DeployFile(string sourceFile, string destinationDirectory)
{
if (!string.IsNullOrEmpty(rawTarget))
{
DeployFileForRawTarget(rawTarget, sourceFile, destinationDirectory);
}
else
{
foreach (Target target in targets)
{
DeployFileForTarget(target, sourceFile, destinationDirectory);
}
}
}
void DeployFileForRawTarget(string target, string sourceFile, string destinationDirectory)
{
Target parsedTarget = targetParser.ParseTarget(target, null, targets);
DeployFileForTarget(parsedTarget, sourceFile, destinationDirectory);
}
void DeployFileForTarget(Target target, string sourceFile, string destinationDirectory)
{
VirtualFile fileToCopy = fileSystem.GetFile(sourceFile, project.Path);
VirtualFile copiedFile = fileSystem.GetDirectory(destinationDirectory, GetOutputDirectory(target).FullName).File(fileToCopy.Name);
using (Stream source = fileToCopy.OpenRead(true))
using (Stream destination = copiedFile.OpenWrite())
{
destination.SetLength(0);
source.CopyTo(destination);
executionContext.WriteVerbose($"Deployed file {fileToCopy.FullName} to {copiedFile.FullName}.");
}
}
}
void DeployFilesFromTemplate(Entity deployableEntity)
{
TemplateDescription template = deployableEntity.Template();
if (template == null)
{
return;
}
foreach (templateFile file in template.File)
{
if (!file.deployPathSpecified)
{
continue;
}
VirtualFile deployableFile = GetFile(file, dataModel.Root.Path, false, out string path);
DeployFile(file, deployableFile, path);
}
foreach (templateGeneratedFile generatedFile in template.GeneratedFile ?? Enumerable.Empty <templateGeneratedFile>())
{
if (!generatedFile.deployPathSpecified)
{
continue;
}
VirtualFile deployableFile = GetFile(generatedFile, dataModel.Root.Path, true, out string path);
DeployFile(generatedFile, deployableFile, path);
}
VirtualFile GetDestination(templateFile file, Target target, string name)
{
string basePath = GetOutputDirectory(target).FullName;
string path = resolver.Resolve(file.deployPath ?? string.Empty, deployableEntity);
VirtualFile destination = fileSystem.GetFile(Path.Combine(path, name), basePath);
return(destination);
}
void DeployFile(templateFile file, VirtualFile deployableFile, string filePath)
{
if (deployableFile == null)
{
executionContext.WriteVerbose($"Could not find file {filePath} in {dataModel.Root.Path}, the file will not be deployed.");
return;
}
foreach (Target target in targets)
{
VirtualFile destination = GetDestination(file, target, deployableFile.Name);
using (Stream source = deployableFile.OpenRead(true))
using (Stream dest = destination.OpenWrite())
{
dest.SetLength(0);
source.CopyTo(dest);
}
executionContext.WriteVerbose($"Deployed file {deployableFile.FullName} to {destination.FullName}.");
}
}
VirtualFile GetFile(templateFile file, string basePath, bool isGeneratedFile, out string realFilePath)
{
string path = resolver.Resolve(file.path ?? string.Empty, deployableEntity);
string name = resolver.Resolve(file.name, deployableEntity);
if (isGeneratedFile && file is templateGeneratedFile generatedFile)
{
realFilePath = Path.Combine(path, name);
if (!Path.IsPathRooted(realFilePath))
{
realFilePath = Path.Combine(Constants.IntermediateFolderName, generatedFile.generator?.ToLowerInvariant() ?? string.Empty, realFilePath);
}
}
else
{
realFilePath = Path.Combine(path, name);
}
VirtualFile destination = fileSystem.FileExists(realFilePath, basePath)
? fileSystem.GetFile(realFilePath, basePath)
: null;
return(destination);
}
}
VirtualDirectory GetOutputDirectory(Target target)
{
string buildTypeFolder = command.IsCommandArgumentSpecified(Constants.BuildTypeArgumentName)
? FormatBuildType(command.GetSingleValueArgument(Constants.BuildTypeArgumentName))
: Constants.ReleaseFolderName;
string basePath = project.Path;
if (!command.IsCommandArgumentSpecified(Constants.OutputArgumentName))
{
return(fileSystem.GetDirectory(Path.Combine(basePath, Constants.LibraryFolderName, target.GetFullName().Replace(',', '_'),
buildTypeFolder)));
}
basePath = fileSystem.GetDirectory(command.GetSingleValueArgument(Constants.OutputArgumentName), basePath).FullName;
basePath = Path.Combine(basePath, target.GetFullName().Replace(',', '_'), buildTypeFolder);
return(fileSystem.GetDirectory(basePath));
string FormatBuildType(string buildType)
{
if (string.IsNullOrEmpty(buildType))
{
return(Constants.ReleaseFolderName);
}
return(buildType.Substring(0, 1).ToUpperInvariant() +
buildType.Substring(1).ToLowerInvariant());
}
}
}
public override Entity Resolve(Entity owner, string key, bool fallback = false)
{
switch (key)
{
case EntityKeys.ProjectConfigurationsKey:
return(GetProjectConfiguration());
case EntityKeys.EngineerVersionKey:
return(GetEngineerVersion());
case EntityKeys.SolutionVersionKey:
return(GetSolutionVersion());
case EntityKeys.LibraryDescriptionKey:
return(GetLibraryDescription());
case EntityKeys.LibraryVersionKey:
return(GetLibraryVersion());
default:
throw new ContentProviderException(key, owner);
}
Entity GetProjectConfiguration()
{
if (!owner.HasPath)
{
executionContext.WriteVerbose("The executed command lacks the path argument, no project configuration can be loaded.");
return(owner.Create(key, new ProjectConfigurations()));
}
string rootFilePath = fileSystem.GetDirectory(owner.Path, createNew: false)
.FullName;
string projectDirectory = fileSystem.FileExists(rootFilePath)
? Path.GetDirectoryName(rootFilePath)
: rootFilePath;
VirtualFile file = fileSystem.DirectoryExists(projectDirectory) &&
fileSystem.FileExists(Path.Combine(projectDirectory, Constants.ConfigFileName))
? fileSystem.GetFile(Path.Combine(projectDirectory, Constants.ConfigFileName))
: null;
if (file == null)
{
executionContext.WriteVerbose($"No config file found in {projectDirectory}.");
return(owner.Create(key, new ProjectConfigurations()));
}
try
{
using (Stream fileStream = file.OpenRead())
using (XmlReader reader = XmlReader.Create(fileStream))
{
XmlSerializer serializer = new XmlSerializer(typeof(ProjectConfiguration));
ProjectConfiguration configuration = (ProjectConfiguration)serializer.Deserialize(reader);
if (configuration != null)
{
return(owner.Create(key, new ProjectConfigurations(configuration, file)));
}
}
}
catch (DeployArgumentsException)
{
throw;
}
catch (Exception e)
{
executionContext.WriteVerbose($"Error while trying to parse project configuration {file.FullName}." +
$"{Environment.NewLine}{e}");
}
return(owner.Create(key, new ProjectConfigurations()));
}
Entity GetEngineerVersion()
{
CommandEntity command = CommandEntity.Decorate(owner.Origin);
ProjectEntity project = ProjectEntity.Decorate(owner);
if (command.CommandName.Equals("deploy", StringComparison.OrdinalIgnoreCase) &&
command.IsCommandArgumentSpecified(Constants.EngineerVersionArgumentKey))
{
if (command.IsCommandArgumentSpecified(Constants.SolutionVersionArgumentKey))
{
throw new DeployArgumentsException();
}
string value = command.GetSingleValueArgument(Constants.EngineerVersionArgumentKey);
project.Configuration.EngineerVersion = value;
return(owner.Create(key, value));
}
return(owner.Create(key, project.Configuration.EngineerVersion));
}
Entity GetSolutionVersion()
{
CommandEntity command = CommandEntity.Decorate(owner.Origin);
ProjectEntity project = ProjectEntity.Decorate(owner);
if (command.CommandName.Equals("deploy", StringComparison.OrdinalIgnoreCase) &&
command.IsCommandArgumentSpecified(Constants.SolutionVersionArgumentKey))
{
if (command.IsCommandArgumentSpecified(Constants.EngineerVersionArgumentKey))
{
throw new DeployArgumentsException();
}
string value = command.GetSingleValueArgument(Constants.SolutionVersionArgumentKey);
project.Configuration.SolutionVersion = value;
return(owner.Create(key, value));
}
return(owner.Create(key, project.Configuration.SolutionVersion));
}
Entity GetLibraryDescription()
{
CommandEntity command = CommandEntity.Decorate(owner.Origin);
ProjectEntity project = ProjectEntity.Decorate(owner);
if (command.CommandName.Equals("deploy", StringComparison.OrdinalIgnoreCase) &&
command.IsCommandArgumentSpecified(Constants.DescriptionArgumentKey))
{
string value = command.GetSingleValueArgument(Constants.DescriptionArgumentKey);
project.Configuration.LibraryDescription = value;
return(owner.Create(key, value));
}
return(owner.Create(key, project.Configuration.LibraryDescription));
}
Entity GetLibraryVersion()
{
CommandEntity command = CommandEntity.Decorate(owner.Origin);
ProjectEntity project = ProjectEntity.Decorate(owner);
if (command.CommandName.Equals("deploy", StringComparison.OrdinalIgnoreCase) &&
command.IsCommandArgumentSpecified(Constants.VersionArgumentKey))
{
string value = command.GetSingleValueArgument(Constants.VersionArgumentKey);
project.Configuration.LibraryVersion = value;
return(owner.Create(key, value));
}
return(owner.Create(key, project.Configuration.LibraryVersion));
}
}
public ParserResult Parse(VirtualFile file)
{
log.LogVerbose($"Parse file {file.FullName}.");
List <CodeSpecificException> codeSpecificExceptions = new List <CodeSpecificException>();
List <ParserMessage> messages = new List <ParserMessage>();
IDictionary <IType, CodePosition> types = new Dictionary <IType, CodePosition>();
CppStreamParser parser = new CppStreamParser();
ParseNode root = parser.Parse(file.OpenRead());
if (!parser.Succeeded)
{
messages.Add(parser.Exception == null
? new ParserMessage("CPP0004", 1, 1)
: new ParserMessage("CPP0005", parser.Exception.Row, parser.Exception.Col,
$"{Environment.NewLine}{parser.Exception.Message}"));
codeSpecificExceptions.AddRange(messages.Select(m => m.ToException(file)));
return(new ParserResult(codeSpecificExceptions));
}
string[] usings = GetUsings();
foreach (ParseNode typeDeclaration in GetTypeDeclarations(root))
{
ParseNode content = GetDeclarationContentParent(typeDeclaration);
if (content != null && IsValidDecalration(content, typeDeclaration))
{
string name = GetName(typeDeclaration);
string ns = GetNamespace(typeDeclaration);
switch (typeDeclaration[1].RuleName)
{
case "struct_decl":
CppStructure structure = new CppStructure(ns, name, usings, content, messages, typeDeclaration,
settingsProvider.Settings.AttributePrefix);
types.Add(structure, new CodePosition(typeDeclaration.Position.line, typeDeclaration.Position.column));
break;
case "class_decl":
CppClass cppClass = new CppClass(ns, name, usings, content, typeDeclaration[1], messages,
settingsProvider.Settings.AttributePrefix);
types.Add(cppClass, new CodePosition(typeDeclaration.Position.line, typeDeclaration.Position.column));
break;
case "enum_decl":
CppEnum cppEnum = new CppEnum(ns, name, usings, content, messages, typeDeclaration[1],
settingsProvider.Settings.AttributePrefix);
types.Add(cppEnum, new CodePosition(typeDeclaration.Position.line, typeDeclaration.Position.column));
break;
default:
//do nothing
break;
}
}
}
codeSpecificExceptions.AddRange(messages.Select(m => m.ToException(file)));
string[] includes = GetIncludes();
return(new ParserResult(codeSpecificExceptions, types, includes));
bool IsValidDecalration(ParseNode content, ParseNode typeDeclaration)
{
return(content.Count >= 2 &&
content.Any(c => c.GetHierarchy().Contains(typeDeclaration)) &&
content.SkipWhile(c => !c.GetHierarchy().Contains(typeDeclaration))
.Skip(1).Any(c => c.GetHierarchy().Any(n => n.RuleName == "brace_group")));
}
string GetName(ParseNode typeDeclaration)
{
ParseNode leaf = typeDeclaration.GetHierarchy()
.FirstOrDefault(n => n.RuleName == "identifier" ||
n.RuleName == "generic");
if (leaf == null)
{
return(Guid.NewGuid().ToByteString());
}
return(leaf.ToString());
}
ParseNode GetDeclarationContentParent(ParseNode current)
{
while (current != null &&
current.RuleType != "plus" &&
current.RuleName != "declaration_content")
{
current = current.GetParent();
}
return(current);
}
IEnumerable <ParseNode> GetTypeDeclarations(ParseNode current)
{
foreach (ParseNode node in current)
{
if (node.RuleType == "sequence" && node.RuleName == "type_decl")
{
yield return(node);
}
else
{
foreach (ParseNode child in GetTypeDeclarations(node))
{
yield return(child);
}
}
}
}
string[] GetIncludes()
{
List <string> result = new List <string>();
foreach (ParseNode includeNode in root.GetHierarchy().Where(n => n.RuleType == "sequence" &&
n.RuleName == "pp_directive" &&
n.Any(c => c.ToString().Equals("include", StringComparison.OrdinalIgnoreCase))))
{
ParseNode include = includeNode.FirstOrDefault(n => n.RuleName == "until_eol");
if (include != null)
{
result.Add(include.ToString().Trim('\"'));
}
}
return(result.ToArray());
}
string[] GetUsings()
{
List <string> result = new List <string>();
foreach (ParseNode usingNode in root.GetHierarchy().Where(n => n.RuleType == "leaf" &&
n.RuleName == "identifier" &&
n.ToString() == "using"))
{
ParseNode declarationParent = GetDeclarationContentParent(usingNode);
string[] identifier = declarationParent.ChildrenSkipUnnamed()
.Select(Identifier)
.Where(i => i != null)
.Select(i => i.ToString())
.ToArray();
if (identifier.Length > 2 && identifier[0] == "using" && identifier[1] == "namespace")
{
result.Add(identifier.Skip(2).Aggregate(string.Empty, (s, s1) => s + s1));
}
}
return(result.ToArray());
}
ParseNode Identifier(ParseNode parent)
{
if (parent.RuleType == "choice" && parent.RuleName == "node")
{
ParseNode result = parent.FirstOrDefault();
if (result?.RuleType == "leaf" && result.RuleName == "identifier")
{
return(result);
}
}
return(null);
}
string GetNamespace(ParseNode typeDeclaration)
{
ParseNode declarationParent;
typeDeclaration = GetDeclarationContentParent(typeDeclaration).GetParent();
string result = string.Empty;
while ((declarationParent = GetDeclarationContentParent(typeDeclaration)) != null)
{
string[] identifier = declarationParent.ChildrenSkipUnnamed()
.Where(r => r.RuleName != "comment_set")
.Select(Identifier)
.TakeWhile(i => i != null)
.Select(i => i.ToString())
.ToArray();
if (identifier.Length > 1 && identifier[0] == "namespace")
{
result = $"{identifier.Skip(1).Aggregate(string.Empty, (s, s1) => s + s1)}::{result}";
}
else if (identifier.Length == 0)
{
ParseNode parentTypeDeclaration = declarationParent.ChildrenSkipUnnamed()
.Where(c => c.RuleType == "choice" &&
c.RuleName == "node")
.SelectMany(c => c.ChildrenSkipUnnamed())
.FirstOrDefault(
c => c.RuleType == "sequence" &&
c.RuleName == "type_decl");
ParseNode name = parentTypeDeclaration?.GetHierarchy()
.FirstOrDefault(n => n.RuleType == "leaf" &&
n.RuleName == "identifier");
if (name != null)
{
result = $"{name}::{result}";
}
}
typeDeclaration = declarationParent.GetParent();
}
if (!string.IsNullOrEmpty(result))
{
result = result.Substring(0, result.Length - 2);
}
return(result);
}
}
public IReadOnlyCollection <TemplateLoaderResult> LoadTemplates()
{
List <TemplateLoaderResult> result = new List <TemplateLoaderResult>();
XmlSerializer templatesSerializer = new XmlSerializer(typeof(Templates.Templates));
XmlSerializer templateDescriptionSerializer = new XmlSerializer(typeof(TemplateDescription));
XmlSerializer fieldTemplateSerializer = new XmlSerializer(typeof(FieldTemplates));
XmlSerializer typeTemplateSerializer = new XmlSerializer(typeof(TypeTemplates));
XmlSerializer formatTemplateSerializer = new XmlSerializer(typeof(FormatTemplates));
foreach (string templateLocation in settingsProvider.Settings.TemplateLocations)
{
try
{
if (!fileSystem.FileExists(templateLocation, environmentService.AssemblyDirectory))
{
executionContext.WriteWarning($"The template location {templateLocation} does not point to an existing file." +
" Fix problems with template or remove the location from the settings.");
continue;
}
VirtualFile baseFile = fileSystem.GetFile(templateLocation, environmentService.AssemblyDirectory);
Templates.Templates templates;
using (Stream fileStream = baseFile.OpenRead())
using (XmlReader reader = XmlReader.Create(fileStream))
{
templates = (Templates.Templates)templatesSerializer.Deserialize(reader);
}
foreach (include include in templates.Include)
{
string path = include.Value.Replace('\\', Path.DirectorySeparatorChar)
.Replace('/', Path.DirectorySeparatorChar);
path = Path.Combine(baseFile.Parent.FullName, path);
using (Stream includeStream = fileSystem.GetFile(path).OpenRead())
using (XmlReader reader = XmlReader.Create(includeStream))
{
switch (include.type)
{
case includeType.Template:
result.Add(new TemplateLoaderResult(
templateDescriptionSerializer.Deserialize(reader),
Path.GetDirectoryName(path)));
break;
case includeType.Fields:
result.Add(new TemplateLoaderResult(
fieldTemplateSerializer.Deserialize(reader),
Path.GetDirectoryName(path)));
break;
case includeType.Types:
result.Add(new TemplateLoaderResult(
typeTemplateSerializer.Deserialize(reader),
Path.GetDirectoryName(path)));
break;
case includeType.Format:
result.Add(new TemplateLoaderResult(
formatTemplateSerializer.Deserialize(reader),
Path.GetDirectoryName(path)));
break;
default:
throw new InvalidOperationException();
}
}
}
}
catch (InvalidOperationException e)
{
executionContext.WriteWarning($"The template {templateLocation} could not be loaded. See log for details.");
executionContext.WriteWarning($"Fix problems with template or remove template {templateLocation} from the settings", false);
executionContext.WriteError(e.ToString(), false);
}
}
MergeTemplates(result.Select(r => r.Template)
.OfType <TemplateDescription>()
.ToArray());
return(result);
void MergeTemplates(TemplateDescription[] descriptions)
{
List <TemplateDescription> merged = new List <TemplateDescription>();
foreach (TemplateDescription templateDescription in descriptions)
{
MergeTemplate(templateDescription);
}
void MergeTemplate(TemplateDescription templateDescription)
{
TemplateDescription baseDescription = GetBaseDescription();
if (baseDescription != null)
{
if (!merged.Contains(baseDescription))
{
MergeTemplate(baseDescription);
}
templateDescription.Merge(baseDescription);
}
merged.Add(templateDescription);
TemplateDescription GetBaseDescription()
{
return(descriptions.FirstOrDefault(d => d.name.Equals(templateDescription.basedOn,
StringComparison.OrdinalIgnoreCase)));
}
}
}
}
public async Task Unpack(VirtualFile file, VirtualDirectory destination,
IProgressNotifier parentProgress = null, ChangeObservable observable = null)
{
if (Path.GetExtension(file.Name)?.Equals(".zip", StringComparison.OrdinalIgnoreCase) == true)
{
await UnpackZipFile().ConfigureAwait(false);
}
else if (file.Name.EndsWith(".tar.xz", StringComparison.OrdinalIgnoreCase))
{
UnpackTarXzFile(file);
}
else if (Path.GetExtension(file.Name)?.Equals(".xz", StringComparison.OrdinalIgnoreCase) == true)
{
UnpackXzFile(file);
}
else if (Path.GetExtension(file.Name)?.Equals(".tar", StringComparison.OrdinalIgnoreCase) == true)
{
UnpackTarFile(file);
}
else if (Path.GetExtension(file.Name)?.Equals(".sh", StringComparison.OrdinalIgnoreCase) == true &&
environmentService.Platform != OSPlatform.Windows)
{
await UnpackSelfExtractingShellScript().ConfigureAwait(false);
}
else
{
throw new UnsupportedArchiveFormatException(file.FullName);
}
async Task UnpackSelfExtractingShellScript()
{
ValidateShellScript();
StringBuilderUserInterface userInterface = new StringBuilderUserInterface(log, writeInformation: true, writeError: true);
try
{
using (parentProgress?.SpawnInfiniteProgress("Executing the shell script."))
using (IProcess process = processManager.StartProcess(file.FullName, $"-y -d \"{destination.FullName}\"", userInterface))
{
await process.WaitForExitAsync().ConfigureAwait(false);
if (process.ExitCode != 0)
{
throw new UnsupportedArchiveFormatException(file.FullName,
new FormattableException(
$"An error occured while executing the script.{Environment.NewLine}" +
$"{userInterface.Error}"));
}
}
}
catch (Exception e)
{
if (e is FormattableException)
{
throw;
}
throw new UnsupportedArchiveFormatException(file.FullName,
new FormattableException(
$"An exception occured while executing the script.{Environment.NewLine}" +
$"{e.Message}", e));
}
void ValidateShellScript()
{
StringBuilderUserInterface validationUserInterface = new StringBuilderUserInterface(log, writeInformation: true, writeError: true);
try
{
using (IProcess process = processManager.StartProcess(file.FullName, "--help", validationUserInterface))
{
process.WaitForExit();
}
}
catch (UnauthorizedAccessException e)
{
throw new UnsupportedArchiveFormatException(file.FullName,
new FormattableException(
$"An exception occured while inspecting the script.{Environment.NewLine}" +
$"This excpetion can occur when the file is not marked as executable.{Environment.NewLine}" +
$"{e.Message}", e));
}
catch (Exception e)
{
if (e is FormattableException)
{
throw;
}
throw new UnsupportedArchiveFormatException(file.FullName,
new FormattableException(
$"An exception occured while inspecting the script.{Environment.NewLine}" +
$"{e.Message}", e));
}
if (!Regex.IsMatch(validationUserInterface.Information,
@"(?=.*(?:usage|Usage)).*(?=.*-y)(?=.*-d)"))
{
throw new UnsupportedArchiveFormatException(file.FullName,
new FormattableException($"Did not find the expected usage information.{Environment.NewLine}" +
$"The expected information need to include the options '-y' and '-d'.{Environment.NewLine}" +
$"The following usage information was given:{Environment.NewLine}" +
$"{validationUserInterface.Information}"));
}
}
}
async Task UnpackZipFile()
{
using (Stream fileStream = file.OpenRead())
using (ZipFile zipFile = new ZipFile(fileStream))
using (IProgressNotifier mainProgress = parentProgress?.Spawn(2, $"Extracting {file.FullName} to {destination.FullName}."))
{
archiveResultBuilder.Clear();
using (mainProgress?.SpawnInfiniteProgress("Test archive integrity."))
{
ZipFile copy = zipFile;
await Task.Run(() =>
{
if (!copy.TestArchive(true, TestStrategy.FindAllErrors, ResultHandler))
{
throw new UnsupportedArchiveFormatException(
file.FullName, new FormattableException(archiveResultBuilder.ToString()));
}
}).ConfigureAwait(false);
}
double increment = (double)Constants.ProgressMaxResolution / zipFile.Count + 1;
using (IProgressNotifier extractProgress = mainProgress?.Spawn(Constants.ProgressMaxResolution, "Extract files"))
{
foreach (ZipEntry zipEntry in zipFile)
{
extractProgress?.TickIncrement(increment);
if (!zipEntry.IsFile)
{
continue; // Ignore directories
}
byte[] buffer = new byte[Constants.StreamCopyBufferSize]; // 4K is optimum
using (Stream zipStream = zipFile.GetInputStream(zipEntry))
{
string[] path = fileSystem.GetPath(zipEntry.Name);
VirtualDirectory fileDestination = destination.Directory(path.Take(path.Length - 1).ToArray());
VirtualFile entryFile = fileDestination.File(path.Last());
// Unzip file in buffered chunks. This is just as fast as unpacking to a buffer the full size
// of the file, but does not waste memory.
using (Stream streamWriter = entryFile.OpenWrite())
{
StreamUtils.Copy(zipStream, streamWriter, buffer);
}
}
}
}
}
}
VirtualFile UnpackXzFile(VirtualFile packedFile)
{
using (Stream fileStream = packedFile.OpenRead())
using (XZStream xzStream = new XZStream(fileStream))
using (parentProgress?.SpawnInfiniteProgress($"Extracting {packedFile.Name}..."))
{
string[] path = fileSystem.GetPath(packedFile.FullName);
string relativeFilePath = path.Last().Substring(0, path.Last().LastIndexOf(".xz", StringComparison.OrdinalIgnoreCase));
if (destination.FileExists(relativeFilePath))
{
destination.File(relativeFilePath).Delete();
}
VirtualFile destinationFile = destination.File(relativeFilePath);
observable?.OnNext(new Change(() => destinationFile.Restore()));
byte[] buffer = new byte[Constants.StreamCopyBufferSize]; // 4K is optimum
using (Stream streamWriter = destinationFile.OpenWrite())
{
StreamUtils.Copy(xzStream, streamWriter, buffer);
return(destinationFile);
}
}
}
void UnpackTarFile(VirtualFile packedFile)
{
//sharpcompress
using (Stream fileStream = packedFile.OpenRead())
using (TarArchive tarArchive = TarArchive.Open(fileStream))
{
double increment = (double)Constants.ProgressMaxResolution / tarArchive.Entries.Count;
using (IProgressNotifier extractProgress = parentProgress?.Spawn(Constants.ProgressMaxResolution, "Extracting .tar archive"))
{
foreach (TarArchiveEntry tarEntry in tarArchive.Entries)
{
extractProgress?.TickIncrement(increment);
if (tarEntry.IsDirectory)
{
continue; // Ignore directories
}
byte[] buffer = new byte[Constants.StreamCopyBufferSize]; // 4K is optimum
using (Stream tarStream = tarEntry.OpenEntryStream())
{
string[] path = fileSystem.GetPath(tarEntry.Key);
VirtualDirectory fileDestination = destination.Directory(path.Take(path.Length - 1).ToArray());
if (fileDestination.FileExists(path.Last()))
{
fileDestination.File(path.Last()).Delete();
}
VirtualFile entryFile = fileDestination.File(path.Last());
observable?.OnNext(new Change(() => entryFile.Restore()
//, $"Unpack {tarEntry.Key}."
));
//Unzip file in buffered chunks. This is just as fast as unpacking to a buffer the full size
// of the file, but does not waste memory.
using (Stream streamWriter = entryFile.OpenWrite())
{
StreamUtils.Copy(tarStream, streamWriter, buffer);
}
}
}
}
}
}
void UnpackTarXzFile(VirtualFile packedFile)
{
using (IProgressNotifier subProgress = parentProgress?.Spawn(2))
{
parentProgress = subProgress;
VirtualFile tarFile = UnpackXzFile(packedFile);
UnpackTarFile(tarFile);
tarFile.Delete();
}
}
}
public (bool, VirtualDirectory) EnsureConfigured(BuildInformation buildInformation, bool showWarningsToUser, ChangeObservable observable = null,
bool throwOnError = false, bool showMessagesToUser = true)
{
if (!CmakeFileExists())
{
GenerateCmakeFile();
}
VirtualDirectory cmakeFolder = CreateCmakeFolder();
LoadCmakeOptions();
bool success = ConfigureCMake();
return(success, cmakeFolder);
void GenerateCmakeFile()
{
//It is important to get the name first before the cmake file is created in the next line.
string name = buildInformation.RootEntity.Name;
VirtualFile cMakeFile = buildInformation.RootFileEntity.Directory.File(Constants.CMakeFileName);
//TODO Generate cmakefile with template system
//TODO Set src folders in cmake file (consider foreign project structure)
CMakeFileGenerator.WriteCMakeFile(cMakeFile, name);
observable?.OnNext(new Change(() => { /*Do not delete, because user need to make changes perhaps*/ }, $"Generated cmake file {cMakeFile.FullName}"));
}
bool CmakeFileExists()
{
return(buildInformation.RootFileEntity.Directory.FileExists(Constants.CMakeFileName));
}
VirtualDirectory CreateCmakeFolder()
{
VirtualDirectory result = buildInformation.BuildEntity.BuildSystemDirectory;
if (buildInformation.Configure && !buildInformation.NoConfigure)
{
result.Clear();
observable?.OnNext(new Change(() => result.UnClear(), $"Cleared cmake directory."));
}
return(result);
}
string GetRealBuildType()
{
string buildType = !string.IsNullOrEmpty(buildInformation.BuildType)
? buildInformation.BuildType
: Constants.ReleaseFolderName;
return(buildType);
}
void LoadCmakeOptions()
{
if (!string.IsNullOrEmpty(buildInformation.BuildProperties))
{
return;
}
if (buildInformation.RootFileEntity?.Directory?.FileExists(Constants.CMakeCommandArgsFileName) == true)
{
string cmakeArgs = string.Empty;
VirtualFile commandArgsFile = buildInformation.RootFileEntity.Directory.File(Constants.CMakeCommandArgsFileName);
using (Stream fileStream = commandArgsFile.OpenRead())
using (StreamReader streamReader = new StreamReader(fileStream))
{
while (!streamReader.EndOfStream)
{
string line = streamReader.ReadLine();
if (string.IsNullOrEmpty(line))
{
continue;
}
cmakeArgs = string.Join(" ", cmakeArgs, line);
}
}
buildInformation.BuildProperties = cmakeArgs;
buildInformation.BuildPropertiesSetByFile = true;
}
}
bool ConfigureCMake()
{
executionContext.WriteInformation("Checking if CMake needs to be reconfigured...", showMessagesToUser);
if ((!cmakeFolder.FileExists("CMakeCache.txt") ||
buildInformation.Configure ||
!CacheHasValidTimestamp() ||
!IsCorrectlyConfigured() ||
OutputOptionDiffersFromStagingPrefix()) &&
!buildInformation.NoConfigure)
{
string cmakeCommand = GenerateCmakeCommand(buildInformation.Target.Name,
buildInformation.Target.LongVersion);
executionContext.WriteInformation("Configuring CMake...", showMessagesToUser);
bool result = CallCmake(cmakeFolder, cmakeCommand, showMessagesToUser, throwOnError, showWarningsToUser);
AddTimestamp();
return(result);
}
if (!string.IsNullOrEmpty(buildInformation.BuildProperties) && !buildInformation.BuildPropertiesSetByFile)
{
executionContext.WriteWarning($"The specified build options will not be used, " +
$"because no reconfiguration is necessary. " +
$"To force a reconfiguration please use the '--configure' command option.",
showMessagesToUser);
}
return(true);
string GenerateCmakeCommand(string target, string version)
{
List <string> commandParts = new List <string>();
string sdkRoot = buildInformation.SdkInformation.Root.FullName.Replace("\\", "/");
if (!buildInformation.BuildProperties.Contains("-DCMAKE_TOOLCHAIN_FILE="))
{
commandParts.Add(ToolchainFileOption.Replace("%SDK_ROOT%", sdkRoot));
}
if (!buildInformation.BuildProperties.Contains("-DARP_TOOLCHAIN_ROOT="))
{
commandParts.Add(ToolchainRootOption.Replace("%SDK_ROOT%", sdkRoot));
}
if (!buildInformation.BuildProperties.Contains("-DCMAKE_BUILD_TYPE="))
{
commandParts.Add(BuildTypeOption.Replace("%BUILD_TYPE%", GetRealBuildType()));
}
if (!buildInformation.BuildProperties.Contains("-DARP_DEVICE="))
{
commandParts.Add(DeviceOption.Replace("%TARGET%", $"\"{target}\""));
}
if (!buildInformation.BuildProperties.Contains("-DARP_DEVICE_VERSION="))
{
commandParts.Add(DeviceVersionOption.Replace("%VERSION%", $"\"{version}\""));
}
if (!buildInformation.BuildProperties.Contains("-DCMAKE_STAGING_PREFIX="))
{
commandParts.Add(StagingPrefixOption.Replace("%STAGING_PREFIX%", GenerateStagingPrefixForTarget()));
}
if (!buildInformation.BuildProperties.Contains("-DCMAKE_PREFIX_PATH=") &&
IsIncludePathAvailable(out string includePath))
{
commandParts.Add(PrefixPathOption.Replace("%PREFIX_PATH%", includePath));
}
if (!buildInformation.BuildProperties.Contains("-G "))
{
commandParts.Add(GeneratorOption);
if (buildInformation.SdkInformation.MakeFile != null && !buildInformation.BuildProperties.Contains("-DCMAKE_MAKE_PROGRAM "))
{
commandParts.Add(MakeFileOption.Replace("%MAKE_EXE%", $"\"{buildInformation.SdkInformation.MakeFile.FullName.Replace("\\", "/")}\""));
}
}
if (!string.IsNullOrEmpty(buildInformation.BuildProperties))
{
commandParts.Add(buildInformation.BuildProperties);
}
commandParts.Add($"\"{buildInformation.RootFileEntity.Directory.FullName.Replace("\\", "/")}\"");
return(string.Join(" ", commandParts));
string GenerateStagingPrefixForTarget()
{
string basePath = buildInformation.RootFileEntity.Directory.FullName;
return(buildInformation.Output != null
? OutputOptionFullPath()
: Path.Combine(basePath, Constants.LibraryFolderName)
.Replace(Path.DirectorySeparatorChar, '/'));
}
bool IsIncludePathAvailable(out string path)
{
path = null;
if (!buildInformation.RootFileEntity.Directory.DirectoryExists("external"))
{
return(false);
}
Dictionary <Version, VirtualDirectory> versions = new Dictionary <Version, VirtualDirectory>();
VirtualDirectory externalDirectory = buildInformation.RootFileEntity.Directory.Directory("external");
foreach (VirtualDirectory directory in externalDirectory.Directories)
{
Match patternMatch = IncludeDirectoryPattern.Match(directory.Name);
if (!patternMatch.Success ||
!Version.TryParse(patternMatch.Groups["version"].Value, out Version includeVersion) ||
target != patternMatch.Groups["name"].Value)
{
continue;
}
versions.Add(includeVersion, directory);
}
Version actualVersion = Version.Parse(buildInformation.Target.Version);
Version bestMatch = versions.Keys.Where(v => v <= actualVersion)
.OrderByDescending(v => v)
.FirstOrDefault();
if (bestMatch != null)
{
VirtualDirectory directory = versions[bestMatch];
if (directory.DirectoryExists(buildInformation.BuildType))
{
path = directory.Directory(buildInformation.BuildType).FullName;
}
else if (directory.DirectoryExists(Constants.ReleaseFolderName))
{
path = directory.Directory(Constants.ReleaseFolderName).FullName;
}
else
{
path = directory.FullName;
}
}
else
{
path = externalDirectory.FullName;
}
return(true);
}
}
string OutputOptionFullPath()
{
return(fileSystem.GetDirectory(buildInformation.Output,
buildInformation.RootFileEntity.Directory.FullName)
.FullName.Replace(Path.DirectorySeparatorChar, '/'));
}
bool OutputOptionDiffersFromStagingPrefix()
{
return(buildInformation.Output != null &&
!buildInformation.BuildEntity.BuildSystem.InstallationPaths.Any(p => p.StartsWith(OutputOptionFullPath(), StringComparison.Ordinal)));
}
bool IsCorrectlyConfigured()
{
try
{
return(buildInformation.BuildEntity.HasBuildSystem &&
buildInformation.BuildEntity.BuildSystem != null);
}
catch (Exception e)
{
if (!IsTimeout(e))
{
executionContext.WriteVerbose($"The project is not correctly configured:{Environment.NewLine}{e}");
return(false);
}
}
return(true); //this is a timeout so we dont know if it is correctly configured
bool IsTimeout(Exception exception)
{
return(exception is TimeoutException ||
exception is AggregateException aggregate &&
aggregate.InnerExceptions.Any(e => e is TimeoutException));
}
}
void AddTimestamp()
{
if (buildInformation.RootFileEntity?.Directory?.FileExists(Constants.CMakeCommandArgsFileName) == true)
{
VirtualFile commandArgsFile = buildInformation.RootFileEntity.Directory.File(Constants.CMakeCommandArgsFileName);
VirtualFile timestampFile = cmakeFolder.File(Constants.CMakeTimestampFileName);
JObject timestamp = new JObject
{
new JProperty("FlagsWriteTime", new JValue(commandArgsFile.LastWriteTime))
};
using (Stream fileStream = timestampFile.OpenWrite())
using (StreamWriter streamWriter = new StreamWriter(fileStream, Encoding.UTF8))
using (JsonWriter jsonWriter = new JsonTextWriter(streamWriter))
{
fileStream.SetLength(0);
jsonWriter.Formatting = Formatting.Indented;
timestamp.WriteTo(jsonWriter);
}
}
else
{
if (cmakeFolder.FileExists(Constants.CMakeTimestampFileName))
{
cmakeFolder.File(Constants.CMakeTimestampFileName).Delete();
}
}
}
bool CacheHasValidTimestamp()
{
if (buildInformation.RootFileEntity?.Directory?.FileExists(Constants.CMakeCommandArgsFileName) == true)
{
DateTime commandArgsLastWriteTime = buildInformation.RootFileEntity
.Directory
.File(Constants.CMakeCommandArgsFileName)
.LastWriteTime;
if (cmakeFolder.FileExists(Constants.CMakeTimestampFileName))
{
VirtualFile timestampFile = cmakeFolder.File(Constants.CMakeTimestampFileName);
try
{
using (Stream fileStream = timestampFile.OpenRead())
using (StreamReader reader = new StreamReader(fileStream))
using (JsonReader jsonReader = new JsonTextReader(reader))
{
JObject fileContent = JObject.Load(jsonReader);
if (fileContent.ContainsKey("FlagsWriteTime") &&
fileContent["FlagsWriteTime"].Type == JTokenType.Date)
{
DateTime savedTimeStamp = fileContent["FlagsWriteTime"].Value <DateTime>();
if (savedTimeStamp.CompareTo(commandArgsLastWriteTime) == 0)
{
return(true);
}
}
}
}
catch (JsonReaderException)
{
return(false);
}
}
}
else
{
if (!cmakeFolder.FileExists(Constants.CMakeTimestampFileName))
{
return(true);
}
}
return(false);
}
}
}