protected override void Parse(AsmParser parser)
{
do {
var dest = parser.ReadReg32();
Registers.Add(dest);
} while (!parser.IsEndOfLine);
}
public static void Main(string[] args)
{
string code = File.ReadAllText("/Volumes/exFat/Vectrex/hello2.asm");
AntlrInputStream stream = new AntlrInputStream(code);
AsmLexer lexer = new AsmLexer(stream);
//lexer.AddErrorListener(new LexerErrorListener());
CommonTokenStream tokens = new CommonTokenStream(lexer);
AsmParser parser = new AsmParser(tokens);
//parser.AddErrorListener(new ParserErrorListener());
AsmParser.ProgContext tree;
tree = parser.prog();
AsmVisitor visitor = new AsmVisitor();
visitor.Visit(tree);
foreach (byte b in visitor.m_objectCode)
{
Console.Write("{0:X2} ", b);
}
File.WriteAllBytes("/Volumes/exFat/Vectrex/hello2.bin", visitor.m_objectCode.ToArray());
}
public override void Compile(AsmParser parser, AsmSection output)
{
var translation = new OpcodeTranslation { Opcode = _opcodeTemplate };
var dest = parser.ReadDesRound();
translation.DesRound = dest;
output.EmitCode(translation.Opcode);
}
public override void Compile(AsmParser parser, AsmSection output)
{
var zToken = parser.ReadToken(TokenType.Literal);
if (zToken.StringValue.ToLower() != "z") throw new TokenException("Z register expected", zToken);
parser.ReadToken(TokenType.Comma);
var dest = parser.ReadReg32();
var translation = new OpcodeTranslation { Opcode = _opcodeTemplate, Destination32 = dest };
output.EmitCode(translation.Opcode);
}
protected override void Parse(AsmParser parser)
{
var dest = parser.ReadPort32();
parser.ReadToken(TokenType.Comma);
var value = parser.ReadBit();
Port = dest;
Bit = value;
}
public override void Compile(AsmParser parser, AsmSection output)
{
var translation = new OpcodeTranslation { Opcode = _opcodeTemplate };
var dest = parser.ReadReg8();
translation.Destination8 = dest;
parser.ReadToken(TokenType.Comma);
var reg = parser.ReadReg8();
translation.Register8 = reg;
output.EmitCode(translation.Opcode);
}
protected override void Parse(AsmParser parser)
{
if (parser.IsEndOfLine) {
PostIncrement = false;
} else {
var zReg = parser.ReadToken(TokenType.Literal);
if (zReg.StringValue.ToLower() != "z") throw new TokenException("Z+ expected", zReg);
parser.ReadToken(TokenType.Plus);
PostIncrement = true;
}
}
protected override void Parse(AsmParser parser)
{
Register = parser.ReadRegW24();
parser.ReadToken(TokenType.Comma);
Token exprToken;
var imm = parser.CalculateExpression(out exprToken);
if (imm > 63) {
throw new TokenException("value must be less than 64", exprToken);
}
Value = (byte)imm;
}
public void Run(AntlrInputStream inputStream, Stream w)
{
var lexer = new AsmLexer(inputStream);
var commonTokenStream = new CommonTokenStream(lexer);
var parser = new AsmParser(commonTokenStream);
var context = parser.prog();
ParseTreeWalker walker = new ParseTreeWalker();
AsmListener listener = new AsmListener(parser, w);
walker.Walk(listener, context);
}
public override void Compile(AsmParser parser, AsmSection output)
{
var dest = parser.ReadReg16();
parser.ReadToken(TokenType.Comma);
var value = parser.ReadByte();
var translation = new OpcodeTranslation {
Opcode = _opcodeTemplate,
Destination16 = dest,
Imm8 = (byte)(255 - value)
};
output.EmitCode(translation.Opcode);
}
public override void Compile(AsmParser parser, AsmSection output)
{
var dest = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
var operand = parser.ReadIndirectWithDisplacement();
var translation = new OpcodeTranslation {
Opcode = GetOpcodeTemplate(operand.Register),
Destination32 = dest,
Displacement = operand.Displacement
};
output.EmitCode(translation.Opcode);
}
static void Main(string[] args)
{
var input = new AntlrFileStream("Modl.Vm\\test.modl");
var lexer = new AsmLexer(input);
var tokens = new CommonTokenStream(lexer);
var parser = new AsmParser(tokens);
var tree = parser.program();
var visit = new AsmAstBuilder();
visit.VisitProgram(tree);
var vm = new VirtualMachine(visit.Program, visit.Functions);
vm.Execute(true);
}
protected override void Parse(AsmParser parser)
{
Token firstToken;
var offset = parser.CalculateExpression(out firstToken);
var zeroOffset = parser.CurrentOffset + 2;
var delta = offset - zeroOffset;
if ((delta & 0x1) > 0) {
throw new TokenException("invalid relative jump", firstToken);
}
delta /= 2;
if (delta < -2048 || delta > 2047) {
throw new TokenException("relative jump out of range (-2047; 2048)", firstToken);
}
delta *= 2;
Delta = (short)delta;
}
protected override void Parse(AsmParser parser)
{
Token firstToken;
var target = parser.CalculateExpression(out firstToken);
if ((target & 0x1) > 0) {
throw new TokenException("invalid absolute jump", firstToken);
}
target /= 2;
//todo: for 64k devices limit is 64k
if (target < 0 || target >= (1 << 22)) {
throw new TokenException("jump beyond 4m boundary", firstToken);
}
Target = (int)(target << 1);
}
protected override void Parse(AsmParser parser)
{
if (parser.IsEndOfLine) {
Destination = 0;
Increment = false;
NoArgs = true;
return;
}
NoArgs = false;
Destination = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
var zReg = parser.ReadToken(TokenType.Literal);
if (zReg.StringValue.ToLower() != "z") throw new TokenException("Z register expected", zReg);
Increment = false;
if (!parser.IsEndOfLine) {
parser.ReadToken(TokenType.Plus);
Increment = true;
}
}
public override void Compile(AsmParser parser, AsmSection output)
{
if (parser.IsEndOfLine) {
output.EmitCode(_opcodeTemplate);
return;
}
var dest = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
var zReg = parser.ReadToken(TokenType.Literal);
if (zReg.StringValue.ToLower() != "z") throw new TokenException("Z register expected", zReg);
var increment = false;
if (!parser.IsEndOfLine) {
parser.ReadToken(TokenType.Plus);
increment = true;
}
var translation = new OpcodeTranslation { Opcode = 0x9006, Destination32 = dest, Increment = increment };
output.EmitCode(translation.Opcode);
}
protected override void Parse(AsmParser parser)
{
Bit = parser.ReadBit();
parser.ReadToken(TokenType.Comma);
ParseOffset(parser);
}
protected override void Parse(AsmParser parser)
{
Address = parser.ReadUshort();
parser.ReadToken(TokenType.Comma);
Source = parser.ReadReg32();
}
protected override void Parse(AsmParser parser)
{
Register = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
Bit = parser.ReadBit();
}
protected override void Parse(AsmParser parser)
{
Destination = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
Operand = parser.ReadIndirectOperand();
}
static void Main(string[] args)
{
AsmParser parser = new AsmParser();
parser.Parse(@"C:\Users\OptaneTester\Documents\Visual Studio 2017\Projects\s\asm_gen\asm_gen\ReadMe.txt");
}
protected override void Parse(AsmParser parser)
{
Destination = parser.ReadReg32();
parser.ReadToken(TokenType.Comma);
Address = parser.ReadUshort();
}
protected override void Parse(AsmParser parser)
{
Register = parser.ReadReg16();
parser.ReadToken(TokenType.Comma);
Value = parser.ReadByte();
}
protected override void Parse(AsmParser parser)
{
}
protected virtual void Parse(AsmParser parser)
{
}
public AsmListener(AsmParser parser, Stream w)
{
this.parser = parser;
this.w = w;
}
protected override void Parse(AsmParser parser)
{
Register = parser.ReadReg32();
}
protected override void Parse(AsmParser parser)
{
ParseOffset(parser);
}
private static void Main()
{
var path =
Path.Join(GetProgramDirectory(), "code.asm");
var progText = File.ReadAllText(path);
var p = new AsmParser();
/*var sw1 = new Stopwatch();
* var sw2 = new Stopwatch();
* const int iterations = 100_000;
*
* sw1.Start();
*
* for (var i = 0; i < iterations; i++)
* {
* p.Parse(progText);
* }
*
* sw1.Stop();
*
* sw2.Start();
*
* for (var i = 0; i < iterations; i++)
* {
* }
*
* sw2.Stop();
*
* Console.WriteLine("Elapsed 1 = {0}, {1} per iteration",
* sw1.Elapsed,
* sw1.Elapsed / iterations);
* Console.WriteLine("Elapsed 2 = {0}, {1} per iteration",
* sw2.Elapsed,
* sw2.Elapsed / iterations);
* return;*/
var vm = new VirtualMachine();
/*Breakpoint.BreakpointAction regBp = delegate (int aX)
* {
* Debug.WriteLine($"Register breakpoint = {aX}");
* return false;
* };
*
* // Trigger breakpoint when the value 0x123 is written to R1.
* vm.Debugger.AddBreakpoint(0x123,
* BreakpointType.RegisterWrite,
* regBp,
* Registers.R1);
*
* Breakpoint.BreakpointAction memBP = delegate (int aX)
* {
* Debug.WriteLine($"Memory position {aX} was written too!");
* return false;
* };
*
* // Trigger breakpoint upon write to memory address 0x1.
* vm.Debugger.AddBreakpoint(0,
* BreakpointType.MemoryWrite,
* memBP);*/
// Enable CPU debug logging.
vm.Cpu.SetLoggingEnabled(true);
var sectionData = p.Parse(progText);
var compiler = new Compiler(sectionData, null, true);
var bin = new BinFile(compiler.Compile());
//File.Delete(@"D:\test.bin");
//File.WriteAllBytes(@"D:\test.bin", bin.Raw);
//var programBytes =
// QuickCompile.RawCompile(sectionData, true);
//var programBytes = QuickCompile.RawCompile(program, true);
//File.WriteAllBytes(@"D:\Downloads\test.bin", programBytes);
vm.Run(bin);
Console.WriteLine("-------------[Registers]------------");
vm.Cpu.Registers.PrintRegisters();
Console.WriteLine("---------------[Stack]--------------");
vm.Memory.PrintStack();
/*Console.WriteLine("----------[Memory Regions]----------");
* var regionLines =
* vm.Memory.GetFormattedMemoryRegions();
* foreach (var l in regionLines)
* {
* Console.WriteLine(l);
* }*/
Console.WriteLine("------------[Raw Memory]------------");
var mem = vm.Memory.DirectGetMemoryRaw(0, 0x20);
foreach (var m in mem)
{
Console.Write(m.ToString("X2") + " ");
}
Console.WriteLine();
Console.WriteLine("------------[Disassembly]-----------");
vm.Disassembler.DisplayDisassembly(true, false, true);
Console.ReadLine();
}
protected override void Parse(AsmParser parser)
{
Bit = parser.ReadBit();
}
protected override void Parse(AsmParser parser)
{
Port = parser.ReadPort64();
parser.ReadToken(TokenType.Comma);
Register = parser.ReadReg32();
}
public override void Compile(AsmParser parser, AsmSection output)
{
throw new NotImplementedException();
}
public virtual void Compile(AsmParser parser, AsmSection output)
{
Parse(parser);
Compile(output);
}
protected override void Parse(AsmParser parser)
{
Destination = parser.ReadReg16();
parser.ReadToken(TokenType.Comma);
Register = parser.ReadReg16();
}
protected override void Parse(AsmParser parser)
{
Operand = parser.ReadIndirectOperand();
parser.ReadToken(TokenType.Comma);
Source = parser.ReadReg32();
}
