BugFixes

GerardSmit · GerardSmit · commit c9025cdf1775 · 2023-10-28T16:07:06.000+02:00
diff --git a/src/Yabal.Compiler/InstructionBuildResult.cs b/src/Yabal.Compiler/InstructionBuildResult.cs
@@ -114,7 +114,7 @@ public string ToAssembly(bool addComments = false)
 
     public int[] ToArray()
     {
-        var array = new int[_length];
+        var array = new int[0xFFFF];
         var i = 0;
 
         foreach (var value in GetBytes())
diff --git a/src/Yabal.Compiler/Yabal/Ast/Statement/ExpressionStatement.cs b/src/Yabal.Compiler/Yabal/Ast/Statement/ExpressionStatement.cs
@@ -9,14 +9,29 @@ public override void Initialize(YabalBuilder builder)
 
     public override void Build(YabalBuilder builder)
     {
-        Expression.BuildExpression(builder, true, null);
+        if (builder.Debug && Expression is CallExpression { Type.StaticType: not (StaticType.Void or StaticType.Unknown) } callExpression)
+        {
+            var temp = builder.GetTemporaryVariable(global: true, size: callExpression.Type.Size);
+
+            callExpression.BuildExpressionToPointer(builder, callExpression.Type, temp);
 
-        if (Expression is AddressExpression address and (IdentifierExpression or MemberExpression))
+            builder.AddVariableDebug(Range, callExpression.Type, temp);
+        }
+        else
         {
-            address.ShowDebug(builder);
+            Expression.BuildExpression(builder, true, null);
+
+            if (Expression is AddressExpression address and (IdentifierExpression or MemberExpression or ArrayAccessExpression))
+            {
+                address.ShowDebug(builder);
+            }
         }
     }
 
+    public bool ShowDebug => Expression is
+        (AddressExpression and (IdentifierExpression or MemberExpression or ArrayAccessExpression)) or
+        (CallExpression { Type.StaticType: not StaticType.Void });
+
     public override Statement CloneStatement()
     {
         return new ExpressionStatement(Range, Expression.CloneExpression());
@@ -26,7 +41,7 @@ public override Statement Optimize()
     {
         return new ExpressionStatement(Range, Expression switch
         {
-            IdentifierExpression or MemberExpression => Expression,
+            IdentifierExpression or MemberExpression or ArrayAccessExpression or CallExpression => Expression,
             _ => Expression.Optimize(null)
         });
     }
diff --git a/src/Yabal.Compiler/Yabal/Ast/Statement/ReturnStatement.cs b/src/Yabal.Compiler/Yabal/Ast/Statement/ReturnStatement.cs
@@ -10,6 +10,11 @@ public override void Initialize(YabalBuilder builder)
     {
         Expression?.Initialize(builder);
         ReturnType = builder.ReturnType;
+
+        if (ReturnType != null && Expression is ITypeExpression typeExpression)
+        {
+            typeExpression.Initialize(builder, ReturnType);
+        }
     }
 
     public override void Build(YabalBuilder builder)
diff --git a/src/Yabal.Compiler/Yabal/Visitor/YabalVisitor.cs b/src/Yabal.Compiler/Yabal/Visitor/YabalVisitor.cs
@@ -736,7 +736,7 @@ public override Node VisitOrElseExpression(YabalParser.OrElseExpressionContext c
 
     public override Node VisitShiftExpression(YabalParser.ShiftExpressionContext context)
     {
-        var @operator = context.ShiftLeft() != null ? BinaryOperator.LeftShift : BinaryOperator.RightShift;
+        var @operator = context.Less()?.Length > 0 ? BinaryOperator.LeftShift : BinaryOperator.RightShift;
         return CreateBinary(context, context.expression(), @operator);
     }
 
diff --git a/src/Yabal.Compiler/Yabal/YabalBuilder.cs b/src/Yabal.Compiler/Yabal/YabalBuilder.cs
@@ -89,6 +89,7 @@ public YabalBuilder(YabalContext context)
         _errors = new Dictionary<SourceRange, List<CompileError>>();
         BinaryOperators = new Dictionary<(BinaryOperator, LanguageType, LanguageType), Function>();
         CastOperators = new Dictionary<(LanguageType, LanguageType), Function>();
+        ArrowFunctions = new List<Function>();
 
         _visitor = new TypeVisitor();
         _globalBlock = new BlockStack { IsGlobal = true };
@@ -120,6 +121,7 @@ public YabalBuilder(YabalBuilder parent)
         _errors = parent._errors;
         BinaryOperators = parent.BinaryOperators;
         CastOperators = parent.CastOperators;
+        ArrowFunctions = parent.ArrowFunctions;
         Options = parent.Options;
 
         Debug = parent.Debug;
@@ -129,9 +131,9 @@ public YabalBuilder(YabalBuilder parent)
 
     public Dictionary<(BinaryOperator, LanguageType, LanguageType), Function> BinaryOperators { get; }
 
-    public Dictionary<(LanguageType, LanguageType), Function> CastOperators { get; } = new();
+    public Dictionary<(LanguageType, LanguageType), Function> CastOperators { get; }
 
-    public List<Function> ArrowFunctions { get; } = new();
+    public List<Function> ArrowFunctions { get; }
 
     public InstructionPointer StackAllocPointer => _stackAllocPointer;
 
@@ -830,7 +832,7 @@ public InstructionBuildResult Build(int offset = 0)
 
         AddHeader(builder);
         builder.AddRange(_builder);
-        builder.Jump(0xFFFF);
+        builder.Jump(0xFFFE);
         AddStrings(builder);
 
         return builder.Build(offset);
diff --git a/src/Yabal.Compiler/Yabal/YabalLexer.g4 b/src/Yabal.Compiler/Yabal/YabalLexer.g4
@@ -29,8 +29,6 @@ Xor                 : '^';
 And                 : '&';
 Mod                 : '%';
 Not                 : '~';
-ShiftLeft           : '<<';
-ShiftRight          : '>>';
 Add				    : '+';
 Sub					: '-';
 Mul					: '*';
diff --git a/src/Yabal.Compiler/Yabal/YabalParser.g4 b/src/Yabal.Compiler/Yabal/YabalParser.g4
@@ -53,7 +53,7 @@ expression
 	| expression DivEqual expression								    # DivEqualExpression
     | expression (Div|Mul|Mod) expression							    # DivMulModBinaryExpression
     | expression (Add|Sub) expression								    # PlusSubBinaryExpression
-	| expression (ShiftLeft|ShiftRight) expression						# ShiftExpression
+	| expression (Less Less|Greater Greater) expression					# ShiftExpression
 	| expression (GreaterEqual|Greater|LessEqual|Less) expression		# ComparisonExpression
 	| expression (Equals|NotEquals) expression						    # EqualExpression
 	| expression And expression									        # AndExpression
diff --git a/src/Yabal.Emulator/Devices/Cpu.cs b/src/Yabal.Emulator/Devices/Cpu.cs
@@ -126,8 +126,9 @@ public void Halt()
                     var index = context.ProgramCounter;
                     context.MemoryIndex = index;
 
-                    if (index >= 0x3FFE)
+                    if (index >= 0xFFFF)
                     {
+                        _handler.Halt();
                         _halt = true;
                         break;
                     }
@@ -236,7 +237,7 @@ public void Load(Stream stream)
     private unsafe ref struct StepContext
     {
         private CpuMemory<THandler> _memory;
-        private Span<int> _memoryPointer;
+        private int* _memoryPointer;
         private readonly CpuMemory<THandler>[] _banks;
         private readonly InstructionReference* _instructionPointer;
 
@@ -262,7 +263,7 @@ public StepContext(
         {
             _banks = banks;
             _memory = banks[context.Bank];
-            _memoryPointer = _memory.Data.AsSpan();
+            _memoryPointer = (int*) Unsafe.AsPointer(ref _memory.Data[0]);
             _instructionPointer = instructionPointer;
             Handler = handler;
             A = context.A;
@@ -283,7 +284,7 @@ public void SetBank(int id)
             {
                 Bank = id;
                 _memory = _banks[id];
-                _memoryPointer = _memory.Data.AsSpan();
+                _memoryPointer = (int*) Unsafe.AsPointer(ref _memory.Data[0]);
             }
         }
 
diff --git a/src/Yabal.Wasm/Interop.cs b/src/Yabal.Wasm/Interop.cs
@@ -55,7 +55,7 @@ public static unsafe void Compile(byte* bytes, int byteLength)
 		}
 		catch (Exception e)
 		{
-			Console.WriteLine("Failed to compile: " + e.Message);
+			Console.WriteLine("Failed to compile: " + e);
 		}
 	}
 
@@ -72,8 +72,9 @@ public static int Step(int amount)
 			cpu.Step(amount);
 			return cpu.ProgramCounter;
 		}
-		catch (Exception)
+		catch (Exception e)
 		{
+			Console.WriteLine("Failed to step: " + e);
 			cpu.Halt();
 			return -1;
 		}
diff --git a/src/Yabal.Wasm/WasmHandler.cs b/src/Yabal.Wasm/WasmHandler.cs
@@ -30,15 +30,15 @@ public override unsafe void FlushScreen()
 
 	public override void Halt()
 	{
-		Interop.Halt();
 		FlushScreen();
+		Interop.Halt();
 	}
 
 	public override unsafe void ShowVariable(int line, int offset, Span<int> value)
 	{
 		fixed (int* screen = value)
 		{
-			Interop.ShowVariable(line, offset, value.Length, (int*)screen);
+			Interop.ShowVariable(line, offset, value.Length, screen);
 		}
 	}
 }
diff --git a/tests/Yabal.Tests/AssemblerTest.cs b/tests/Yabal.Tests/AssemblerTest.cs
@@ -1893,4 +1893,116 @@ STLGE 0 4000
 
         Assert.Equal(1, cpu.Memory[4000]);
     }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task FunctionPointerInFunction(bool optimize)
