public void LongRelativeJump()
{
using var assembler = new Assembler.Assembler();
const int expectedResult = 42069;
string[] customFunction = new string[]
{
$"{_use32}",
$"mov {_eax}, {expectedResult}",
$"ret"
};
// Make target and source.
var target = _highMemoryAllocator.Write(assembler.Assemble(customFunction));
var src = _lowAlloc.Allocate(100); // for our jump instruction
// Assert original works.
var tgtMethod = ReloadedHooks.Instance.CreateFunction <GetValueFunction>(target.ToSigned());
Assert.Equal(expectedResult, tgtMethod.GetWrapper()());
CurrentProcess.WriteRaw(src, Utilities.AssembleRelativeJump(src, target, Environment.Is64BitProcess));
// Call the code.
var srcMethod = ReloadedHooks.Instance.CreateFunction <GetValueFunction>(src.ToSigned());
Assert.Equal(expectedResult, srcMethod.GetWrapper()());
}
static void Main(string[] args)
{
if (args.Length < 2)
{
Console.WriteLine("Usage: assembler input output");
return;
}
var input = args[0];
var output = args[1];
try
{
var a = new Assembler(File.ReadAllText(input));
File.WriteAllBytes(output, a.Binary);
Console.WriteLine("Assembled to {0} bytes", a.Binary.Length);
}
catch (AssemblerException e)
{
Console.WriteLine("Error: {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
static void TestVideoSave()
{
var assembler = new Assembler.Assembler();
assembler.ReadAssemFile("test_video.asm");
assembler.AssembleCode();
assembler.SaveHexFile("test_video.hex");
}
private static void DisassembleProgram()
{
var assembler = new Assembler.Assembler();
/*
* assembler.ReadHexFile(@"c:\temp\EEPROM2716_8085_computer.txt");
* assembler.DissassembleCode();
* assembler.SaveAssemFile(@"c:\temp\EEPROM_8085_computer.asm");
*/
assembler.ReadHexFile(@"c:\temp\hello_world.hex");
assembler.DissassembleCode();
assembler.SaveAssemFile(@"c:\temp\hello_world.asm");
}
public Form1()
{
InitializeComponent();
assembler = new Assembler();
assembler.FireAssemblyComplete += OnAssemblyComplete;
assembler.FireError += OnError;
assembler.FireStatusUpdate += OnStatusUpdate;
writer = new HexInstWriter();
writer.FireWriteComplete += OnWriteComplete;
hexPreviewBox.AddPeer(asmPreviewBox);
asmPreviewBox.AddPeer(hexPreviewBox);
}
static void SpaceInvaders()
{
//http://www.computerarcheology.com/Arcade/SpaceInvaders/RAMUse.html
//The raster resolution is 256x224 at 60Hz.The monitor is rotated in the cabinet 90 degrees counter-clockwise.
//The screens pixels are on/ off(1 bit each). 256 * 224 / 8 = 7168(7K) bytes
//0000 - 1FFF 8K ROM
//2000 - 23FF 1K RAM
//2400 - 3FFF 7K Video RAM
//4000 - RAM mirror
//https://github.com/begoon/i8080-core
var assembler = new Assembler.Assembler();
assembler.ReadAssemFile("four_k_basic.asm");
assembler.AssembleCode();
assembler.SaveHexFile("four_k_basic_test.hex");
}
static void Main(string[] args)
{
if (args.Length == 2)
{
string inputPath = args[0];
string outputPath = args[1];
// TODO could do with some error handling around this , try catch invalid filepaths etc...
Assembler assembler = new Assembler(inputPath);
string assembledCode = assembler.Assemble();
Program.WriteToFile(outputPath, assembledCode);
Console.WriteLine("Assembly Complete, written to " + Path.GetFullPath(outputPath));
}
else
{
Console.WriteLine("Specify an input .asm file and an output file. See the test files folder for some assembly files...");
}
}
static void Main(string[] args)
{
if (!BitConverter.IsLittleEndian)
{
Console.WriteLine("Big endian CPUs are currently not supported.");
return;
}
if (args.Length < 2)
{
Console.WriteLine("Usage:");
Console.WriteLine(" assembler input.pga output.pge [output.pgd]");
return;
}
var index = 0;
try
{
var input = args[index++];
var output = args[index++];
var debug = args.Length >= 3 ? args[index] : null;
var assembler = new Assembler(File.ReadAllText(input));
assembler.Assemble();
File.WriteAllBytes(output, assembler.Binary);
if (debug != null)
{
assembler.Debug.Save(debug);
}
Console.WriteLine("Assembled to {0} words", assembler.Binary.Length / 2);
}
catch (AssemblerException e)
{
Console.WriteLine("Error: {0}", e.Message);
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
static void Main(string[] args)
{
var basePath = Directory.GetCurrentDirectory();
Console.Write("Enter file to compile: ");
var fileName = Console.ReadLine();
if (fileName.EndsWith(".s")) fileName = fileName.Substring(0, fileName.Length - 2);
try
{
var inputPath = String.Format("{0}\\{1}.s", basePath, fileName);
var lines = File.ReadAllLines(inputPath);
Console.WriteLine("Assembly file read from {0}", inputPath);
var assembler = new Assembler(lines);
var mif = assembler.GetMachineCode();
if (assembler.Success)
{
var outputPath = String.Format("{0}\\{1}.mif", basePath, fileName);
File.WriteAllLines(outputPath, mif);
Console.WriteLine("MIF file saved to {0}", outputPath);
}
else
{
Console.WriteLine("Due to errors, the program was not assembled");
}
}
catch (Exception e)
{
Console.WriteLine("Sorry, it looks like there was an error. {0}", e.Message);
}
Console.WriteLine("Press any key to exit...");
Console.Read();
}
static void RunDiagnosticProgram()
{
var assembler = new Assembler.Assembler();
assembler.ReadAssemFile("cpudiag.asm");
assembler.AssembleCode();
assembler.SaveHumanReadableHexFile("cpudiag.hex");
assembler.SaveHexFile("cpudiag_raw.hex");
/*
*
* //computer.ComputerMemory.LoadMachineCodeFromFile("loop.hex");
* // computer.ComputerMemory.LoadMachineCodeFromFile("basic.hex");
*
*
*/
var computer = new Computer();
computer.Reset();
computer.ComputerMemory.LoadMachineCodeDirect(assembler.HexResult);
//computer.ComputerMemory.Dump();
while (computer.Step())
{
string nextChar = computer.OutputPorts[1].GetNextCharacter();
if (nextChar != "")
{
Console.Write(nextChar);
}
}
Console.ReadKey();
}
static void Main(string[] args)
{
Assembler a = new Assembler();
a.TranslateAssemblyFile(@"Add.asm", @"Add.mc");
}
/// <summary>
/// Gets the binary value of specified number (padded to <see cref="BINARY_ROW_LENGTH"/> length).
/// </summary>
/// <param name="number">The number.</param>
/// <returns>the binary value</returns>
private static string GetBinaryValue(int number)
{
return(Assembler.GetBinaryValue(number, BINARY_ROW_LENGTH));
}
static void Main(string[] args)
{
var ass = new Assembler();
ass.Assemble(File.ReadAllText(args[0]), "test.pc");
}
static void Main(string[] args)
{
Assembler a = new Assembler();
a.TranslateAssemblyFile(@"SquareMacro.asm", @"SquareMacro.hack");
}
