public void ValidateRequest_Default_Success()
{
var file = new LibraryFileInfo
{
Id = Guid.NewGuid(),
TenantId = Guid.NewGuid(),
AlternateId = Guid.NewGuid().ToString(),
Attributes = "Hidden",
ContentType = MediaTypeNames.Application.Octet,
CreatedOn = DateTimeOffset.UtcNow,
FullPath = "C:/foo.txt",
Name = "foo.txt",
LastAccessedOn = DateTimeOffset.UtcNow,
LastModifiedOn = DateTimeOffset.UtcNow,
Length = 123,
ParentDirectoryId = Guid.NewGuid(),
PartitionId = Guid.NewGuid(),
};
LibraryItemInfo libItem = JsonConvert.DeserializeObject <LibraryItemInfo>(JsonConvert.SerializeObject(file));
libItem.Should().NotBeNull();
libItem.Should().BeOfType <LibraryFileInfo>();
LibraryFileInfo?newFile = libItem as LibraryFileInfo;
newFile.Should().BeEquivalentTo(file);
}
/// <summary>
/// Функция рекурсивно анализирует все VHDL файлы библиотеки
/// </summary>
/// <param name="path"></param>
private void AnalyzeFolder(string path)
{
logger.WriteLineFormat("Analyzing folder {0}", path);
string LibraryName = Path.GetFileNameWithoutExtension(path);
if (Directory.Exists(path) == true)
{
string[] dirs = Directory.GetDirectories(path);
foreach (string dir in dirs)
{
AnalyzeFolder(dir);
}
string[] files = Directory.GetFiles(path);
foreach (string file in files)
{
if (isVHDLCodeFile(file) == true)
{
logger.WriteLineFormat("Added file for analyze {0}", file);
LibraryFileInfo inf = LibraryFileInfo.AnalyzeFile(file, LibraryName);
if (inf != null)
{
libraryFiles.Add(inf);
}
}
}
}
}
/// <summary>
/// Организация очереди для компиляции
/// </summary>
private void CreateQueue()
{
logger.WriteLine("");
logger.WriteLine("Creating compilation queue");
List <LibraryFileInfo> tmp = new List <LibraryFileInfo>(libraryFiles);
foreach (LibraryFileInfo file in tmp)
{
if (file.Dependencies.Count == 0)
{
compileQueue.Add(file);
}
}
foreach (LibraryFileInfo file in compileQueue)
{
tmp.Remove(file);
}
while (tmp.Count != 0)
{
LibraryFileInfo fileToRemove = null;
foreach (LibraryFileInfo file in tmp)
{
bool include = true;
foreach (LibraryFileInfo dep in file.Dependencies)
{
if (compileQueue.Contains(dep) == false)
{
include = false;
}
}
if (include == true)
{
compileQueue.Add(file);
fileToRemove = file;
break;
}
}
if (fileToRemove != null)
{
tmp.Remove(fileToRemove);
}
}
logger.WriteLine("Compilation order: ");
foreach (LibraryFileInfo file in compileQueue)
{
logger.WriteLineFormat("Tarh: {0}", file.Path);
}
}
public static LibraryDownloadsInfo Parse(JObject json)
{
JToken temp;
Dictionary <string, LibraryFileInfo> classifiers = new Dictionary <string, LibraryFileInfo>();
LibraryFileInfo artifact = new LibraryFileInfo();
if (json.TryGetValue("classifiers", out temp) && temp.Type == JTokenType.Object)
{
foreach (KeyValuePair <string, JToken> jsonPro in JObject.Parse(temp.ToString()))
{
if (jsonPro.Value.Type == JTokenType.Object)
{
classifiers.Add(jsonPro.Key, LibraryFileInfo.Parse(JObject.Parse(jsonPro.Value.ToString())));
}
}
}
if (json.TryGetValue("artifact", out temp) && temp.Type == JTokenType.Object)
{
artifact = LibraryFileInfo.Parse(JObject.Parse(temp.ToString()));
}
return(new LibraryDownloadsInfo(classifiers, artifact));
}
public LibraryDownloadsInfo()
{
Classifiers = new Dictionary <string, LibraryFileInfo>();
Artifact = new LibraryFileInfo();
}
public LibraryDownloadsInfo(Dictionary <string, LibraryFileInfo> classifiers, LibraryFileInfo artifact)
{
Classifiers = classifiers;
Artifact = artifact;
}
/// <summary>
/// Обновление служебной информации
/// </summary>
public void UpdateLibraryInfo()
{
libraryFileInfo = LibraryFileInfo.AnalyseText(text, filePath, LibraryName);
}
public VHDL_CodeFile(string filePath, string libraryName, VHDLCompiler compiler)
: base(filePath, libraryName, ModelingLanguage.VHDL)
{
this.compiler = compiler;
libraryFileInfo = LibraryFileInfo.AnalyseText(text, filePath, LibraryName);
}
/// <summary>
/// Компиляция файла
/// </summary>
/// <param name="file"></param>
private void CompileFile(LibraryFileInfo file, VhdlParserSettings settings, RootDeclarativeRegion rootScope)
{
LibraryInfo currentLibrary = null;
foreach (LibraryInfo inf in parsedLibraries)
{
if (inf.Name.EqualsIgnoreCase(file.LibraryName))
{
currentLibrary = inf;
break;
}
}
if (currentLibrary == null)
{
currentLibrary = new LibraryInfo(file.LibraryName);
parsedLibraries.Add(currentLibrary);
rootScope.Libraries.Add(currentLibrary.LibraryScope);
}
try
{
Console.WriteLine("parsing file {0} ", file.Path);
VhdlFile vhdfile = VhdlParserWrapper.parseFile(file.Path, settings, rootScope, currentLibrary.LibraryScope, libraryManager);
foreach (LibraryUnit unit in vhdfile.Elements)
{
if (unit is PackageDeclaration)
{
PackageDeclaration pd = unit as PackageDeclaration;
pd.Parent = null;
bool foundPackage = false;
foreach (PackageInfo inf in currentLibrary.Packages)
{
if (inf.Name.EqualsIdentifier(pd.Identifier))
{
inf.DeclarationPath = file.Path;
string path = FormCompilePath(file.Path, "decl");
inf.DeclarationLibPath = path;
inf.Declaration = pd;
foundPackage = true;
break;
}
}
if (foundPackage == false)
{
PackageInfo pi = new PackageInfo(pd.Identifier, currentLibrary.Name, file.Path);
pi.DeclarationPath = file.Path;
string path = FormCompilePath(file.Path, "decl");
pi.DeclarationLibPath = path;
pi.BodyLibPath = path;
pi.Declaration = pd;
currentLibrary.Packages.Add(pi);
}
}
if (unit is PackageBody)
{
PackageBody pb = unit as PackageBody;
pb.Parent = null;
bool foundPackage = false;
foreach (PackageInfo inf in currentLibrary.Packages)
{
if (inf.Name.EqualsIdentifier(pb.Package.Identifier))
{
inf.BodyPath = file.Path;
string path = FormCompilePath(file.Path, "body");
inf.BodyLibPath = path;
inf.Body = pb;
foundPackage = true;
break;
}
}
if (foundPackage == false)
{
PackageInfo pi = new PackageInfo(pb.Package.Identifier, currentLibrary.Name, file.Path);
pi.BodyPath = file.Path;
string path = FormCompilePath(file.Path, "body");
pi.BodyLibPath = path;
pi.Body = pb;
currentLibrary.Packages.Add(pi);
}
}
}
}
catch (Exception ex)
{
logger.WriteLineFormat("parsing {0} failed", file.Path);
logger.WriteLine(ex.Message);
logger.WriteLine(LoggerMessageVerbosity.Error, ex.Message);
}
}
/// <summary>
/// Если обьект класса CodeFile является VHDL_CodeFile,
/// то провести его обработку и встроить в общую библиотеку,
/// новый поток не создается,
/// ошибки выписываются в обьект file
/// </summary>
/// <param name="file"></param>
public override void ProcessCodeFile(CodeFile file)
{
try
{
lock (this)
{
isBusy = true;
if ((file is VHDL_CodeFile) && ((file as VHDL_CodeFile).LibraryName == "work"))
{
VHDL_CodeFile vhdlCode = (file as VHDL_CodeFile);
vhdlCode.ParseException = null;
vhdlCode.ParseSyntaxException = null;
vhdlCode.ParseSemanticException = null;
VhdlFile oldFile = null;
foreach (VhdlFile f in currentLibrary.Files)
{
if (f.FilePath == file.FilePath)
{
oldFile = f;
break;
}
}
if (oldFile != null)
{
currentLibrary.Files.Remove(oldFile);
}
IParseTree tree;
CommonTokenStream tokenStream;
ICharStream stream = new CaseInsensitiveStringStream(file.Text, file.FilePath);
VhdlFile ParsedFile = Parse(stream, currentLibrary, out tokenStream, out tree);
if (ParsedFile != null)
{
ParsedFile.FilePath = file.FilePath;
}
vhdlCode.File = ParsedFile;
vhdlCode.ParseSemanticException = parseSemanticException;
vhdlCode.ParseSyntaxException = parseSyntaxException;
vhdlCode.ParseException = parseException;
vhdlCode.TokenStream = tokenStream;
vhdlCode.Tree = tree;
vhdlCode.LibraryFileInfo = LibraryFileInfo.AnalyseText(vhdlCode.Text, vhdlCode.FilePath, vhdlCode.LibraryName);
foreach (CodeFile f in vhdlCode.Dependencies)
{
f.NeedForUpdate = true;
}
SetDependencies();
}
base.ProcessCodeFile(file);
isBusy = false;
}
}
catch (Exception ex)
{
Messages.Add(new DiagnosticMessage(string.Format("Message: {0}\n Source: {1}\n StackTrace: {2}\n HelpLink: {3}", ex.Message, ex.Source, ex.StackTrace, ex.HelpLink)));
NotifyCollectionChanged();
}
}
