sfja.skp/Amogulator
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

sus

Browse Source
This commit is contained in:
Simon 2023-03-14 12:02:39 +01:00
parent e56a2a0e74
commit 181250cd01
4 changed files with 245 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
AmogulatorVM.cs
View File

@ -1,9 +1,22 @@
using CommunityToolkit.Mvvm.ComponentModel;
using Amogulator.Suslang;
using CommunityToolkit.Mvvm.ComponentModel;
using CommunityToolkit.Mvvm.Input;
namespace Amogulator;
public partial class AmogulatorVM : ObservableObject {
[ObservableProperty]
private string output = "test";
private string output = "test", input = "2 + 3";
[RelayCommand]
private void run() {
var ast = new Parser(this.Input, new Lexer(this.Input)).parseExpr();
var compiler = new Compiler();
compiler.compileExpr(ast);
var bytecode = compiler.result();
var vm = new VM(bytecode);
vm.evaluate();
this.Output = ast.astString(0) + "\n\nresult = " + ((IntValue) vm.stack.Peek()).value;
}
}

14
MainWindow.xaml
View File

@ -5,6 +5,7 @@
xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
xmlns:vm="clr-namespace:Amogulator"
mc:Ignorable="d"
Background="Black"
Title="MainWindow" Height="450" Width="800">
<Window.Resources>
<vm:AmogulatorVM x:Key="ViewModel" />
@ -15,7 +16,7 @@
</Grid.ColumnDefinitions>
<Grid.RowDefinitions>
<RowDefinition Height="4*" />
<RowDefinition Height="4*" />
<RowDefinition Height="2*" />
<RowDefinition Height="*" />
</Grid.RowDefinitions>
<Label
@ -24,19 +25,26 @@
Content="{Binding Output}"
Margin="5"
FontSize="16"
FontFamily="Consolas"
FontFamily="Consolas monospace"
Background="Black"
Foreground="White"
ScrollViewer.CanContentScroll="True"
/>
<TextBox
Grid.Column="0"
Grid.Row="1"
Text="{Binding Input}"
Margin="5"
FontSize="16"
FontFamily="Consolas"
FontFamily="Consolas monospace"
Background="Black"
Foreground="White"
/>
<Button
Grid.Column="0"
Grid.Row="2"
Grid.ColumnSpan="1"
Command="{Binding runCommand}"
Content="Test"
Margin="5"
/>

4
MainWindow.xaml.cs
View File

@ -21,4 +21,8 @@ public partial class MainWindow : Window {
public MainWindow() {
InitializeComponent();
}
private void Label_Scroll(object sender, System.Windows.Controls.Primitives.ScrollEventArgs e) {
}
}

267
Suslang/Suslang.cs
View File