+    {
+        const string code = """
+            var screen = create_pointer(53870, 1)
+
+            void callback(func<void> cb) {
+                cb()
+            }
+
+            inline int get_color(int r, int g, int b) {
+                return (r / 8 << 10) + (g / 8 << 5) + (b / 8)
+            }
+
+            callback(() => {
+                screen[1] = get_color(255, 0, 0)
+            })
+            """;
+
+        var builder = new YabalBuilder();
+        await builder.CompileCodeAsync(code, optimize);
+
+        var cpu = Create(builder);
+        cpu.Run();
+
+        Assert.Equal(31744, cpu.Banks[1][53871]);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task TickExample(bool optimize)
+    {
+        const string code = """
+            var chars = create_pointer(0xD12A, 1)
+
+            var tick_callbacks = stackalloc func<void>[10]
+            var tick_callback_count = 0
+
+            // Register a callback
+            void register_tick_callback(func<void> callback) {
+                tick_callbacks[tick_callback_count++] = callback
+            }
+
+            // Call all the callbacks
+            void tick() {
+                for (int i = 0; i < tick_callback_count; i++) {
+                    tick_callbacks[i]()
+                }
+            }
+
+            // Register a callback that clears the screen
+            register_tick_callback(() => {
+                for (int i = 0; i < 17 * 17; i++) {
+                    chars[i] = ' '
+                }
+            })
+
+            // Register a callback that draws a 'x' on the screen
+            // and moves it to the right every time it is called
+            var offset = 0
+
+            register_tick_callback(() => {
+                chars[offset++] = 'x'
+            })
+
+            // Tick 3 times
+            tick()
+            tick()
+            tick()
+
+            // The 'x' should be on the 3rd column
+            """;
+
+        var builder = new YabalBuilder();
+        await builder.CompileCodeAsync(code, optimize);
+
+        var cpu = Create(builder);
+        cpu.Run();
+
+        Assert.Equal(36, cpu.Banks[1][53548]);
+    }
+
+    [Theory]
+    [InlineData(true)]
+    [InlineData(false)]
+    public async Task MisMatchBitShift(bool optimize)
+    {
+        const string code = """
+            func<func<void>> get_callback() {
+                return () => {
+                    asm {
+                        LDIA 1
+                        STLGE 0 4000
+                    }
+                }
+            }
+            
+            get_callback()()
+            """;
+
+        var builder = new YabalBuilder();
+        await builder.CompileCodeAsync(code, optimize);
+
+        var cpu = Create(builder);
+        cpu.Run();
+
+        Assert.Equal(1, cpu.Memory[4000]);
+    }
 }

