public static void Main(string[] args)
{
//construct a simple binary tree using treenodes
TreeNode Node1 = new TreeNode(3);
TreeNode Node2 = new TreeNode(9);
TreeNode Node3 = new TreeNode(20);
TreeNode Node4 = new TreeNode(15);
TreeNode Node5 = new TreeNode(17);
TreeNode Node6 = new TreeNode(11);
TreeNode Node7 = new TreeNode(13);
TreeNode Node8 = new TreeNode(71);
Node1.Left = Node2;
Node1.Right = Node3;
Node3.Left = Node4;
Node3.Right = Node5;
Node4.Left = Node6;
Node4.Right = Node7;
Node5.Left = Node8;
TreePrinter printer = new TreePrinter();
printer.PrintLevel(Node1);
printer.newPrintLevel(Node1);
}
public void CodeBytesTest() //no assert!
{
Stream ins = File.OpenRead(@"D:\MFF\ZS_2019\c#_repos\Huffman1\Huffman1Tests\bin\Debug\netcoreapp3.0\TestFiles\Huff2\Ins\simple4.in");
BinaryReader reader = new BinaryReader(ins);
HuffmanReader HuffReader = new HuffmanReader(reader);
bool NotEmpty = HuffReader.ReadFileUsingBuffer();
//Build Huffman tree
TreeBuilder Builder = new TreeBuilder(HuffReader.ProvideSymbolsWihtWeights());
Node Root = Builder.BuildHuffTree();
TreePrinter.PrintNiceTree(Root, 0);
Stack <byte> path = new Stack <byte>();
HuffCompresor.CodeBytes(Root, path);
for (int i = 0; i < HuffCompresor.Codes.Length; i++)
{
if (HuffCompresor.Codes[i] != null)
{
Console.Write($"{i}: ");
for (int j = 0; j < HuffCompresor.Codes[i].Length; j++)
{
Console.Write($"{HuffCompresor.Codes[i][j]} ");
}
Console.WriteLine();
}
}
}
public void ReadTreeAndHeaderTest()
{
string inputFile = @"TestFiles\Huff3Tests\simple4.in.huff";
string[] arg = new string[1];
arg[0] = inputFile;
Program.Huff3OpenFiles(arg, out BinaryReader reader, out BinaryWriter writer);
Huff3TreeBuilder b = new Huff3TreeBuilder();
bool success = b.ReadHeaderAndTreeFromBinaryFile(reader);
Assert.IsNotNull(b.Root);
TreePrinter.PrintNiceTree(b.Root, 0);
reader.Close();
writer.Close();
}
/// <summary>
/// Performs the compilation process
/// </summary>
public void Compile()
{
// Tokenize
Write("Tokenising...");
List <Token> tokens = Tokenizer.GetAllTokens();
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
//WriteLine(string.Join("\n", tokens));
// Parse
Write("Parsing...");
ProgramNode tree = Parser.Parse(tokens);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done.");
//Display the Abstract Syntax Tree
WriteLine(TreePrinter.ToString(tree));
//Identify
Write("Identifying...");
Identifier.PerformIdentification(tree);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
//Type check
Write("Type Checking...");
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
WriteLine(TreePrinter.ToString(tree));
}
public void PrintNiceTreeTest()
{
ulong[] Test = new ulong[256];
Test[97] = 6;
Test[98] = 2;
Test[32] = 5;
Test[99] = 5;
Test[100] = 1;
Test[101] = 2;
Test[102] = 2;
Test[52] = 2;
TreeBuilder builder = new TreeBuilder(Test);
Node Root = builder.BuildHuffTree();
TreePrinter.PrintNiceTree(Root, 0);
}
/// <summary>
/// Performs the compilation process
/// </summary>
public void Compile()
{
// Tokenize
Write("Tokenising...");
List <Token> tokens = Tokenizer.GetAllTokens();
// changed this to spit out wats up rather than just killing the process
//if (Reporter.TokenizerHasErrors) return;
WriteLine("Done");
// Parse
Write("Parsing...");
ProgramNode tree = Parser.Parse(tokens);
// by returning it here it kills the process
//if (Reporter.ParserHasErrors) return;
WriteLine("Done");
// Identify
Write("Identifying...");
Identifier.PerformIdentification(tree);
//if (Reporter.ParserHasErrors) return;
WriteLine("Done");
// Type check
Write("Type Checking...");
Checker.PerformTypeChecking(tree);
//if (Reporter.CheckingHasErrors) return;
WriteLine("Done");
WriteLine(TreePrinter.ToString(tree));
// Code generation
Write("Generating code...");
TargetCode targetCode = Generator.GenerateCodeFor(tree);
//if (Reporter.HasErrors) return;
WriteLine("Done");
// Output
Write("Writing to file...");
Writer.WriteToFiles(targetCode);
//if (Reporter.HasErrors) return;
WriteLine("Done");
}
public void ReadTreeTest()
{
string inputFile = @"TestFiles\Huff3Tests\simple4.in.huff";
string[] arg = new string[1];
arg[0] = inputFile;
Program.Huff3OpenFiles(arg, out BinaryReader reader, out BinaryWriter writer);
reader.ReadUInt64(); //skip header
Huff3TreeBuilder b = new Huff3TreeBuilder();
bool f = false;
Node n = b.ReadTreeFromBinaryFile(reader, ref f);
Assert.IsNotNull(n);
TreePrinter.PrintNiceTree(n, 0);
Console.WriteLine(b.NumberOfSymbols);
reader.Close();
writer.Close();
}
public void PrintCompresedTreeTest()
{
ulong[] Test = new ulong[256];
Test[97] = 6;
Test[98] = 2;
Test[32] = 5;
Test[99] = 5;
Test[100] = 1;
Test[101] = 2;
Test[102] = 2;
Test[52] = 2;
TreeBuilder builder = new TreeBuilder(Test);
Node Root = builder.BuildHuffTree();
StreamWriter sw = new StreamWriter(@"TestFiles\myCompresTree.txt");
TreePrinter.PrintCompresedTree(Root, sw);
//sw.Flush();
}
private static void InvokeID3Algorithm(IDomainTree data)
{
var me = ID3Algorithm.CreateIt(data);
long startTime = DateTime.Now.Ticks;
me.BuildDecisionTree();
long endTime = DateTime.Now.Ticks;
long totalTime = (endTime - startTime) / 1000;
TreePrinter.PrintTree(me.DomainTree);
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine();
Console.WriteLine("Generating tree: {0} ms", totalTime);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
}
private static void BuildTree(Stack <List <HufmannLetter> > letters)
{
HuffmanTree tree = new HuffmanTree();
tree.Insert(letters.Peek()[2], 0, null); //ROOT
while (letters.Count != 0)
{
HufmannLetter parent = letters.Peek()[2]; //2A and 3D 's parent is 5AD
for (int i = letters.Peek().Count - 2; i >= 0; i--)
{
tree.Insert(letters.Peek()[i], i, parent); //if i =0, left child, else right child. Parent 5AD
}
letters.Pop();
}
TreePrinter btr = new TreePrinter(); //Print the tree
btr.Print(tree.Root);
Console.WriteLine();
}
public void PrintTreeBinaryTest()
{
Stream s = File.OpenWrite(@"D:\MFF\ZS_2019\c#_repos\Huffman1\Huffman1Tests\bin\Debug\netcoreapp3.0\TestFiles\Huff2\Outs\PrintTreeBin.out");
BinaryWriter writer = new BinaryWriter(s);
Stream ins = File.OpenRead(@"D:\MFF\ZS_2019\c#_repos\Huffman1\Huffman1Tests\bin\Debug\netcoreapp3.0\TestFiles\Huff2\Ins\simple4.in");
BinaryReader reader = new BinaryReader(ins);
HuffmanReader HuffReader = new HuffmanReader(reader);
bool NotEmpty = HuffReader.ReadFileUsingBuffer();
//Build Huffman tree
TreeBuilder Builder = new TreeBuilder(HuffReader.ProvideSymbolsWihtWeights());
Node Root = Builder.BuildHuffTree();
TreePrinter.PrintTreeBinary(Root, writer);
writer.Flush();
writer.Close();
reader.Close();
bool same = Utils.FileDiff(@"D:\MFF\ZS_2019\c#_repos\Huffman1\Huffman1Tests\bin\Debug\netcoreapp3.0\TestFiles\Huff2\Ins\Tree.in", @"D:\MFF\ZS_2019\c#_repos\Huffman1\Huffman1Tests\bin\Debug\netcoreapp3.0\TestFiles\Huff2\Outs\PrintTreeBin.out");
Assert.IsTrue(same);
}
public void JustPrintTree()
{
string inputFile = @"TestFiles\Huff3Tests\simple4.in";
string[] args = new string[1];
args[0] = inputFile;
bool opened = Program.OpenFile(args, out BinaryReader Reader, out BinaryWriter Writer);
if (!opened)
{
return;
}
//create HuffmanReader, that is going to count occurences of bytes in input file
HuffmanReader HuffReader = new HuffmanReader(Reader);
bool NotEmpty = HuffReader.ReadFileUsingBuffer();
//Build Huffman tree
TreeBuilder Builder = new TreeBuilder(HuffReader.ProvideSymbolsWihtWeights());
Node Root = Builder.BuildHuffTree();
TreePrinter.PrintNiceTree(Root, 0);
Reader.Close();
Writer.Close();
}
public override string ToString()
{
TreePrinter printer = new TreePrinter();
printer.PrintTree(this);
return printer.PrettyPrintedOutputString();
}
void DoMain()
{
try {
NadirHelper.InitializeHelper();
ParseProgramArguments(args);
ProcessProgramArguments();
//
bool anyErrors = false;
switch (action)
{
case ACTION.None:
Usage();
break;
case ACTION.Test:
{
switch (this.test)
{
case 1: ThermodynamicsData.TestNearestNeighborCalculations(); break;
case 2: Verifier.TestRegEx(); break;
}
}
break;
case ACTION.Felony:
ProcessFelony();
break;
case ACTION.Parse:
{
// Do the heavy lifting of parsing the files that have been specified
//
NadirContext context = ParseInputs();
//
// Set up for debugging if we need to
//
TreePrinter printer = new TreePrinter();
//
// Run the remaining phases of the parse
//
if (!context.ExceptionOccurred)
{
if (this.FDumpParse) DumpTrees(printer, context);
//
ValidateAST(context); // 2
//
if (!context.ExceptionOccurred)
{
OptimizeAST(context); // 3
//
if (!context.ExceptionOccurred) DefineSymbols(context); // 4
if (!context.ExceptionOccurred) AutoDefineVariables(context); // 5
if (!context.ExceptionOccurred) ResolveSymbols(context); // 6
if (!context.ExceptionOccurred) DefineTypes(context); // 7
if (!context.ExceptionOccurred) ResolveTypes(context); // 8
//
if (!context.ExceptionOccurred && this.FDumpTrees) DumpTrees(printer, context);
}
}
//
this.resultToOutput = null;
SequenceDesigner designer = null;
try {
// Run distillation and sequence design. Only worth designing
// if something has been distilled.
//
if (!context.ExceptionOccurred && context.ParseResults.Count > 0)
{
this.parseResult = context.ParseResults[0].Tree;
this.resultToOutput = this.parseResult;
//
if (!this.fNoDistill)
{
// If we are to distill, but he hasn't given us a name, then
// distill the first distillable thing in the file.
if (null == this.globalToDistill)
{
foreach (NadirAST global in ((NadirAST)parseResult).NadirChildren)
{
if (global.Symbol.IsDistillable)
{
this.globalToDistill = global.Symbol.Name;
break;
}
}
}
// If there's something to distill, then distill it!
if (this.globalToDistill != null)
{
this.distillationResult = Distill(context, this.globalToDistill);
this.resultToOutput = this.distillationResult;
//
// Design the result if we're asked
//
if (!this.fNoDesign && !context.ExceptionOccurred)
{
if (this.globalToDesign != null)
{
designer = Design(context, this.distillationResult, this, true);
}
}
}
}
}
//
// Emit the output
//
if (!context.ExceptionOccurred)
{
PrintFinalOutput(designer, context);
}
anyErrors = anyErrors || context.ExceptionOccurred;
}
finally
{
designer?.Dispose();
}
break;
}
// end switch
}
//
NadirHelper.TerminateHelper();
Environment.Exit(anyErrors ? -1 : 0);
}
catch (Exception e)
{
MiscUtil.DisplayException(new WrappedException(e));
}
}
protected override void ExecuteCmd(List <string> args)
{
if (!File.Exists(args[0]))
{
BetterConsole.WriteOnNextLine($"Grammar file does not exist.", ConsoleColor.Red);
return;
}
if (!Directory.Exists(args[1]))
{
BetterConsole.WriteOnNextLine($"Output directory does not exist.", ConsoleColor.Red);
return;
}
InterpreterCodeGenerator.LanguageName = args[2];
var results = DescriptionLanguageInterpreter.Execute(File.ReadAllText(args[0]));
if (results.Item2.Count > 0)
{
BetterConsole.WriteOnNextLine($"Failure to load language: {string.Join("\n\n", results.Item2.Select(y => TreePrinter.ToString(y, z => z.SubErrors)))}", ConsoleColor.Red);
}
var fileContents = results.Item1.Cast <string>().ToArray();
File.WriteAllText(Path.Combine(args[1], $"{args[2]}Interpreter_NoEdit.cs"), fileContents[0]);
File.WriteAllText(Path.Combine(args[1], $"{args[2]}Interpreter_Edit.cs"), fileContents[1]);
File.WriteAllText(Path.Combine(args[1], "InterpreterSupport_NoEdit.cs"), fileContents[2]);
}
public static void Main(string[] args)
{
Console.Clear();
while (true) //handle switching prompts
{
Prompt(Constants.ReplPromptName, x => { REPLCommandInterpreter.Execute(x); }, _cmdBuffer);
Prompt(LanguageName, x => {
if (_languageInterp != null)
{
var results = _languageInterp(x);
if (results.Item1.Count > 0)
{
BetterConsole.WriteOnNextLine($"Result: ({string.Join(", ", results.Item1)})", ConsoleColor.Green);
}
if (results.Item2.Count > 0)
{
BetterConsole.WriteOnNextLine($"Errors: \n{string.Join("\n\n", results.Item2.Select(y => TreePrinter.ToString(y, z => z.SubErrors)))}", ConsoleColor.Red);
}
}
else
{
BetterConsole.WriteOnNextLine("Language not loaded. Use REPL Command {Language} to load a language assembly.");
}
}, _langBuffer);
}
}
protected override void ExecuteCmd(List <string> args)
{
if (_languagedLoaded)
{
BetterConsole.WriteOnNextLine("Language already loaded, unloading languages is not currently supported.");
return;
}
if (!File.Exists(args[0]))
{
BetterConsole.WriteOnNextLine($"No file named {args[0]}");
return;
}
try {
var assem = Assembly.LoadFile(args[0]);
var handlers = assem.GetTypes().Where(x => x.GetInterfaces().Contains(typeof(ISymbolHandler))).Select(x => (ISymbolHandler)Activator.CreateInstance(x)).ToArray();
var languageInfo = (ILanguageInfo)Activator.CreateInstance(assem.GetTypes().First(x => x.GetInterfaces().Contains(typeof(ILanguageInfo))));
Program.LanguageName = languageInfo.Name;
var results = LoadLanguageInterpreter.MakeTemporaryParser(languageInfo.Grammar);
if (results.Item2.Count > 0)
{
BetterConsole.WriteOnNextLine($"Failure to load language: {string.Join("\n\n", results.Item2.Select(y => TreePrinter.ToString(y, z => z.SubErrors)))}", ConsoleColor.Red);
return;
}
Program._languageInterp = code => results.Item1(code, handlers);
_languagedLoaded = true;
BetterConsole.WriteOnNextLine($"{languageInfo.Name} loaded.");
} catch (Exception ex) {
BetterConsole.WriteOnNextLine($"{args[0]} is not a path to a valid language assembly.");
}
}
/// <summary>
/// Performs the compilation process
/// </summary>
public void Compile()
{
// Tokenize
Write("Tokenising...");
List <Token> tokens = Tokenizer.GetAllTokens();
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
//WriteLine(string.Join("\n", tokens));
//Parse
Write("Parsing...");
//Parser.Parse(tokens);
ProgramNode tree = Parser.Parse(tokens);
if (Reporter.HasErrors)
{
WriteLine("ERRORS");
return;
}
WriteLine("Done");
//WriteLine(TreePrinter.ToString(tree));
Write("Identifying...");
Identifier.PerformIdentification(tree);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
//WriteLine(TreePrinter.ToString(tree));
//Type checking
Write("Type Checking...");
Checker.PerformTypeChecking(tree);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
WriteLine(TreePrinter.ToString(tree));
// Code generation
Write("Generating code...");
TargetCode targetCode = Generator.GenerateCodeFor(tree);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
// Output
Write("Writing to file...");
Writer.WriteToFiles(targetCode);
if (Reporter.HasErrors)
{
return;
}
WriteLine("Done");
}
//-----------------------------------------------------
void DumpTrees(TreePrinter printer, NadirContext context)
{
MiscUtil.TraceLine("-------------------------", this.FTracingToDebug);
foreach (ParseResult parseResult in context.ParseResults)
{
printer.DumpTree(parseResult.Tree, this.FTracingToDebug);
}
}
