void FirmwareFromCS()
{
var csFiles = Directory.EnumerateFiles(SourceFolder);
var csFilesContent = csFiles
.Select(path => new FSTextFile()
{
Name = path, Content = File.ReadAllText(path)
})
.ToList();
if (csFilesContent.Any())
{
foreach (var cs in csFilesContent)
{
Console.WriteLine($"Found CS source: {cs.Name}");
}
// translate source files
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.AddRange(csFilesContent);
tx.Run(source);
var firmwareSource = tx.Result;
// create soc resource records
var socGenerator = new SOCGenerator();
var socRecordsBuilder = new SOCRecordsBuilder();
var socRecords = socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources);
firmwareSource.Add(socGenerator.SOCImport(socRecords));
FileTools.CreateDirectoryRecursive(FirmwareFolder);
var m = new FSManager(FirmwareFolder);
m.SaveSnapshot(firmwareSource);
}
ModifyMakefile();
if (File.Exists(MakefileFile))
{
if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
{
var context = RISCVIntegration
.DefaultContext(FirmwareFolder)
.WithMakeTarget("bin");
RISCVIntegrationClient.Make(context).Wait();
}
else
{
using (new CurrentDirectory(FirmwareFolder))
{
Toolchain.Make("bin");
}
}
}
else
{
Console.WriteLine($"Makefile was not found: {MakefileFile}");
}
}
public static void SaveHardwareSource(FSSnapshot snapshot)
{
Clean(TestPath.HardwareSourceFolder);
var m = new FSManager(TestPath.HardwareSourceFolder);
m.SaveSnapshot(snapshot);
}
public FSSnapshot LoadSnapshot(
ExtensionClasses classes,
IEnumerable <string> files)
{
var fs = new FSSnapshot();
foreach (var file in files.Where(file => File.Exists(Path.Combine(_rootPath, file))))
{
var cls = classes.GetClass(Path.GetExtension(file));
var fileName = Path.IsPathRooted(file) ? file.Substring(_rootPath.Length) : file;
switch (cls)
{
case eExtensionClass.Text:
fs.Files.Add(new FSTextFile()
{
Name = fileName,
Content = File.ReadAllText(Path.Combine(_rootPath, file))
});
break;
case eExtensionClass.Binary:
fs.Files.Add(new FSBinaryFile()
{
Name = fileName,
Content = File.ReadAllBytes(Path.Combine(_rootPath, file))
});
break;
}
}
return(fs);
}
public static void SaveFirmwareOutput(FSSnapshot snapshot)
{
Clean(TestPath.FirmwareOutputFolder);
var m = new FSManager(TestPath.FirmwareOutputFolder);
m.SaveSnapshot(snapshot);
}
public async Task MakeTest()
{
// translate source files
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.Add(LoadSource("SOCBlinker.cs"));
tx.Run(source);
var firmwareSource = tx.Result;
// create soc resource records
var socGenerator = new SOCGenerator();
var socRecordsBuilder = new SOCRecordsBuilder();
var socRecords = socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources);
firmwareSource.Add(socGenerator.SOCImport(socRecords));
IntermediateData.SaveToMake(firmwareSource);
// run makefile
var context = RISCVIntegration
.DefaultContext(TestPath.MakeFolder)
.WithMakeTarget("bin");
await RISCVIntegrationClient.Make(context);
}
public RISCVIntegrationContext WithResultSnapshot(FSSnapshot snapshot)
{
var result = Clone();
result.ResultSnapshot = snapshot;
return(result);
}
public void SaveSnapshot(FSSnapshot fsSnashot)
{
foreach (var file in fsSnashot.Files)
{
var fullPath = Path.Combine(_rootPath, file.Name);
RecursiveCreateDirectory(Path.GetDirectoryName(fullPath));
switch (file)
{
case FSTextFile tf:
var localContent = string.Join(Environment.NewLine, tf.Content.Split("\n").Select(l => l.TrimEnd('\r')));
File.WriteAllText(fullPath, localContent);
break;
case FSBinaryFile bf:
File.WriteAllBytes(fullPath, bf.Content);
break;
}
}
}
public void Run(FSSnapshot source)
{
// create syntax tree
var trees = source
.Files
.OfType <FSTextFile>()
.Where(f => f.Name.EndsWith(".cs"))
.ToDictionary(f => f.Name, f => CSharpSyntaxTree.ParseText(f.Content));
// compile into assembly and load into library
var builder = new AssemblyBuilder();
var library = builder.Build(trees.Values);
// translate each source file
foreach (var tree in trees)
{
var fileName = Path.GetFileNameWithoutExtension(tree.Key);
var context = new TranslationContext()
{
Library = library,
Root = tree.Value,
FileName = fileName,
};
var content = new SourceFileVisitor().Translate(context, tree.Value);
Result.Files.Add(new FSTextFile()
{
Name = $"{fileName}.h", Content = content["h"]
});
Result.Files.Add(new FSTextFile()
{
Name = $"{fileName}.cpp", Content = content["cpp"]
});
SOCResources.AddRange(context.SOCResources);
}
}
public void SaveSnapshot()
{
using (var tc = new Toolchain(Guid.NewGuid()))
{
var fs = new FSSnapshot();
fs.Files.Add(new FSTextFile()
{
Name = "1.txt",
Content = "abc"
});
fs.Files.Add(new FSBinaryFile()
{
Name = "1.bin",
Content = new byte[] { 128 }
});
tc.SaveSnapshot(fs);
Assert.AreEqual("abc", File.ReadAllText(Path.Combine(tc.RootPath, "1.txt")));
Assert.AreEqual(128, File.ReadAllBytes(Path.Combine(tc.RootPath, "1.bin"))[0]);
}
}
public void ExecuteCommandTest_Success()
{
using (var tc = new Toolchain(Guid.NewGuid()))
{
var fs = new FSSnapshot();
fs.Files.Add(new FSTextFile()
{
Name = "1.cmd",
Content = "copy 1.txt 2.txt"
});
fs.Files.Add(new FSTextFile()
{
Name = "1.txt",
Content = "content"
});
tc.SaveSnapshot(fs);
tc.SetupRules(new[] { new ModifiedFilesRule() });
tc.Invoke(new[]
{
new CommandLineInfo()
{
FileName = "cmd.exe",
Arguments = "/c 1.cmd"
}
});
var result = tc.LoadSnapshot(new ExtensionClasses().Text("txt"));
Assert.AreEqual(1, result.Files.Count);
var file = (FSTextFile)result.Files[0];
Assert.AreEqual("2.txt", file.Name);
Assert.AreEqual("content", file.Content);
}
}
public bool FirmwareFromAppFolder()
{
if (!SourceExists)
{
return(false);
}
// delete old firmware before making new one
if (File.Exists(FirmwareFile))
{
File.Delete(FirmwareFile);
}
var appName = Path.GetFileName(appPath);
var sourceFolder = Path.Combine(appPath, "source");
var firmwareFolder = Path.Combine(appPath, "firmware");
var csFiles = Directory.EnumerateFiles(sourceFolder);
var csFilesContent = csFiles
.Select(path => new FSTextFile()
{
Name = path, Content = File.ReadAllText(path)
})
.ToList();
if (csFilesContent.Any())
{
foreach (var cs in csFilesContent)
{
Console.WriteLine($"Found CS source: {cs.Name}");
}
// translate source files
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.AddRange(csFilesContent);
tx.Run(source);
var firmwareSource = tx.Result;
// create soc resource records
var socGenerator = new SOCGenerator();
var socRecordsBuilder = new SOCRecordsBuilder();
var socRecords = socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources);
firmwareSource.Add(socGenerator.SOCImport(socRecords));
FileTools.CreateDirectoryRecursive(firmwareFolder);
var m = new FSManager(firmwareFolder);
m.SaveSnapshot(firmwareSource);
}
ModifyMakefile();
if (File.Exists(MakefileFile))
{
var context = RISCVIntegration
.DefaultContext(firmwareFolder)
.WithMakeTarget("bin");
RISCVIntegrationClient.Make(context).Wait();
}
if (File.Exists(FirmwareFile))
{
var disassembler = new Disassembler();
File.WriteAllText(FirmwareAsmFile, disassembler.Disassemble(Instructions()));
}
return(File.Exists(FirmwareFile));
}
async Task TranslateSourceFiles(
IEnumerable <FSTextFile> files,
Action entryPoint
)
{
var textReplacer = new TextReplacer();
var generator = new IntegrationGenerator();
var firmwareTemplates = IntegrationTemplatesLoader.FirmwareTemplates;
var hardwareTemplates = IntegrationTemplatesLoader.HardwareTemplates;
var tx = new CSharp2CPPTranslator();
var source = new FSSnapshot();
source.Files.AddRange(files);
tx.Run(source);
var firmwareSource = tx.Result;
var socGenerator = new SOCGenerator();
var socRecords = new List <SOCRecord>();
var socRecordsBuilder = new SOCRecordsBuilder();
// default code block
socRecords.Add(new SOCRecord()
{
DataType = typeof(uint),
SegmentBits = 12,
HardwareName = "firmware",
SoftwareName = "firmware",
Segment = 0,
Depth = 512,
Template = "memory32"
});
socRecords.AddRange(socRecordsBuilder.ToSOCRecords(0x800, tx.SOCResources));
firmwareSource.Add(socGenerator.SOCImport(socRecords));
var generatedSourceFiles = firmwareSource.Files.Where(f => Path.GetExtension(f.Name).ToLower() == ".cpp").ToList();
var generatedHeaderFiles = firmwareSource.Files.Where(f => Path.GetExtension(f.Name).ToLower() == ".h").ToList();
firmwareSource.Merge(firmwareTemplates, f => !f.Name.Contains("template"));
var firmwareTemplate = firmwareTemplates.Get <FSTextFile>("firmware.template.cpp");
var firmwareMap = new Dictionary <string, string>()
{
{ "FIRMWARE_INCLUDES", string.Join(Environment.NewLine, generatedHeaderFiles.Select(f => $"#include \"{f.Name}\"")) },
{ "FIRMWARE_CODE", $"{entryPoint.Method.DeclaringType.Namespace}::{entryPoint.Method.DeclaringType.Name}::{entryPoint.Method.Name}();" },
};
firmwareSource.Add("firmware.cpp", textReplacer.ReplaceToken(firmwareTemplate.Content, firmwareMap));
var makefileTemplate = firmwareTemplates.Get <FSTextFile>("Makefile.template");
var makefileMap = new Dictionary <string, string>()
{
{ "SOURCES_LIST", string.Join(" ", generatedSourceFiles.Select(f => f.Name)) }
};
firmwareSource.Add("Makefile", textReplacer.ReplaceToken(makefileTemplate.Content, makefileMap));
IntermediateData.SaveFirmwareSource(firmwareSource);
var firmwareOutput = await CompileFromIntermediate();
IntermediateData.SaveFirmwareOutput(firmwareOutput);
// generat verilog
var hardwareTemplate = hardwareTemplates.Get <FSTextFile>("hardware.template.v").Content;
var replacers = new Dictionary <string, string>();
// memory init file
replacers["MEM_INIT"] = "";
foreach (var dma in socRecords)
{
var binFile = firmwareOutput.Get <FSBinaryFile>($"{dma.HardwareName}.bin");
if (binFile != null)
{
var words = TestTools.ReadWords(binFile.Content).ToList();
var memInit = generator.MemInit(words, dma.HardwareName, (int)dma.Depth, SizeOfType(dma.DataType));
replacers["MEM_INIT"] += memInit;
}
else
{
var memInit = generator.MemInit(Enumerable.Range(0, (int)dma.Depth).Select(idx => 0UL).ToList(), dma.HardwareName, (int)dma.Depth, SizeOfType(dma.DataType));
replacers["MEM_INIT"] += memInit;
}
}
// data declarations
replacers["DATA_DECL"] = generator.DataDeclaration(socRecords);
// data control signals
var templates = new IntegrationTemplates();
foreach (var t in hardwareTemplates.Files.OfType <FSTextFile>())
{
templates.Templates[t.Name] = t.Content;
}
replacers["DATA_CTRL"] = generator.DataControl(socRecords, templates);
replacers["MEM_READY"] = generator.MemReady(socRecords);
replacers["MEM_RDATA"] = generator.MemRData(socRecords);
hardwareTemplate = textReplacer.ReplaceToken(hardwareTemplate, replacers);
var hardwareSource = new FSSnapshot();
hardwareSource.Add("hardware.v", hardwareTemplate);
IntermediateData.SaveHardwareSource(hardwareSource);
}
public static void SaveToMake(FSSnapshot snapshot)
{
var m = new FSManager(TestPath.MakeFolder);
m.SaveSnapshot(snapshot);
}
public void SaveSnapshot(FSSnapshot fsSnashot)
{
new FSManager(RootPath).SaveSnapshot(fsSnashot);
}