@ -73,7 +73,7 @@ public class Lexer {
step();
while (!done() && "1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_".Contains(current()))
step();
this.text.Substring(start.index, this.i - start.index).switch {
return this.text.Substring(start.index, this.i - start.index) switch {
"false" => token(TokenType.False, start),
"true" => token(TokenType.True, start),
_ => token(TokenType.Id, start),
@ -84,9 +84,9 @@ public class Lexer {
var start = position();
switch (current()) {
case '0':
break;
return zeroToken();
case '.':
break;
return dotToken();
case '(':
step();
return token(TokenType.LParen, start);
@ -118,21 +118,21 @@ public class Lexer {
var start = position();
step();
if (!done() && (current() == 'x' || current() == 'X')) {
while (!done() && "1234567890abcdefABCDEF".Contains(current()))
while (!done() && "1234567890abcdefABCDEF".Contains(current()))
step();
return token(TokenType.Hex, start);
} else {
while (!done() && "1234567890".Contains(current()))
while (!done() && "1234567890".Contains(current()))
step();
return token(TokenType.Int, start);
}
}
private Token dotToken() {
var start = position();
step();
if (!done() && "1234567890".Contains(current())) {
while (!done() && "1234567890".Contains(current()))
while (!done() && "1234567890".Contains(current()))
step();
return token(TokenType.Decimal, start);
} else {
@ -157,6 +157,14 @@ public class Lexer {
private void step() {
this.i += 1;
if (!done()) {
if (current() == '\n') {
this.line += 1;
this.col = 1;
} else {
this.col += 1;
}
}
}
}
@ -164,46 +172,46 @@ public interface Expr {
string astString(int depth);
}
public ErrorExpr : Expr {
public class ErrorExpr : Expr {
public Position position;
public string message;
public override astString(int depth) =>
public string astString(int depth) =>
$"ErrorExpr {{ {this.position.line}:{this.position.col} \"{this.message}\" }}";
}
public IdExpr : Expr {
public class IdExpr : Expr {
public string value;
public override astString(int depth) =>
public string astString(int depth) =>
$"IdExpr {{ \"{this.value}\" }}";
}
public IntExpr : Expr {
public class IntExpr : Expr {
public int value;
public override astString(int depth) =>
public string astString(int depth) =>
$"IntExpr {{ {this.value} }}";
}
public FloatExpr : Expr {
public class FloatExpr : Expr {
public double value;
public override astString(int depth) =>
public string astString(int depth) =>
$"FloatExpr {{ {this.value} }}";
}
public StringExpr : Expr {
public class StringExpr : Expr {
public string value;
public override astString(int depth) =>
public string astString(int depth) =>
$"FloatExpr {{ \"{this.value}\" }}";
}
public BoolExpr : Expr {
public class BoolExpr : Expr {
public bool value;
public override astString(int depth) =>
public string astString(int depth) =>
$"BoolExpr {{ {this.value} }}";
}
@ -212,13 +220,13 @@ public enum UnaryType {
Negate,
}
public UnaryExpr : Expr {
public class UnaryExpr : Expr {
public UnaryType type;
public Expr value;
public override astString(int depth) =>
$"UnaryExpr {{\n{new String(' ', depth) + 1}type: "
+ $"{this.type.ToString()},\n{new String(' ', depth + 1)}value: "
public string astString(int depth) =>
$"UnaryExpr {{\n{new string(' ', depth + 1)}type: "
+ $"{this.type},\n{new string(' ', depth + 1)}value: "
+ $"{this.value.astString(depth + 1)}\n{new String(' ', depth)}}}";
}
@ -227,28 +235,29 @@ public enum BinaryType {
Subtract,
Multiply,
Divide,
Modulus,
Modulo,
}
public BinaryExpr : Expr {
public class BinaryExpr : Expr {
public BinaryType type;
public Expr left, right;
public override astString(int depth) =>
$"UnaryExpr {{\n{new String(' ', depth) + 1}type: "
public string astString(int depth) =>
$"BinaryExpr {{\n{new String(' ', depth + 1)}type: "
+ $"{this.type.ToString()},\n{new String(' ', depth + 1)}left: "
+ $"{this.left.astString(depth + 1)},\n{new String(' ', depth + 1)}right: "
+ $"{this.right.astString(depth + 1)}\n{new String(' ', depth)}}}";
+ $"{this.right.astString(depth + 1)},\n{new String(' ', depth)}}}";
}
public class Parser {
private int i = 0;
private string text;
private List<Token> tokens;
private Lexer lexer;
private Token currentToken;
public Parser(string text, List<Token> tokens) {
public Parser(string text, Lexer lexer) {
this.text = text;
this.tokens = tokens;
this.lexer = lexer;
this.currentToken = this.lexer.next();
}
public Expr parseExpr() {
@ -269,7 +278,7 @@ public class Parser {
step();
var right = parsePrec11();
return new BinaryExpr() {
type = BinaryType.Subtraction,
type = BinaryType.Subtract,
left = left,
right = right,
};
@ -282,7 +291,7 @@ public class Parser {
var left = parsePrec13();
if (!done() && current().type == TokenType.Asterisk) {
step();
var right = parePrec12();
var right = parsePrec12();
return new BinaryExpr() {
type = BinaryType.Multiply,
left = left,
@ -290,7 +299,7 @@ public class Parser {
};
} else if (!done() && current().type == TokenType.Slash) {
step();
var right = parePrec12();
var right = parsePrec12();
return new BinaryExpr() {
type = BinaryType.Divide,
left = left,
@ -298,9 +307,9 @@ public class Parser {
};
} else if (!done() && current().type == TokenType.Percent) {
step();
var right = parePrec12();
var right = parsePrec12();
return new BinaryExpr() {
type = BinaryType.Modulus,
type = BinaryType.Modulo,
left = left,
right = right,
};
@ -317,7 +326,7 @@ public class Parser {
if (!done() && current().type == TokenType.LParen) {
step();
var expr = parseExpr();
if (done() || current().type TokenType.RParen) {
if (done() || current().type != TokenType.RParen) {
var pos = position();
step();
return new ErrorExpr() {
@ -332,13 +341,13 @@ public class Parser {
}
}
public parseOperand() {
public Expr parseOperand() {
var start = position();
if (done()) {
step();
return new ErrorExpr() {
position = start,
message = "expected value, got eof",
message = "expected value, got Eof",
};
} else if (current().type == TokenType.Int) {
var intToken = current();
@ -347,13 +356,19 @@ public class Parser {
var decimalToken = current();
step();
return new FloatExpr() {
value = double.Parse(this.text.Substring(start.index, intToken.length + decimalToken.length)),
value = double.Parse(this.text.Substring(start.index, intToken.length + decimalToken.length).Replace(".", ",")),
};
} else {
return new IntExpr() {
value = int.Parse(this.text.Substring(start.index, intToken.length));
value = int.Parse(this.text.Substring(start.index, intToken.length)),
};
}
} else if (current().type == TokenType.Decimal) {
var decimalToken = current();
step();
return new FloatExpr() {
value = double.Parse("0" + this.text.Substring(start.index, decimalToken.length).Replace(".", ",")),
};
} else if (current().type == TokenType.String) {
var stringToken = current();
step();
@ -379,34 +394,182 @@ public class Parser {
}
}
private char current() => this.tokens[this.i];
private bool done() => this.i >= this.text.Length;
private Position position() => current().position;
private Token current() => this.currentToken;
private bool done() => this.currentToken.type == TokenType.Eof;
private void step() {
this.i += 1;
this.currentToken = this.lexer.next();
}
}
public interface Operation {}
public interface Operation { }
public class PushInt {
public class PushIntOperation : Operation {
public int value;
}
}
public class PushFloat {
public class PushFloatOperation : Operation {
public double value;
}
public class PushStringOperation : Operation {
public string value;
}
public class PushBoolOperation : Operation {
public bool value;
}
public class AddIntOperation : Operation { }
public class SubtractIntOperation : Operation { }
public class MultiplyIntOperation : Operation { }
public class DivideIntOperation : Operation { }
public class ModuloIntOperation : Operation { }
public class AddFloatOperation : Operation { }
public class SubtractFloatOperation : Operation { }
public class MultiplyFloatOperation : Operation { }
public class DivideFloatOperation : Operation { }
public class ModuloFloatOperation : Operation { }
public class Compiler {
public List<Operation> compileExpr(Expr expr) {
private List<Operation> operations = new();
public List<Operation> result() => this.operations;
public string compileExpr(Expr expr) {
switch (expr) {
case IntExpr:
return compileIntExpr((IntExpr) expr);
break;
case FloatExpr:
return compileFloatExpr((FloatExpr) expr);
break;
case StringExpr:
return compileStringExpr((StringExpr) expr);
break;
case BoolExpr:
return compileBoolExpr((BoolExpr) expr);
break;
case UnaryExpr:
return compileUnaryExpr((UnaryExpr) expr);
break;
case BinaryExpr:
return compileBinaryExpr((BinaryExpr) expr);
break;
default:
throw new NotImplementedException();
};
}
public string compileIntExpr(IntExpr expr) {
this.operations.Add(new PushIntOperation() { value = expr.value });
return "int";
}
public string compileFloatExpr(FloatExpr expr) {
this.operations.Add(new PushFloatOperation() { value = expr.value });
return "float";
}
public string compileStringExpr(StringExpr expr) {
this.operations.Add(new PushStringOperation() { value = expr.value });
return "string";
}
public string compileBoolExpr(BoolExpr expr) {
this.operations.Add(new PushBoolOperation() { value = expr.value });
return "bool";
}
public string compileUnaryExpr(UnaryExpr expr) {
throw new NotImplementedException();
}
public string compileBinaryExpr(BinaryExpr expr) {
var leftType = compileExpr(expr.left);
var rightType = compileExpr(expr.right);
if ((leftType, rightType) == ("int", "int")) {
this.operations.Add(expr.type switch {
BinaryType.Add => new AddIntOperation(),
BinaryType.Subtract => new SubtractIntOperation(),
BinaryType.Multiply => new MultiplyIntOperation(),
BinaryType.Divide => new DivideIntOperation(),
BinaryType.Modulo => new ModuloIntOperation(),
});
return "int";
} else if ((leftType, rightType) == ("int", "int")) {
this.operations.Add(expr.type switch {
BinaryType.Add => new AddFloatOperation(),
BinaryType.Subtract => new SubtractFloatOperation(),
BinaryType.Multiply => new MultiplyFloatOperation(),
BinaryType.Divide => new DivideFloatOperation(),
BinaryType.Modulo => new ModuloFloatOperation(),
});
return "float";
} else {
throw new Exception("type mismatch");
}
}
}
public interface Value { }
public class IntValue : Value { public int value; }
public class FloatValue : Value { public double value; }
public class VM {
public Value evaluate(List<Operation> program) {
throw new NotImplementedException();
private int pc = 0;
private List<Operation> program;
public Stack<Value> stack = new();
public VM(List<Operation> program) {
this.program = program;
}
public void evaluate() {
while (this.pc < this.program.Count) {
switch (this.program[this.pc]) {
case PushIntOperation op:
this.stack.Push(new IntValue() { value = op.value });
break;
case PushFloatOperation op:
this.stack.Push(new FloatValue() { value = op.value });
break;
case AddIntOperation:
this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value + ((IntValue) this.stack.Pop()).value });
break;
case SubtractIntOperation:
this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value - ((IntValue) this.stack.Pop()).value });
break;
case MultiplyIntOperation:
this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value * ((IntValue) this.stack.Pop()).value });
break;
case DivideIntOperation:
this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value / ((IntValue) this.stack.Pop()).value });
break;
case ModuloIntOperation:
this.stack.Push(new IntValue() { value = ((IntValue) this.stack.Pop()).value % ((IntValue) this.stack.Pop()).value });
break;
case AddFloatOperation:
this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value + ((FloatValue) this.stack.Pop()).value });
break;
case SubtractFloatOperation:
this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value - ((FloatValue) this.stack.Pop()).value });
break;
case MultiplyFloatOperation:
this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value * ((FloatValue) this.stack.Pop()).value });
break;
case DivideFloatOperation:
this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value / ((FloatValue) this.stack.Pop()).value });
break;
case ModuloFloatOperation:
this.stack.Push(new FloatValue() { value = ((FloatValue) this.stack.Pop()).value % ((FloatValue) this.stack.Pop()).value });
break;
default:
break;
}
this.pc += 1;
}
}
}