public static LinksWrapper GetAllLinksInDomain(string urlAddress)
{
var normalLinks = new List <LinkResult>();
var brokenLinks = new List <LinkResult>();
var allStrLinks = GetAllStringLinksInDomain(urlAddress);
foreach (var link in allStrLinks)
{
var linkResult = new LinkResult()
{
Link = link, Status = GetStatusCode(link)
};
var statusCode = linkResult.Status;
if (statusCode < BAD_REQUEST)
{
normalLinks.Add(linkResult);
}
else
{
brokenLinks.Add(linkResult);
}
}
return(new LinksWrapper
{
NormalLinks = normalLinks,
BrokenLinks = brokenLinks
});
}
/// <summary>
/// Processa a junção.
/// </summary>
/// <param name="query">Informações da consulta.</param>
/// <param name="join">Informações do join.</param>
private LinkResult ProcessJoin(QueryInfo query, JoinInfo join)
{
LinkResult endResult = ProcessLinkResult(query, join.Conditional);
;
return(endResult);
}
private void ReportResult(LinkResult result)
{
LinkedFiles = result.LinkedFiles;
#if DEBUG
var message = $"Successfully linked {result.LinkedFiles.Count} file(s)! ({result.Elapsed} ms)";
#else
var message = $"Successfully linked {result.LinkedFiles.Count} file(s)!)";
#endif
ShowInlineMessage(message, 5000);
}
public LinkResult GetLinks(int page)
{
var itemPerPage = _configuration.GetValue <int>("itemPerPage");
var(linkList, count) = _linkRepository.GetLinks((page - 1) * itemPerPage, itemPerPage);
var result = new LinkResult
{
PageInfo = new PageInfo
{
CurrentPage = page,
MaxPage = count % itemPerPage == 0 ? count / itemPerPage : count / itemPerPage + 1
},
Items = linkList
};
return(result);
}
/// <summary>
/// Executa a consulta informada retornando resultado do cache.
/// </summary>
/// <param name="query">Informações da consulta</param>
/// <returns>Resultado do cache</returns>
public QueryResultSet ExecuteInCache(QueryInfo query)
{
query.Require("query").NotNull();
string commandText;
Hashtable parameters;
Parse(query, out commandText, out parameters);
if (query.Entities.Length > 1)
{
LinkResult endResult = null;
if (query.WhereClause != null && query.WhereClause.ConditionalsCount > 0)
{
endResult = ProcessLinkResult(query, query.WhereClause);
}
else
{
Parse(new QueryInfo {
Entities = new EntityInfo[] {
query.Entities.FirstOrDefault()
},
}, out commandText, out parameters);
var searchResult = _cacheProvider.Cache.Search(commandText, parameters);
endResult = Convert(searchResult, query.Entities.FirstOrDefault());
}
foreach (var join in query.Joins)
{
var res = ProcessJoin(query, join);
endResult = Merge(join.Type == JoinType.Inner ? MergeType.Intersect : MergeType.LeftJoin, endResult, res);
}
if (endResult == null)
{
string command = "SELECT " + query.Entities[0].FullName;
endResult = Convert(Cache.Search(command, parameters), query.Entities[0]);
}
var defaultEntityIndex = Array.IndexOf(endResult.Entities, query.Entities[0].FullName);
if (defaultEntityIndex < 0)
{
defaultEntityIndex = 0;
}
return(new MultipleKeysQueryResultSet(endResult, defaultEntityIndex));
}
else
{
return(Cache.Search(commandText, parameters));
}
}
/// <summary>
/// Links several files to create an executable (stored to dest).
/// </summary>
/// <param name="dest">the resulting executable (on success) (non-null)</param>
/// <param name="files">the files to link. ".o" files are loaded as object files, otherwise treated as assembly source and assembled</param>
/// <param name="entry_point">the main entry point</param>
/// <param name="rootdir">the root directory to use for core file lookup - null for default</param>
private static int Link(Executable dest, List <string> files, string entry_point, string rootdir)
{
var objs = new List <KeyValuePair <string, ObjectFile> >();
// load the stdlib files
int ret = LoadStdlibObjs(objs, rootdir);
if (ret != 0)
{
return(ret);
}
// load the provided files
foreach (string file in files)
{
// treat ".o" as object file, otherwise as assembly source
ObjectFile obj = new ObjectFile();
ret = file.EndsWith(".o") ? LoadObjectFile(file, obj) : Assemble(file, obj);
if (ret != 0)
{
return(ret);
}
objs.Add(new KeyValuePair <string, ObjectFile>(file, obj));
}
// link the resulting object files into an executable
LinkResult res = Assembly.Link(dest, objs.ToArray(), entry_point);
// if there was an error, show error message
if (res.Error != LinkError.None)
{
Console.Error.WriteLine($"Link Error:\n{res.ErrorMsg}");
return((int)res.Error);
}
return(0);
}
private Task <LinkResult> CreateTask(FluentConfiguration fluentConfiguration, HttpWebRequest webRequest, string originalUrl)
{
return(Task <LinkResult> .Factory.StartNew(() =>
{
if (fluentConfiguration.Bot != null)
{
fluentConfiguration.Bot.OnRequest(webRequest);
}
_beforeConfigurers.ForEach(x => x(webRequest));
var result = new LinkResult {
Url = new Uri(originalUrl, UriKind.RelativeOrAbsolute)
};
HttpWebResponse webResponse = null;
try
{
webResponse = (HttpWebResponse)webRequest.GetResponse();
result.StatusCode = webResponse.StatusCode;
}
catch (WebException we)
{
result.StatusCode = we.Response != null ? ((HttpWebResponse)we.Response).StatusCode : HttpStatusCode.NotFound;
}
finally
{
if (webResponse != null)
{
_afterConfigurers.ForEach(x => x(webResponse));
webResponse.Close();
}
}
return result;
}));
}
public async Task <ProcessResult> ObjCopy(IConsole console, IProject project, LinkResult linkResult, AssemblyFormat format)
{
var result = new ProcessResult();
var commandName = Path.Combine(BinDirectory, $"{SizePrefix}objcopy" + Platform.ExecutableExtension);
if (PlatformSupport.CheckExecutableAvailability(commandName, BinDirectory))
{
string formatArg = "binary";
switch (format)
{
case AssemblyFormat.Binary:
formatArg = "binary";
break;
case AssemblyFormat.IntelHex:
formatArg = "ihex";
break;
}
string outputExtension = ".bin";
switch (format)
{
case AssemblyFormat.Binary:
outputExtension = ".bin";
break;
case AssemblyFormat.IntelHex:
outputExtension = ".hex";
break;
case AssemblyFormat.Elf32:
outputExtension = ".elf";
break;
}
var arguments = $"-O {formatArg} {linkResult.Executable} {Path.GetDirectoryName(linkResult.Executable)}{Platform.DirectorySeperator}{Path.GetFileNameWithoutExtension(linkResult.Executable)}{outputExtension}";
console.WriteLine($"Converting to {format.ToString()}");
result.ExitCode = PlatformSupport.ExecuteShellCommand(commandName, arguments, (s, e) => console.WriteLine(e.Data), (s, e) => console.WriteLine(e.Data), false, string.Empty, false);
}
else
{
console.WriteLine("Unable to find tool (" + commandName + ") check project compiler settings.");
result.ExitCode = -1;
}
return(result);
}
public override async Task <bool> PostBuild(IConsole console, IProject project, LinkResult linkResult)
{
return(true);
}
public override async Task<bool> PostBuild(IConsole console, IProject project, LinkResult linkResult)
{
if((project is IStandardProject) && (project as IStandardProject).Type == ProjectType.Executable)
{
var result = await ObjCopy(console, project, linkResult, AssemblyFormat.Binary);
if (result.ExitCode == 0)
{
result = await ObjCopy(console, project, linkResult, AssemblyFormat.IntelHex);
}
return result.ExitCode == 0;
}
return true;
}
public async Task<ProcessResult> ObjCopy(IConsole console, IProject project, LinkResult linkResult, AssemblyFormat format)
{
var result = new ProcessResult();
var commandName = Path.Combine(BinDirectory, $"{SizePrefix}objcopy" + Platform.ExecutableExtension);
if(PlatformSupport.CheckExecutableAvailability(commandName, BinDirectory))
{
string formatArg = "binary";
switch (format)
{
case AssemblyFormat.Binary:
formatArg = "binary";
break;
case AssemblyFormat.IntelHex:
formatArg = "ihex";
break;
}
string outputExtension = ".bin";
switch (format)
{
case AssemblyFormat.Binary:
outputExtension = ".bin";
break;
case AssemblyFormat.IntelHex:
outputExtension = ".hex";
break;
case AssemblyFormat.Elf32:
outputExtension = ".elf";
break;
}
var arguments = $"-O {formatArg} {linkResult.Executable} {Path.GetDirectoryName(linkResult.Executable)}{Platform.DirectorySeperator}{Path.GetFileNameWithoutExtension(linkResult.Executable)}{outputExtension}";
console.WriteLine($"Converting to {format.ToString()}");
result.ExitCode = PlatformSupport.ExecuteShellCommand(commandName, arguments, (s, e) => console.WriteLine(e.Data), (s, e) => console.WriteLine(e.Data), false, string.Empty, false);
}
else
{
console.WriteLine("Unable to find tool (" + commandName + ") check project compiler settings.");
result.ExitCode = -1;
}
return result;
}
public static void UserEquilibriumMSA(XXE_DataStructures.ProjectData project, NetworkData network, List <LinkData> links, List <FreewayData> freewayfacilities, List <ODdata> OD, List <UserEquilibriumTimePeriodResult> results, List <List <List <double> > > RampProportionList)
{
Graph g = new Graph(network.NumNodes - network.FirstNetworkNode + 1);
ConstructGraph(g, links, network.FirstNetworkNode);
int numTPs = 1;
for (int n = 0; n < freewayfacilities.Count; n++)
{
if (freewayfacilities[n].PhysicalLinkXXE == true)
{
numTPs = freewayfacilities[n].TotalTimePeriods;
}
}
UserEquilibriumTimePeriodResult timePeriodResult;
for (int tp = 1; tp <= numTPs; tp++)
{
timePeriodResult = new UserEquilibriumTimePeriodResult();
Iteration iteration;
double[,] ShortPath = new double[299, 299];
double[,] ShortPath1 = new double[299, 299];
double ObjFcn; //value of BPR function
bool SolutionConverged = false;
double DeltaFlows;
double D;
FL.Clear();
FL.Add(newFL); //create the '0' index list entry, since loop starts with index '1'
List <List <ODvolume> > ODvolumeLists = new List <List <ODvolume> >();
//initialize shortest path from each origin to each destination to zero
for (int i = 1; i <= network.NumZones; i++)
{
for (int j = 1; j <= network.NumZones + 1; j++)
{
ShortPath[j, i] = 0;
ShortPath1[j, i] = 0;
}
}
AllOrNothingMSA(tp, network.NumZones, network.NumNodes, FL, network, links, freewayfacilities, OD, RampProportionList, ODvolumeLists, ref ShortPath);
IterNum = 0;
ObjFcn = 0;
for (int i = 1; i <= network.TotalLinks; i++)
{
ObjFcn = ObjFcn + HCM_FF_Method.TravTimeFcnFreewayFacilities(RampProportionList[i - 1], freewayfacilities[i - 1], tp, FL[i]);
}
for (int i = 1; i <= network.NumZones; i++)
{
for (int j = 1; j <= network.NumZones; j++)
{
ShortPath1[i, j] = ShortPath[i, j];
}
}
ConvValue = 2 * network.ConvCrit; //initialize convergence value
do
{
IterNum++;
AllOrNothingMSA(tp, network.NumZones, network.NumNodes, NFL, network, links, freewayfacilities, OD, RampProportionList, ODvolumeLists, ref ShortPath);
MoveMSA(network, IterNum + 1);
ConvValue = 0;
ObjFcn = 0;
List <double> TravelTimes = new List <double>();
for (int i = 1; i <= network.TotalLinks; i++)
{
double travelTime = HCM_FF_Method.TravTimeFcnFreewayFacilities(RampProportionList[i - 1], freewayfacilities[i - 1], tp, FL[i]);
ObjFcn = ObjFcn + travelTime * FL[i];
//TravelTimes.Add(travelTime);
DeltaFlows = Math.Abs(NFL[i] - FL[i]); //difference between previous set of flows and current set of flows
if (DeltaFlows != 0)
{
D = NFL[i];
if (D == 0)
{
D = FL[i];
}
ConvValue = ConvValue + DeltaFlows / D;
FL.Add(newFL);
FL[i] = NFL[i];
}
TravelTimes.Add(HCM_FF_Method.TravTimeFcnFreewayFacilities(RampProportionList[i - 1], freewayfacilities[i - 1], tp, FL[i]));
}
ConvValue = ConvValue / network.TotalLinks;
iteration = new Iteration();
iteration.ObjFunction = ObjFcn;
iteration.IternationNum = IterNum;
iteration.ConvergeValue = ConvValue;
IterationLinkVolume linkVolume;
for (int n = 1; n <= network.TotalLinks; n++)
{
if (links[n].PhysLink == true)
{
linkVolume = new IterationLinkVolume();
linkVolume.ID = n;
linkVolume.FromNode = links[n].FromNode;
linkVolume.ToNode = links[n].ToNode;
linkVolume.Volume = FL[n];
linkVolume.PhysLink = links[n].PhysLink;
iteration.LinkVolumes.Add(linkVolume);
}
}
timePeriodResult.TimePeriod = tp;
timePeriodResult.Iterations.Add(iteration);
timePeriodResult.IsConverged = false;
if (ConvValue <= network.ConvCrit || IterNum == network.MaxIterations)
{
if (ConvValue <= network.ConvCrit)
{
SolutionConverged = true;
timePeriodResult.IsConverged = true;
}
timePeriodResult.NumIterations = IterNum;
timePeriodResult.ConvergenceValue = ConvValue;
timePeriodResult.ObjFunctionValue = ObjFcn;
timePeriodResult.LinkResults.Clear();
LinkResult result;
for (int n = 1; n <= network.TotalLinks; n++)
{
if (links[n].PhysLink == true)
{
result = new LinkResult();
result.ID = n;
result.FromNode = links[n].FromNode;
result.ToNode = links[n].ToNode;
result.Volume = FL[n];
result.PhysLink = links[n].PhysLink;
result.TravelTime = TravelTimes[n - 1];
result.VehMilesTravVolume = freewayfacilities[n - 1].Results[tp].VehMilesTravVolume;
result.VehMilesTravDemand = freewayfacilities[n - 1].Results[tp].VehMilesTravDemand;
result.VehHoursTrav = freewayfacilities[n - 1].Results[tp].VehHoursTrav;
result.VehHoursDelay = freewayfacilities[n - 1].Results[tp].VehHoursDelay;
result.DensityVeh = freewayfacilities[n - 1].Results[tp].DensityVeh;
result.AvgSpeed = freewayfacilities[n - 1].Results[tp].AvgSpeed;
result.DensityPC = freewayfacilities[n - 1].Results[tp].DensityPC;
result.SegmentTravelTimes = GetSegmentTravelTimes(freewayfacilities[n - 1].TPsegs[tp]);
if (freewayfacilities[n - 1].PhysicalLinkXXE == true)
{
result.FreeFlowTravelTime = freewayfacilities[n - 1].Results[tp].TravTimeFreeFlow;
timePeriodResult.LinkResults.Add(result);
}
}
}
}
} while ((SolutionConverged == false) && (IterNum < network.MaxIterations));
for (int od = 1; od < OD.Count; od++) //the first od item has no values
{
int PathFromNode = ZoneToNode(OD[od].OrigZone, links);
int PathToNode = ZoneToNode(OD[od].DestZone, links);
if (PathFromNode > 0 && PathToNode > 0)
{
g.PathList = new List <List <int> >();
GetPathsFromOD(g, PathFromNode, PathToNode, network.FirstNetworkNode);
ODResult result = new ODResult();
result.Orig = OD[od].OrigZone;
result.Dest = OD[od].DestZone;
result.PathLists = g.PathList;
result.TravelTimeList = GetPathTravelTimes(result.PathLists, timePeriodResult);
result.FreeFlowTravelTimeList = GetPathFreeFlowTravelTimes(result.PathLists, timePeriodResult);
double minimalPathTravelTime = result.TravelTimeList[0];
for (int n = 0; n < result.TravelTimeList.Count; n++)
{
if (result.TravelTimeList[n] < minimalPathTravelTime)
{
minimalPathTravelTime = result.TravelTimeList[n];
}
}
result.MinimalPathTravelTime = minimalPathTravelTime;
double minimalPathFreeFlowTravelTime = result.FreeFlowTravelTimeList[0];
for (int n = 0; n < result.FreeFlowTravelTimeList.Count; n++)
{
if (result.FreeFlowTravelTimeList[n] < minimalPathFreeFlowTravelTime)
{
minimalPathFreeFlowTravelTime = result.FreeFlowTravelTimeList[n];
}
}
result.MinimalPathFreeFlowTravelTime = minimalPathFreeFlowTravelTime;
for (int n = 0; n < result.TravelTimeList.Count; n++)
{
double diff = result.TravelTimeList[n] - minimalPathTravelTime;
if (diff < 1)
{
result.UtilizedPathLists.Add(result.PathLists[n]);
result.UtilizedList.Add(1);
}
else
{
result.UtilizedList.Add(0);
}
}
timePeriodResult.ODResults.Add(result);
}
}
results.Add(timePeriodResult);
}
}
public override LinkResult Link(IConsole console, IStandardProject superProject, IStandardProject project,
CompileResult assemblies, string outputPath)
{
var settings = GetSettings(superProject);
var result = new LinkResult();
var startInfo = new ProcessStartInfo();
startInfo.FileName = Path.Combine(BaseDirectory, "arm-none-eabi-gcc" + Platform.ExecutableExtension);
if (project.Type == ProjectType.StaticLibrary)
{
startInfo.FileName = Path.Combine(BaseDirectory, "arm-none-eabi-ar" + Platform.ExecutableExtension);
}
startInfo.WorkingDirectory = project.Solution.CurrentDirectory;
if (!System.IO.File.Exists(startInfo.FileName))
{
result.ExitCode = -1;
console.WriteLine("Unable to find linker executable (" + startInfo.FileName + ") Check project compiler settings.");
return(result);
}
var objectArguments = string.Empty;
foreach (var obj in assemblies.ObjectLocations)
{
objectArguments += obj + " ";
}
var libs = string.Empty;
foreach (var lib in assemblies.LibraryLocations)
{
libs += lib + " ";
}
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var outputName = Path.GetFileNameWithoutExtension(outputPath) + ExecutableExtension;
if (project.Type == ProjectType.StaticLibrary)
{
outputName = Path.GetFileNameWithoutExtension(outputPath) + StaticLibraryExtension;
}
else
{
GenerateLinkerScript(superProject);
}
var executable = Path.Combine(outputDir, outputName);
var linkedLibraries = string.Empty;
foreach (var libraryPath in project.StaticLibraries)
{
var relativePath = Path.GetDirectoryName(libraryPath);
var libName = Path.GetFileNameWithoutExtension(libraryPath).Substring(3);
linkedLibraries += string.Format("-L\"{0}\" -l{1} ", relativePath, libName);
}
foreach (var lib in project.BuiltinLibraries)
{
linkedLibraries += string.Format("-l{0} ", lib);
}
// TODO linked libraries won't make it in on nano... Please fix -L directory placement in compile string.
switch (settings.LinkSettings.Library)
{
case LibraryType.NanoCLib:
linkedLibraries += "-lm -lc_nano -lsupc++_nano -lstdc++_nano ";
break;
case LibraryType.BaseCLib:
linkedLibraries += "-lm -lc -lstdc++ -lsupc++ ";
break;
case LibraryType.SemiHosting:
linkedLibraries += "-lm -lgcc -lc -lrdimon ";
break;
case LibraryType.Retarget:
linkedLibraries += "-lm -lc -lnosys -lstdc++ -lsupc++ ";
break;
}
// Hide console window
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardInput = true;
startInfo.CreateNoWindow = true;
if (project.Type == ProjectType.StaticLibrary)
{
startInfo.Arguments = string.Format("rvs {0} {1}", executable, objectArguments);
}
else
{
startInfo.Arguments = string.Format("{0} -o{1} {2} -Wl,--start-group {3} {4} -Wl,--end-group",
GetLinkerArguments(project), executable, objectArguments, linkedLibraries, libs);
}
//console.WriteLine(Path.GetFileNameWithoutExtension(startInfo.FileName) + " " + startInfo.Arguments);
//console.WriteLine ("[LL] - " + startInfo.Arguments);
using (var process = Process.Start(startInfo))
{
process.OutputDataReceived += (sender, e) =>
{
//console.WriteLine(e.Data);
};
process.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null && !e.Data.Contains("creating"))
{
console.WriteLine(e.Data);
}
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
result.ExitCode = process.ExitCode;
if (result.ExitCode == 0)
{
result.Executable = executable;
}
}
return(result);
}
/// <summary>
/// Processa a junção.
/// </summary>
/// <param name="query">Consulta que será analizada.</param>
/// <param name="term">Termo condicional que será processado.</param>
/// <returns></returns>
private LinkResult ProcessLinkResult(QueryInfo query, ConditionalTerm term)
{
if (term is Conditional)
{
var conditional = (Conditional)term;
var leftColumn = conditional.Left as Column;
var rightColumn = conditional.Right as Column;
EntityInfo leftEntity = null;
EntityInfo rightEntity = null;
if (leftColumn != null)
{
leftEntity = query.Entities.Where(f => f.Alias == leftColumn.Owner).FirstOrDefault() ?? query.Entities.FirstOrDefault();
}
if (rightColumn != null)
{
rightEntity = query.Entities.Where(f => f.Alias == rightColumn.Owner).FirstOrDefault() ?? query.Entities.FirstOrDefault();
}
if (leftColumn != null && rightColumn != null)
{
ComparisonType comparisonType = ComparisonType.EQUALS;
switch (conditional.Operator.Op)
{
case "==":
case "=":
comparisonType = ComparisonType.EQUALS;
break;
case "<>":
case "!=":
comparisonType = ComparisonType.NOT_EQUALS;
break;
case ">":
comparisonType = ComparisonType.GREATER_THAN;
break;
case ">=":
comparisonType = ComparisonType.GREATER_THAN_EQUALS;
break;
case "<":
comparisonType = ComparisonType.LESS_THAN;
break;
case "<=":
comparisonType = ComparisonType.LESS_THAN_EQUALS;
break;
default:
throw new InvalidOperationException("Unsupported operator " + conditional.Operator.Op);
}
return(new LinkResult {
Entities = new EntityInfo[] {
leftEntity,
rightEntity
},
Items = _cacheProvider.Cache.JoinIndex(leftEntity.FullName, leftColumn.Name, rightEntity.FullName, rightColumn.Name, comparisonType).ToArray()
});
}
else
{
EntityInfo entity = leftEntity != null ? leftEntity : rightEntity;
string commandText = null;
Hashtable parameters = null;
Parse(new QueryInfo {
Entities = new EntityInfo[] {
entity
},
WhereClause = new ConditionalContainer(conditional),
Parameters = query.Parameters
}, out commandText, out parameters);
var searchResult = _cacheProvider.Cache.Search(commandText, parameters);
return(Convert(searchResult, entity));
}
}
else if (term is ConditionalContainer)
{
var container = (ConditionalContainer)term;
var logicOperators = new Queue <LogicalOperator>(container.LogicalOperators);
LinkResult joinResult = null;
foreach (var term2 in container.Conditionals)
{
if (joinResult == null)
{
joinResult = ProcessLinkResult(query, term2);
}
else
{
joinResult = Merge(logicOperators.Dequeue() == LogicalOperator.And ? MergeType.Intersect : MergeType.Union, joinResult, ProcessLinkResult(query, term2));
}
}
return(joinResult);
}
throw new InvalidOperationException();
}
public override LinkResult Link(IConsole console, IStandardProject superProject, IStandardProject project, CompileResult assemblies, string outputPath)
{
var result = new LinkResult();
string commandName = project.Type == ProjectType.StaticLibrary ? ARExecutable : LDExecutable;
var objectArguments = string.Empty;
foreach (var obj in assemblies.ObjectLocations)
{
objectArguments += obj + " ";
}
var libs = string.Empty;
foreach (var lib in assemblies.LibraryLocations)
{
libs += lib + " ";
}
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var outputName = Path.GetFileName(outputPath);
if (project.Type == ProjectType.StaticLibrary)
{
outputName = Path.GetFileName(outputPath);
}
var executable = Path.Combine(outputDir, outputName);
var linkedLibraries = string.Empty;
foreach (var libraryPath in project.StaticLibraries)
{
var relativePath = Path.GetDirectoryName(libraryPath);
var libName = Path.GetFileNameWithoutExtension(libraryPath).Substring(3);
linkedLibraries += string.Format("-L\"{0}\" -l{1} ", relativePath, libName);
}
string libraryPaths = string.Empty;
var linkerScripts = string.Empty;
if (project.Type == ProjectType.Executable)
{
var settings = project.GetToolchainSettings <GccToolchainSettings>();
foreach (var libraryPath in settings.LinkSettings.LinkedLibraries)
{
libraryPaths += $"-Wl,--library-path={Path.Combine(project.CurrentDirectory, Path.GetDirectoryName(libraryPath)).ToPlatformPath()} ";
var libName = Path.GetFileName(libraryPath);
linkedLibraries += string.Format($"-Wl,--library=:{libName} ");
}
foreach (var script in settings.LinkSettings.LinkerScripts)
{
linkerScripts += $"-Wl,-T\"{Path.Combine(project.CurrentDirectory, script)}\" ";
}
foreach (var lib in settings.LinkSettings.SystemLibraries)
{
linkedLibraries += $"-l{lib} ";
}
}
foreach (var lib in project.BuiltinLibraries)
{
linkedLibraries += $"-l{lib} ";
}
linkedLibraries += GetBaseLibraryArguments(superProject);
string arguments = string.Empty;
if (project.Type == ProjectType.StaticLibrary)
{
arguments = string.Format("rvs {0} {1}", executable, objectArguments);
}
else
{
var environment = superProject.GetEnvironmentVariables().AppendRange(Platform.EnvironmentVariables);
arguments = string.Format("{0} {1} -o{2} {3} {4} -Wl,--start-group {5} {6} -Wl,--end-group", GetLinkerArguments(superProject, project).ExpandVariables(environment), linkerScripts, executable, objectArguments, libraryPaths, linkedLibraries, libs);
}
result.ExitCode = PlatformSupport.ExecuteShellCommand(commandName, arguments, (s, e) =>
{
if (e.Data != null)
{
console.WriteLine(e.Data);
}
},
(s, e) =>
{
if (e.Data != null && !e.Data.Contains("creating"))
{
console.WriteLine(e.Data);
}
}, false, project.Solution.CurrentDirectory, false, RunWithSystemPaths);
if (Shell.DebugMode)
{
console.WriteLine(Path.GetFileNameWithoutExtension(commandName) + " " + arguments);
}
if (result.ExitCode == 0)
{
result.Executable = executable;
}
return(result);
}
public override LinkResult Link(IConsole console, IStandardProject superProject, IStandardProject project,
CompileResult assemblies, string outputPath)
{
var settings = GetSettings(superProject);
var result = new LinkResult();
var startInfo = new ProcessStartInfo();
if (Platform.PlatformIdentifier == PlatformID.Unix)
{
startInfo.FileName = "g++";
}
else
{
startInfo.FileName = Path.Combine(BaseDirectory, "bin", "g++" + Platform.ExecutableExtension);
}
if (project.Type == ProjectType.StaticLibrary)
{
if (Platform.PlatformIdentifier == PlatformID.Unix)
{
startInfo.FileName = "ar";
}
else
{
startInfo.FileName = Path.Combine(BaseDirectory, "bin", "ar" + Platform.ExecutableExtension);
}
}
startInfo.WorkingDirectory = project.Solution.CurrentDirectory;
if (!System.IO.File.Exists(startInfo.FileName) && Platform.PlatformIdentifier != PlatformID.Unix)
{
result.ExitCode = -1;
console.WriteLine("Unable to find linker executable (" + startInfo.FileName + ") Check project compiler settings.");
return(result);
}
var objectArguments = string.Empty;
foreach (var obj in assemblies.ObjectLocations)
{
objectArguments += obj + " ";
}
var libs = string.Empty;
foreach (var lib in assemblies.LibraryLocations)
{
libs += lib + " ";
}
var outputDir = Path.GetDirectoryName(outputPath);
if (!Directory.Exists(outputDir))
{
Directory.CreateDirectory(outputDir);
}
var outputName = Path.GetFileNameWithoutExtension(outputPath) + ExecutableExtension;
if (project.Type == ProjectType.StaticLibrary)
{
outputName = Path.GetFileNameWithoutExtension(outputPath) + StaticLibraryExtension;
}
var executable = Path.Combine(outputDir, outputName);
var linkedLibraries = string.Empty;
foreach (var libraryPath in project.StaticLibraries)
{
var relativePath = Path.GetDirectoryName(libraryPath);
var libName = Path.GetFileNameWithoutExtension(libraryPath).Substring(3);
linkedLibraries += string.Format("-L\"{0}\" -l{1} ", relativePath, libName);
}
foreach (var lib in project.BuiltinLibraries)
{
linkedLibraries += string.Format("-l{0} ", lib);
}
// Hide console window
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardInput = true;
startInfo.CreateNoWindow = true;
if (project.Type == ProjectType.StaticLibrary)
{
startInfo.Arguments = string.Format("rvs {0} {1}", executable, objectArguments);
}
else
{
startInfo.Arguments = string.Format("{0} -o{1} {2} -Wl,--start-group {3} {4} -Wl,--end-group",
GetLinkerArguments(project), executable, objectArguments, linkedLibraries, libs);
}
//console.WriteLine(Path.GetFileNameWithoutExtension(startInfo.FileName) + " " + startInfo.Arguments);
//console.WriteLine ("[LL] - " + startInfo.Arguments);
using (var process = Process.Start(startInfo))
{
process.OutputDataReceived += (sender, e) =>
{
//console.WriteLine(e.Data);
};
process.ErrorDataReceived += (sender, e) =>
{
if (e.Data != null && !e.Data.Contains("creating"))
{
console.WriteLine(e.Data);
}
};
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
result.ExitCode = process.ExitCode;
if (result.ExitCode == 0)
{
result.Executable = executable;
}
}
return(result);
}
private Task<LinkResult> CreateTask(FluentConfiguration fluentConfiguration, HttpWebRequest webRequest, string originalUrl)
{
return Task<LinkResult>.Factory.StartNew(() =>
{
if (fluentConfiguration.Bot != null)
{
fluentConfiguration.Bot.OnRequest(webRequest);
}
_beforeConfigurers.ForEach(x => x(webRequest));
var result = new LinkResult {Url = new Uri(originalUrl, UriKind.RelativeOrAbsolute)};
HttpWebResponse webResponse = null;
try
{
webResponse = (HttpWebResponse) webRequest.GetResponse();
result.StatusCode = webResponse.StatusCode;
}
catch (WebException we)
{
result.StatusCode = we.Response != null ? ((HttpWebResponse) we.Response).StatusCode : HttpStatusCode.NotFound;
}
finally
{
if (webResponse != null)
{
_afterConfigurers.ForEach(x => x(webResponse));
webResponse.Close();
}
}
return result;
});
}
/// <summary>
/// Mescla o dois resultados informados.
/// </summary>
/// <param name="mergeType">Tipo do Merge.</param>
/// <param name="leftResult"></param>
/// <param name="rightResult"></param>
/// <returns></returns>
private static LinkResult Merge(MergeType mergeType, LinkResult leftResult, LinkResult rightResult)
{
var intersectEntities = new List <int[]>();
if (rightResult != null)
{
for (var i = 0; i < leftResult.Entities.Length; i++)
{
for (var j = 0; j < rightResult.Entities.Length; j++)
{
if (leftResult.Entities[i] == rightResult.Entities[j])
{
intersectEntities.Add(new int[] {
i,
j
});
}
}
}
}
var entities = rightResult != null?leftResult.Entities.Union(rightResult.Entities).ToArray() : leftResult.Entities;
var items = new List <object[]>();
if (mergeType == MergeType.Intersect)
{
foreach (var rightItem in rightResult.Items)
{
foreach (var leftItem in leftResult.Items)
{
if (IsIntersect(intersectEntities, leftItem, rightItem))
{
items.Add(Concat(leftResult.Entities, leftItem, rightResult.Entities, rightItem, entities));
}
}
}
}
else if (mergeType == MergeType.Union)
{
if ((rightResult.Entities.Length - intersectEntities.Count) > (leftResult.Entities.Length - intersectEntities.Count))
{
var aux = leftResult;
leftResult = rightResult;
rightResult = aux;
}
var leftItems = new List <object[]>();
foreach (var leftItem in leftResult.Items)
{
leftItems.Add(Concat(leftResult.Entities, leftItem, null, null, entities));
}
foreach (var rightItem in rightResult.Items)
{
var isIntersect = false;
foreach (var leftItem in leftItems)
{
if (IsIntersect(intersectEntities, leftItem, rightItem))
{
isIntersect = true;
break;
}
}
if (!isIntersect)
{
if ((rightResult.Entities.Length - intersectEntities.Count) != (leftResult.Entities.Length - intersectEntities.Count))
{
foreach (var leftItem in leftItems)
{
items.Add(Concat(rightResult.Entities, rightItem, leftResult.Entities, leftItem, entities));
}
}
else
{
items.Add(Concat(rightResult.Entities, rightItem, null, null, entities));
}
}
}
items.AddRange(leftItems);
}
else if (mergeType == MergeType.LeftJoin)
{
foreach (var leftItem in leftResult.Items)
{
bool isIntersect = false;
foreach (var rightItem in rightResult.Items)
{
if (IsIntersect(intersectEntities, leftItem, rightItem))
{
items.Add(Concat(leftResult.Entities, leftItem, rightResult.Entities, rightItem, entities));
isIntersect = true;
break;
}
}
if (!isIntersect)
{
items.Add(Concat(leftResult.Entities, leftItem, null, null, entities));
}
}
}
leftResult = new LinkResult {
Entities = entities,
Items = items
};
return(leftResult);
}
public override async Task <bool> PostBuild(IConsole console, IProject project, LinkResult linkResult)
{
if ((project is IStandardProject) && (project as IStandardProject).Type == ProjectType.Executable)
{
var result = await ObjCopy(console, project, linkResult, AssemblyFormat.Binary);
if (result.ExitCode == 0)
{
result = await ObjCopy(console, project, linkResult, AssemblyFormat.IntelHex);
}
return(result.ExitCode == 0);
}
return(true);
}
public override ProcessResult Size(IConsole console, IStandardProject project, LinkResult linkResult)
{
var result = new ProcessResult();
result.ExitCode = PlatformSupport.ExecuteShellCommand(SizeExecutable, linkResult.Executable,
(s, e) => console.WriteLine(e.Data),
(s, e) => console.WriteLine(e.Data),
false, string.Empty, false, RunWithSystemPaths);
return(result);
}
public override ProcessResult Size(IConsole console, IStandardProject project, LinkResult linkResult)
{
var result = new ProcessResult();
var startInfo = new ProcessStartInfo();
startInfo.FileName = Path.Combine(BaseDirectory, "arm-none-eabi-size" + Platform.ExecutableExtension);
if (!System.IO.File.Exists(startInfo.FileName))
{
console.WriteLine("Unable to find tool (" + startInfo.FileName + ") check project compiler settings.");
result.ExitCode = -1;
return(result);
}
startInfo.Arguments = string.Format("{0}", linkResult.Executable);
// Hide console window
startInfo.UseShellExecute = false;
startInfo.RedirectStandardOutput = true;
startInfo.RedirectStandardError = true;
startInfo.RedirectStandardInput = true;
startInfo.CreateNoWindow = true;
using (var process = Process.Start(startInfo))
{
process.OutputDataReceived += (sender, e) => { console.WriteLine(e.Data); };
process.ErrorDataReceived += (sender, e) => { console.WriteLine(e.Data); };
process.BeginOutputReadLine();
process.BeginErrorReadLine();
process.WaitForExit();
result.ExitCode = process.ExitCode;
}
return(result);
}