Original file line number	Diff line number	Diff line change
`@@ -114,7 +114,7 @@ public string ToAssembly(bool addComments = false)`
`114`	`114`
`115`	`115`	`public int[] ToArray()`
`116`	`116`	`{`
`117`		`- var array = new int[_length];`
	`117`	`+ var array = new int[0xFFFF];`
`118`	`118`	`var i = 0;`
`119`	`119`
`120`	`120`	`foreach (var value in GetBytes())`
Original file line number	Diff line number	Diff line change
`@@ -9,14 +9,29 @@ public override void Initialize(YabalBuilder builder)`
`9`	`9`
`10`	`10`	`public override void Build(YabalBuilder builder)`
`11`	`11`	`{`
`12`		`- Expression.BuildExpression(builder, true, null);`
	`12`	`+ if (builder.Debug && Expression is CallExpression { Type.StaticType: not (StaticType.Void or StaticType.Unknown) } callExpression)`
	`13`	`+ {`
	`14`	`+ var temp = builder.GetTemporaryVariable(global: true, size: callExpression.Type.Size);`
	`15`	`+`
	`16`	`+ callExpression.BuildExpressionToPointer(builder, callExpression.Type, temp);`
`13`	`17`
`14`		`- if (Expression is AddressExpression address and (IdentifierExpression or MemberExpression))`
	`18`	`+ builder.AddVariableDebug(Range, callExpression.Type, temp);`
	`19`	`+ }`
	`20`	`+ else`
