public void RelationTable_can_store_one_relation() { PackedExecution packedExecution = new PackedExecution(); PackedExecution.Builder packedExecutionBuilder = new PackedExecution.Builder(packedExecution); long hash = 1; string name = "ShellCommon.Shell.ShellCommon.Shell.Merged.Winmetadata"; PipId pipId = packedExecutionBuilder.PipTableBuilder.Add(hash, name, PipType.Process); packedExecution.ConstructRelationTables(); RelationTable <PipId, PipId> relationTable = packedExecution.PipDependencies; relationTable.Add(new[] { pipId }.AsSpan()); XAssert.AreEqual(1, relationTable[pipId].Length); ReadOnlySpan <PipId> relations = relationTable[pipId]; XAssert.AreEqual(pipId, relations[0]); RelationTable <PipId, PipId> inverseRelationTable = relationTable.Invert(); XAssert.AreEqual(1, inverseRelationTable[pipId].Length); XAssert.AreEqual(pipId, inverseRelationTable[pipId][0]); }
public void RelationTable_can_be_built_unordered() { PackedExecution packedExecution = new PackedExecution(); PackedExecution.Builder packedExecutionBuilder = new PackedExecution.Builder(packedExecution); long hash = 1; string name = "ShellCommon.Shell.ShellCommon.Shell.Merged.Winmetadata"; PipId pipId1 = packedExecutionBuilder.PipTableBuilder.Add(hash, name, PipType.Process); PipId pipId2 = packedExecutionBuilder.PipTableBuilder.Add(hash + 1, $"{name}2", PipType.Process); PipId pipId3 = packedExecutionBuilder.PipTableBuilder.Add(hash + 2, $"{name}3", PipType.SealDirectory); PipId pipId4 = packedExecutionBuilder.PipTableBuilder.Add(hash + 3, $"{name}4", PipType.Process); packedExecution.ConstructRelationTables(); RelationTable <PipId, PipId> pipDependencyTable = packedExecution.PipDependencies; pipDependencyTable.FillToBaseTableCount(); pipDependencyTable.AddUnordered(pipId4, new PipId[] { pipId2, pipId3 }); pipDependencyTable.AddUnordered(pipId3, new PipId[] { pipId1 }); pipDependencyTable.AddUnordered(pipId2, new PipId[] { pipId1 }); XAssert.IsTrue(pipDependencyTable.MayBeUnordered); CheckRelation(packedExecution, pipId1, pipId2, pipId3, pipId4, pipDependencyTable); }
static void Main(string[] args) { if (args.Length == 0) { Console.WriteLine("Program parameter: input file path"); } else { try { using (var streamReader = File.OpenText(args[0])) { var scanner = new Scanner(); var tokenString = scanner.Scan(streamReader.ReadToEnd()); var identifiers = scanner.identifiers.Keys.Except(Scanner.Keywords); var constants = scanner.constants.Keys; var relationTable = new RelationTable(identifiers, constants); var tree = new Parser(relationTable).Parse(tokenString); var codeGenerator = new CodeGenerator(); var assembly = codeGenerator.ColdFire(tree); Console.WriteLine(assembly); } } catch (FileNotFoundException) { Console.WriteLine("File not found"); } }
/// <nodoc /> public Builder(PackedExecution packedExecution) { PackedExecution = packedExecution; // these are sorted as much as possible given construction order constraints StringTableBuilder = new PackedTable.StringTable.CachingBuilder(PackedExecution.StringTable); PathTableBuilder = new NameTable.Builder(PackedExecution.PathTable, StringTableBuilder); DirectoryTableBuilder = new DirectoryTable.CachingBuilder(PackedExecution.DirectoryTable, PathTableBuilder); FileTableBuilder = new FileTable.CachingBuilder(PackedExecution.FileTable, PathTableBuilder); PipTableBuilder = new PipTable.Builder(PackedExecution.PipTable, StringTableBuilder); PipExecutionTableBuilder = new PipExecutionTable.Builder <PipExecutionTable>(PackedExecution.PipExecutionTable); ProcessExecutionTableBuilder = new ProcessExecutionTable.Builder <ProcessExecutionTable>(PackedExecution.ProcessExecutionTable); ProcessPipExecutionTableBuilder = new ProcessPipExecutionTable.Builder <ProcessPipExecutionTable>(PackedExecution.ProcessPipExecutionTable); PipTableBuilder = new PipTable.Builder(PackedExecution.PipTable, StringTableBuilder); WorkerTableBuilder = new WorkerTable.CachingBuilder(PackedExecution.WorkerTable, StringTableBuilder); if (packedExecution.ConsumedFiles != null) { ConsumedFilesBuilder = new RelationTable <PipId, FileId> .Builder(packedExecution.ConsumedFiles); DeclaredInputDirectoriesBuilder = new RelationTable <PipId, DirectoryId> .Builder(packedExecution.DeclaredInputDirectories); DeclaredInputFilesBuilder = new RelationTable <PipId, FileId> .Builder(packedExecution.DeclaredInputFiles); DirectoryContentsBuilder = new RelationTable <DirectoryId, FileId> .Builder(packedExecution.DirectoryContents); } }
static void Main(string[] args) { if (args.Length == 0) { MessageBox.Show("Program parameter: input file path", "Help", MessageBoxButtons.OK, MessageBoxIcon.Information); } else { try { using (var streamReader = File.OpenText(args[0])) { var scanner = new Scanner(); var tokenString = scanner.Scan(streamReader.ReadToEnd()); var identifiers = scanner.identifiers.Keys.Except(Scanner.Keywords); var constants = scanner.constants.Keys; var relationTable = new RelationTable(identifiers, constants); var tree = new Parser(relationTable).Parse(tokenString); Application.Run(new TreeViewer(tree)); } } catch (FileNotFoundException) { MessageBox.Show("File not found", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
public void RelationTable_can_be_built() { PackedExecution packedExecution = new PackedExecution(); PackedExecution.Builder packedExecutionBuilder = new PackedExecution.Builder(packedExecution); long hash = 1; string name = "ShellCommon.Shell.ShellCommon.Shell.Merged.Winmetadata"; PipId pipId = packedExecutionBuilder.PipTableBuilder.Add(hash, name, PipType.Process); PipId pipId2 = packedExecutionBuilder.PipTableBuilder.Add(hash + 1, $"{name}2", PipType.Process); PipId pipId3 = packedExecutionBuilder.PipTableBuilder.Add(hash + 2, $"{name}3", PipType.Process); packedExecution.ConstructRelationTables(); RelationTable <PipId, PipId> relationTable = packedExecution.PipDependencies; RelationTable <PipId, PipId> .Builder builder = new RelationTable <PipId, PipId> .Builder(relationTable); // add relations in any order builder.Add(pipId3, pipId2); builder.Add(pipId3, pipId); builder.Add(pipId, pipId3); builder.Add(pipId, pipId2); // done adding relations; flush to table builder.Complete(); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, relationTable[pipId].ToArray(), true); XAssert.AreArraysEqual(new PipId[0], relationTable[pipId2].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId, pipId2 }, relationTable[pipId3].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, relationTable.Enumerate(pipId).ToArray(), true); XAssert.AreArraysEqual(new PipId[0], relationTable.Enumerate(pipId2).ToArray(), true); XAssert.AreArraysEqual(new[] { pipId, pipId2 }, relationTable.Enumerate(pipId3).ToArray(), true); }
/// <summary> /// Initialize all the elements of this index, as concurrently as possible. /// </summary> /// <param name="progressAction">Action called (from an arbitrary Task thread) to report completion of various index parts.</param> /// <returns>A task which is complete when the index is fully built.</returns> public Task InitializeAsync(Action <string> progressAction) { // All the things we want to do concurrently to index our data. // This is broken out as a separate list since it is useful to run these serially sometimes when debugging // (e.g. when the hacky Span sort code you found online starts hitting stack overflows, whereas the .NET 5 // Span.Sort method just works...). List <(string, Action)> actions = new List <(string, Action)> { ("Sorted strings", () => StringIndex = new StringIndex(PackedExecution.StringTable)), ("Indexed pip names", () => PipNameIndex = new NameIndex(PackedExecution.PipTable.PipNameTable)), ("Indexed paths", () => PathIndex = new NameIndex(PackedExecution.PathTable)), ("Indexed pip dependents", () => PipDependents = PackedExecution.PipDependencies.Invert()), ("Indexed file consumers", () => FileConsumers = PackedExecution.ConsumedFiles.Invert()), ("Indexed produced files", () => ProducedFiles = RelationTable <FileId, PipId> .FromSingleValueTable(PackedExecution.FileProducer, PackedExecution.PipTable) .Invert()), ("Indexed input-file-declaring pips", () => InputFileDeclarers = PackedExecution.DeclaredInputFiles.Invert()), ("Indexed input-directory-declaring pips", () => InputDirectoryDeclarers = PackedExecution.DeclaredInputDirectories.Invert()), ("Indexed parent directories", () => ParentDirectories = PackedExecution.DirectoryContents.Invert()) }; // Concurrently generate all the sorted strings, name indices, and inverse relationships that we need. return(Task.WhenAll( actions .Select(tuple => Task.Run( () => { tuple.Item2(); progressAction(tuple.Item1); })) .ToArray())); }
public void RelationTable_can_be_built() { PackedExecution packedExecution = new PackedExecution(); PackedExecution.Builder packedExecutionBuilder = new PackedExecution.Builder(packedExecution); long hash = 1; string name = "ShellCommon.Shell.ShellCommon.Shell.Merged.Winmetadata"; PipId pipId1 = packedExecutionBuilder.PipTableBuilder.Add(hash, name, PipType.Process); PipId pipId2 = packedExecutionBuilder.PipTableBuilder.Add(hash + 1, $"{name}2", PipType.Process); PipId pipId3 = packedExecutionBuilder.PipTableBuilder.Add(hash + 2, $"{name}3", PipType.SealDirectory); PipId pipId4 = packedExecutionBuilder.PipTableBuilder.Add(hash + 3, $"{name}4", PipType.Process); packedExecution.ConstructRelationTables(); RelationTable <PipId, PipId> relationTable = packedExecution.PipDependencies; RelationTable <PipId, PipId> .Builder builder = new RelationTable <PipId, PipId> .Builder(relationTable); // add relations in any order (but without cycles) // 1 <- 2 // 1 <- 3 // 2 <- 4 // 3 <- 4 builder.Add(pipId2, pipId1); builder.Add(pipId3, pipId1); builder.Add(pipId4, pipId2); builder.Add(pipId4, pipId3); // done adding relations; flush to table builder.Complete(); CheckRelation(packedExecution, pipId1, pipId2, pipId3, pipId4, relationTable); }
/// <summary>After the base tables are populated, construct the (now properly sized) relation tables.</summary> public void ConstructRelationTables() { FileProducer = new SingleValueTable <FileId, PipId>(FileTable); ConsumedFiles = new RelationTable <PipId, FileId>(PipTable, FileTable); DeclaredInputDirectories = new RelationTable <PipId, DirectoryId>(PipTable, DirectoryTable); DeclaredInputFiles = new RelationTable <PipId, FileId>(PipTable, FileTable); DirectoryContents = new RelationTable <DirectoryId, FileId>(DirectoryTable, FileTable); PipDependencies = new RelationTable <PipId, PipId>(PipTable, PipTable); }
/// <summary> /// After the base tables are populated, construct the (now properly sized) relation tables. /// </summary> public void ConstructRelationTables() { //System.Diagnostics.ContractsLight.Contract.Requires(ConsumedFiles == null, "Must only construct relation tables once"); ConsumedFiles = new RelationTable <PipId, FileId>(PipTable, FileTable); DeclaredInputDirectories = new RelationTable <PipId, DirectoryId>(PipTable, DirectoryTable); DeclaredInputFiles = new RelationTable <PipId, FileId>(PipTable, FileTable); DirectoryContents = new RelationTable <DirectoryId, FileId>(DirectoryTable, FileTable); PipDependencies = new RelationTable <PipId, PipId>(PipTable, PipTable); }
static void Main(string[] args) { if (args.Length == 0) Console.WriteLine("Program parameter: input file path"); else try { using (var streamReader = File.OpenText(args[0])) { var scanner = new Scanner(); var tokenString = scanner.Scan(streamReader.ReadToEnd()); var identifiers = scanner.identifiers.Keys.Except(Scanner.Keywords); var constants = scanner.constants.Keys; var relationTable = new RelationTable(identifiers, constants); var tree = new Parser(relationTable).Parse(tokenString); var codeGenerator = new CodeGenerator(); var assembly = codeGenerator.ColdFire(tree); Console.WriteLine(assembly); } } catch (FileNotFoundException) { Console.WriteLine("File not found"); } catch (IOException e) { Console.WriteLine(e.Message); } catch (LexicalException e) { Console.WriteLine(e.Message); } catch (SyntaxException e) { Console.WriteLine(e.Message); } catch (SemanticException e) { Console.WriteLine(e.Message); } catch (RelationException<string, Relation> e) { Console.WriteLine(e.Message); } }
public void RelationTable_can_store_multiple_relations() { PackedExecution packedExecution = new PackedExecution(); PackedExecution.Builder packedExecutionBuilder = new PackedExecution.Builder(packedExecution); long hash = 1; string name = "ShellCommon.Shell.ShellCommon.Shell.Merged.Winmetadata"; PipId pipId = packedExecutionBuilder.PipTableBuilder.Add(hash, name, PipType.Process); PipId pipId2 = packedExecutionBuilder.PipTableBuilder.Add(hash + 1, $"{name}2", PipType.Process); PipId pipId3 = packedExecutionBuilder.PipTableBuilder.Add(hash + 2, $"{name}3", PipType.Process); XAssert.AreNotEqual(pipId, pipId2); XAssert.AreNotEqual(pipId, pipId3); XAssert.AreNotEqual(pipId2, pipId3); packedExecution.ConstructRelationTables(); RelationTable <PipId, PipId> relationTable = packedExecution.PipDependencies; relationTable.Add(new[] { pipId2, pipId3 }.AsSpan()); XAssert.AreEqual(2, relationTable[pipId].Length); ReadOnlySpan <PipId> relations = relationTable[pipId]; XAssert.AreEqual(pipId2, relations[0]); XAssert.AreEqual(pipId3, relations[1]); relationTable.Add(new[] { pipId }.AsSpan()); XAssert.AreEqual(1, relationTable[pipId2].Length); relationTable.Add(new[] { pipId, pipId2, pipId3 }.AsSpan()); XAssert.AreEqual(3, relationTable[pipId3].Length); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, relationTable[pipId].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId, pipId2, pipId3 }, relationTable[pipId3].ToArray(), true); RelationTable <PipId, PipId> inverseRelationTable = relationTable.Invert(); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, inverseRelationTable[pipId].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId, pipId3 }, inverseRelationTable[pipId2].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId, pipId3 }, inverseRelationTable[pipId3].ToArray(), true); }
private static int RecursiveCalculation(Relation relation, int multiply, RelationTable table) { Console.Write($"{multiply}"); var sum = 0; if (!relation.Children.Any()) { return(multiply); } Console.Write("*(1+"); foreach (var(key, value) in relation.Children) { sum += RecursiveCalculation(table[key], value, table); } Console.Write(")"); return(multiply * (sum + 1)); }
static void Main(string[] args) { if (args.Length == 0) MessageBox.Show("Program parameter: input file path", "Help", MessageBoxButtons.OK, MessageBoxIcon.Information); else try { using (var streamReader = File.OpenText(args[0])) { var scanner = new Scanner(); var tokenString = scanner.Scan(streamReader.ReadToEnd()); var identifiers = scanner.identifiers.Keys.Except(Scanner.Keywords); var constants = scanner.constants.Keys; var relationTable = new RelationTable(identifiers, constants); var tree = new Parser(relationTable).Parse(tokenString); Application.Run(new TreeViewer(tree)); } } catch (FileNotFoundException) { MessageBox.Show("File not found", "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } catch (IOException e) { MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } catch (LexicalException e) { MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } catch (SyntaxException e) { MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } catch (RelationException<string, Relation> e) { MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Warning); } }
/// <summary> /// Create syntax analyser instance /// </summary> /// <param name="relationTable">Wirth-Weber precedence relationship table</param> public Parser(RelationTable relationTable) { this.relationTable = relationTable; }
/// <summary> /// Create syntax analyser instance /// </summary> /// <param name="relationTable">Wirth-Weber precedence relationship table</param> public Parser(RelationTable relationTable) { this.relationTable = relationTable; }
private static void CheckRelation(PackedExecution packedExecution, PipId pipId1, PipId pipId2, PipId pipId3, PipId pipId4, RelationTable <PipId, PipId> relationTable) { XAssert.AreArraysEqual(new PipId[0], relationTable[pipId1].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId1 }, relationTable[pipId2].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId1 }, relationTable[pipId3].ToArray(), true); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, relationTable[pipId4].ToArray(), true); XAssert.AreArraysEqual(new PipId[0], relationTable.Enumerate(pipId1).ToArray(), true); XAssert.AreArraysEqual(new[] { pipId1 }, relationTable.Enumerate(pipId2).ToArray(), true); XAssert.AreArraysEqual(new[] { pipId2, pipId3 }, relationTable.Enumerate(pipId4).ToArray(), true); // try traversing from pipId4; should traverse over pipId3 and reach pipId (as well as pipId2) IEnumerable <PipId> reachable = relationTable.Traverse( pipId4, p => packedExecution.PipTable[p].PipType == PipType.Process ? TraversalFilterResult.AcceptAndHalt : TraversalFilterResult.RejectAndContinue); XAssert.AreArraysEqual(new[] { pipId1, pipId2 }, reachable.OrderBy(p => p.Value).ToArray(), true); }