`15`	`21`	`{`
`16`		`- address.ShowDebug(builder);`
	`22`	`+ Expression.BuildExpression(builder, true, null);`
	`23`	`+`
	`24`	`+ if (Expression is AddressExpression address and (IdentifierExpression or MemberExpression or ArrayAccessExpression))`
	`25`	`+ {`
	`26`	`+ address.ShowDebug(builder);`
	`27`	`+ }`
`17`	`28`	`}`
`18`	`29`	`}`
`19`	`30`
	`31`	`+ public bool ShowDebug => Expression is`
	`32`	`+ (AddressExpression and (IdentifierExpression or MemberExpression or ArrayAccessExpression)) or`
	`33`	`+ (CallExpression { Type.StaticType: not StaticType.Void });`
	`34`	`+`
`20`	`35`	`public override Statement CloneStatement()`
`21`	`36`	`{`
`22`	`37`	`return new ExpressionStatement(Range, Expression.CloneExpression());`
`@@ -26,7 +41,7 @@ public override Statement Optimize()`
`26`	`41`	`{`
`27`	`42`	`return new ExpressionStatement(Range, Expression switch`
`28`	`43`	`{`
`29`		`- IdentifierExpression or MemberExpression => Expression,`
	`44`	`+ IdentifierExpression or MemberExpression or ArrayAccessExpression or CallExpression => Expression,`
`30`	`45`	`_ => Expression.Optimize(null)`
`31`	`46`	`});`
`32`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,6 +10,11 @@ public override void Initialize(YabalBuilder builder)`
`10`	`10`	`{`
`11`	`11`	`Expression?.Initialize(builder);`
`12`	`12`	`ReturnType = builder.ReturnType;`
	`13`	`+`
	`14`	`+ if (ReturnType != null && Expression is ITypeExpression typeExpression)`
	`15`	`+ {`
	`16`	`+ typeExpression.Initialize(builder, ReturnType);`
	`17`	`+ }`
`13`	`18`	`}`
`14`	`19`
`15`	`20`	`public override void Build(YabalBuilder builder)`
Original file line number	Diff line number	Diff line change
`@@ -736,7 +736,7 @@ public override Node VisitOrElseExpression(YabalParser.OrElseExpressionContext c`
`736`	`736`
`737`	`737`	`public override Node VisitShiftExpression(YabalParser.ShiftExpressionContext context)`
`738`	`738`	`{`
`739`		`- var @operator = context.ShiftLeft() != null ? BinaryOperator.LeftShift : BinaryOperator.RightShift;`
	`739`	`+ var @operator = context.Less()?.Length > 0 ? BinaryOperator.LeftShift : BinaryOperator.RightShift;`
`740`	`740`	`return CreateBinary(context, context.expression(), @operator);`
`741`	`741`	`}`
`742`	`742`
Original file line number	Diff line number	Diff line change
`@@ -126,8 +126,9 @@ public void Halt()`
`126`	`126`	`var index = context.ProgramCounter;`
`127`	`127`	`context.MemoryIndex = index;`
`128`	`128`
`129`		`- if (index >= 0x3FFE)`
	`129`	`+ if (index >= 0xFFFF)`
`130`	`130`	`{`
	`131`	`+ _handler.Halt();`
`131`	`132`	`_halt = true;`
`132`	`133`	`break;`
`133`	`134`	`}`
`@@ -236,7 +237,7 @@ public void Load(Stream stream)`
`236`	`237`	`private unsafe ref struct StepContext`
`237`	`238`	`{`
`238`	`239`	`private CpuMemory<THandler> _memory;`
`239`		`- private Span<int> _memoryPointer;`
	`240`	`+ private int* _memoryPointer;`
`240`	`241`	`private readonly CpuMemory<THandler>[] _banks;`
`241`	`242`	`private readonly InstructionReference* _instructionPointer;`
`242`	`243`
`@@ -262,7 +263,7 @@ public StepContext(`
`262`	`263`	`{`
`263`	`264`	`_banks = banks;`
`264`	`265`	`_memory = banks[context.Bank];`
`265`		`- _memoryPointer = _memory.Data.AsSpan();`
	`266`	`+ _memoryPointer = (int*) Unsafe.AsPointer(ref _memory.Data[0]);`
`266`	`267`	`_instructionPointer = instructionPointer;`
`267`	`268`	`Handler = handler;`
`268`	`269`	`A = context.A;`
`@@ -283,7 +284,7 @@ public void SetBank(int id)`
`283`	`284`	`{`
`284`	`285`	`Bank = id;`
`285`	`286`	`_memory = _banks[id];`
`286`		`- _memoryPointer = _memory.Data.AsSpan();`
	`287`	`+ _memoryPointer = (int*) Unsafe.AsPointer(ref _memory.Data[0]);`
`287`	`288`	`}`
`288`	`289`	`}`
`289`	`290`
Original file line number	Diff line number	Diff line change
`@@ -55,7 +55,7 @@ public static unsafe void Compile(byte* bytes, int byteLength)`
`55`	`55`	`}`
`56`	`56`	`catch (Exception e)`
`57`	`57`	`{`
`58`		`- Console.WriteLine("Failed to compile: " + e.Message);`
	`58`	`+ Console.WriteLine("Failed to compile: " + e);`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`
`@@ -72,8 +72,9 @@ public static int Step(int amount)`
`72`	`72`	`cpu.Step(amount);`
`73`	`73`	`return cpu.ProgramCounter;`
`74`	`74`	`}`
`75`		`- catch (Exception)`
	`75`	`+ catch (Exception e)`
`76`	`76`	`{`
	`77`	`+ Console.WriteLine("Failed to step: " + e);`
`77`	`78`	`cpu.Halt();`
`78`	`79`	`return -1;`
`79`	`80`	`}`
Original file line number	Diff line number	Diff line change
`@@ -30,15 +30,15 @@ public override unsafe void FlushScreen()`
`30`	`30`
`31`	`31`	`public override void Halt()`
`32`	`32`	`{`
`33`		`- Interop.Halt();`
`34`	`33`	`FlushScreen();`
	`34`	`+ Interop.Halt();`
`35`	`35`	`}`
`36`	`36`
`37`	`37`	`public override unsafe void ShowVariable(int line, int offset, Span<int> value)`
`38`	`38`	`{`
`39`	`39`	`fixed (int* screen = value)`
`40`	`40`	`{`
`41`		`- Interop.ShowVariable(line, offset, value.Length, (int*)screen);`
	`41`	`+ Interop.ShowVariable(line, offset, value.Length, screen);`
`42`	`42`	`}`
`43`	`43`	`}`
`44`	`44`	`}`