belka/elna
1
0
Fork 0
Code Issues 34 Pull Requests Releases Activity

Print test summary

Browse Source
This commit is contained in:
Eugen Wissner
2024-02-28 16:18:39 +01:00
parent 03a72fc583
commit 4d46fc6b4d
18 changed files with 890 additions and 706 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
CMakeLists.txt
View File

@@ -12,11 +12,14 @@ add_executable(elnsh shell/main.cpp
shell/interactive.cpp include/elna/interactive.hpp
shell/history.cpp include/elna/history.hpp
shell/state.cpp include/elna/state.hpp
shell/result.cpp include/elna/result.hpp
)
target_include_directories(elnsh PRIVATE include)
add_library(elna
source/lexer.cpp include/elna/lexer.hpp
source/result.cpp include/elna/result.hpp
source/riscv.cpp include/elna/riscv.hpp
source/ir.cpp include/elna/ir.hpp
include/elna/parser.hpp
)
target_include_directories(elna PRIVATE include)

75
Rakefile
View File

@@ -4,87 +4,16 @@ require 'open3'
DFLAGS = ['--warn-no-deprecated', '-L/usr/lib64/gcc-12']
BINARY = 'build/bin/elna'
TESTS = FileList['tests/*.eln'].flat_map do |test|
build = Pathname.new 'build'
test_basename = Pathname.new(test).basename('')
[build + 'riscv' + test_basename].map { |path| path.sub_ext('').to_path }
end
SOURCES = FileList['source/**/*.d']
directory 'build'
directory 'build/riscv'
CLEAN.include 'build'
CLEAN.include '.dub'
rule(/build\/riscv\/[^\/\.]+$/ => ->(file) { test_for_out(file, '.o') }) do |t|
sh '/opt/riscv/bin/riscv32-unknown-elf-ld',
'-o', t.name,
'-L/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/',
'-L/opt/riscv/riscv32-unknown-elf/lib',
'/opt/riscv/riscv32-unknown-elf/lib/crt0.o',
'/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtbegin.o',
t.source,
'--start-group', '-lgcc', '-lc', '-lgloss', '--end-group',
'/opt/riscv/lib/gcc/riscv32-unknown-elf/13.2.0/crtend.o'
end
rule(/build\/riscv\/.+\.o$/ => ->(file) { test_for_object(file, '.eln') }) do |t|
Pathname.new(t.name).dirname.mkpath
sh BINARY, '-o', t.name, t.source
end
file BINARY => SOURCES do |t|
sh({ 'DFLAGS' => (DFLAGS * ' ') }, 'dub', 'build', '--compiler=gdc')
end
task default: 'build/riscv'
task default: BINARY
desc 'Run all tests and check the results'
task test: TESTS
task test: BINARY do
TESTS.each do |test|
expected = Pathname
.new(test)
.sub_ext('.txt')
.sub(/^build\/[[:alpha:]]+\//, 'tests/expectations/')
.to_path
puts "Running #{test}"
if test.include? '/riscv/'
spike = [
'/opt/riscv/bin/spike',
'--isa=RV32IMAC',
'/opt/riscv/riscv32-unknown-elf/bin/pk',
test
]
diff = ['diff', '-Nur', '--color', expected, '-']
tail = ['tail', '-n', '1']
last_stdout, wait_threads = Open3.pipeline_r spike, tail, diff
else
raise 'Unsupported test platform'
end
print last_stdout.read
last_stdout.close
fail unless wait_threads.last.value.exitstatus.zero?
end
end
def test_for_object(out_file, extension)
test_source = Pathname
.new(out_file)
.sub_ext(extension)
.sub(/^build\/[[:alpha:]]+\//, 'tests/')
.to_path
[test_source, BINARY]
end
def test_for_out(out_file, extension)
Pathname
.new(out_file)
.sub_ext(extension)
.to_path
end

4
dub.json
View File

@@ -5,5 +5,7 @@
"name": "elna",
"targetType": "executable",
"targetPath": "build/bin",
"mainSourceFile": "source/main.d"
"mainSourceFile": "source/main.d",
"libs": ["elna", "stdc++"],
"lflags": ["-Lbuild"]
}

95
include/elna/ir.hpp Normal file
View File

@@ -0,0 +1,95 @@
#pragma once
#include "elna/parser.hpp"
#include <cstddef>
#include <cstdint>
namespace elna::ir
{
class Node;
class Definition;
class Operand;
class BinaryExpression;
class Variable;
class VariableDeclaration;
class Number;
struct IRVisitor
{
virtual void visit(Node *) = 0;
virtual void visit(Definition *) = 0;
virtual void visit(Operand *) = 0;
virtual void visit(BinaryExpression *) = 0;
virtual void visit(Variable *) = 0;
virtual void visit(Number *) = 0;
};
/**
* AST node.
*/
class Node
{
public:
virtual void accept(IRVisitor *) = 0;
};
/**
* Definition.
*/
class Definition : public Node
{
public:
BinaryExpression **statements;
std::size_t statementsLength;
Operand *result;
virtual void accept(IRVisitor *visitor) override;
};
class Statement : public Node
{
};
class Operand : public Node
{
public:
virtual void accept(IRVisitor *visitor) override;
};
class Number : public Operand
{
public:
std::int32_t value;
virtual void accept(IRVisitor *visitor) override;
};
class Variable : public Operand
{
public:
std::size_t counter;
virtual void accept(IRVisitor *visitor) override;
};
class BinaryExpression : public Statement
{
public:
Operand *lhs, *rhs;
BinaryOperator _operator;
BinaryExpression(Operand *lhs, Operand *rhs, BinaryOperator _operator);
virtual void accept(IRVisitor *visitor) override;
};
class BangExpression : public Statement
{
Operand *operand;
public:
BangExpression(Operand *operand);
virtual void accept(IRVisitor *visitor) override;
};
}

57
include/elna/lexer.hpp
View File

@@ -14,10 +14,10 @@ namespace elna
class const_iterator
{
std::string::const_iterator m_buffer;
source_position m_position;
Position m_position;
const_iterator(std::string::const_iterator buffer,
const source_position position = source_position());
const Position position = Position());
public:
using iterator_category = std::forward_iterator_tag;
@@ -26,7 +26,7 @@ namespace elna
using pointer = const value_type *;
using reference = const value_type&;
const source_position& position() const noexcept;
const Position& position() const noexcept;
reference operator*() const noexcept;
pointer operator->() const noexcept;
@@ -43,38 +43,61 @@ namespace elna
const_iterator end() const;
private:
const std::string& m_buffer;
const std::string m_buffer;
};
/**
* Union type representing a single token.
*/
struct token
struct Token
{
/**
* Token type.
*/
enum class type
enum Type : std::uint16_t
{
word,
TOKEN_NUMBER = 0,
TOKEN_OPERATOR = 1,
TOKEN_LET = 2,
TOKEN_IDENTIFIER = 3,
TOKEN_EQUALS = 4,
TOKEN_VAR = 5,
TOKEN_SEMICOLON = 6,
TOKEN_LEFT_PAREN = 7,
TOKEN_RIGHT_PAREN = 8,
TOKEN_BANG = 9,
TOKEN_DOT = 10,
TOKEN_COMMA = 11,
};
/**
* Type of the token value.
*/
using value = std::string;
union Value
{
std::int32_t number;
const char *identifier;
};
token(const type of, source::const_iterator begin, source::const_iterator end);
Token(Type of, Position position);
Token(Type of, std::int32_t value, Position position);
Token(Type of, const char *value, Position position);
Token(const Token& that);
Token(Token&& that);
~Token();
type of() const noexcept;
const value& identifier() const noexcept;
const source_position& position() const noexcept;
Token& operator=(const Token& that);
Token& operator=(Token&& that);
Type of() const noexcept;
const char *identifier() const noexcept;
std::int32_t number() const noexcept;
const Position& position() const noexcept;
private:
std::string m_value;
source_position m_position;
type m_type;
Type m_type;
Value m_value;
Position m_position;
};
/**
@@ -82,5 +105,5 @@ namespace elna
*
* \return Tokens or error.
*/
result<std::vector<token>> lex(const std::string& buffer);
Token *lex(const char *buffer, CompileError *compile_error, std::size_t *length);
}

10
include/elna/parser.hpp Normal file
View File

@@ -0,0 +1,10 @@
#pragma once
namespace elna
{
enum class BinaryOperator
{
sum,
subtraction
};
}

24
include/elna/result.hpp
View File

@@ -8,7 +8,7 @@ namespace elna
/**
* Position in the source text.
*/
struct source_position
struct Position
{
/// Line.
std::size_t line = 1;
@@ -20,18 +20,18 @@ namespace elna
/**
* A compilation error consists of an error message and position.
*/
struct compile_error
struct CompileError
{
private:
char const *message;
source_position position;
Position position;
public:
/**
* @param message Error text.
* @param position Error position in the source text.
*/
compile_error(char const *message, const source_position position) noexcept;
CompileError(char const *message, const Position position) noexcept;
/// Error text.
const char *what() const noexcept;
@@ -44,5 +44,19 @@ namespace elna
};
template<typename T>
using result = boost::outcome_v2::result<T, compile_error>;
using result = boost::outcome_v2::result<T, CompileError>;
enum class Target
{
text,
high20,
lower12i
};
struct Reference
{
const char* name;
size_t offset;
Target target;
};
}

148
include/elna/riscv.hpp Normal file
View File

@@ -0,0 +1,148 @@
#pragma once
#include <cstdint>
#include "elna/ir.hpp"
#include "elna/result.hpp"
namespace elna
{
enum class XRegister : std::uint8_t
{
zero = 0,
ra = 1,
sp = 2,
gp = 3,
tp = 4,
t0 = 5,
t1 = 6,
t2 = 7,
s0 = 8,
s1 = 9,
a0 = 10,
a1 = 11,
a2 = 12,
a3 = 13,
a4 = 14,
a5 = 15,
a6 = 16,
a7 = 17,
s2 = 18,
s3 = 19,
s4 = 20,
s5 = 21,
s6 = 22,
s7 = 23,
s8 = 24,
s9 = 25,
s10 = 26,
s11 = 27,
t3 = 28,
t4 = 29,
t5 = 30,
t6 = 31,
};
enum class Funct3 : std::uint8_t
{
addi = 0b000,
slti = 0b001,
sltiu = 0b011,
andi = 0b111,
ori = 0b110,
xori = 0b100,
slli = 0b000,
srli = 0b101,
srai = 0b101,
add = 0b000,
slt = 0b010,
sltu = 0b011,
_and = 0b111,
_or = 0b110,
_xor = 0b100,
sll = 0b001,
srl = 0b101,
sub = 0b000,
sra = 0b101,
beq = 0b000,
bne = 0b001,
blt = 0b100,
bltu = 0b110,
bge = 0b101,
bgeu = 0b111,
fence = 0b000,
fenceI = 0b001,
csrrw = 0b001,
csrrs = 0b010,
csrrc = 0b011,
csrrwi = 0b101,
csrrsi = 0b110,
csrrci = 0b111,
priv = 0b000,
sb = 0b000,
sh = 0b001,
sw = 0b010,
lb = 0b000,
lh = 0b001,
lw = 0b010,
lbu = 0b100,
lhu = 0b101,
jalr = 0b000,
};
enum class Funct12 : std::uint8_t
{
ecall = 0b000000000000,
ebreak = 0b000000000001,
};
enum class Funct7 : std::uint8_t
{
none = 0,
sub = 0b0100000
};
enum class BaseOpcode : std::uint8_t
{
opImm = 0b0010011,
lui = 0b0110111,
auipc = 0b0010111,
op = 0b0110011,
jal = 0b1101111,
jalr = 0b1100111,
branch = 0b1100011,
load = 0b0000011,
store = 0b0100011,
miscMem = 0b0001111,
system = 0b1110011,
};
struct Instruction
{
Instruction(BaseOpcode opcode);
Instruction& i(XRegister rd, Funct3 funct3, XRegister rs1, std::uint32_t immediate);
Instruction& s(std::uint32_t imm1, Funct3 funct3, XRegister rs1, XRegister rs2);
Instruction& r(XRegister rd, Funct3 funct3, XRegister rs1, XRegister rs2, Funct7 funct7 = Funct7::none);
Instruction& u(XRegister rd, std::uint32_t imm);
std::uint8_t *encode();
private:
std::uint32_t instruction{ 0 };
};
class RiscVVisitor : public ir::IRVisitor
{
Instruction *instructions;
std::size_t instructionsLength;
bool registerInUse;
std::uint32_t variableCounter = 1;
Reference references[3];
virtual void visit(ir::Node *) override;
virtual void visit(ir::Definition *definition) override;
virtual void visit(ir::Operand *operand) override;
virtual void visit(ir::Variable *variable) override;
virtual void visit(ir::Number *number) override;
virtual void visit(ir::BinaryExpression *expression) override;
};
}

39
source/elna/backend.d
View File

@@ -2,6 +2,7 @@ module elna.backend;
import core.stdc.stdio;
import core.stdc.stdlib;
import core.stdc.string;
import elna.elf;
import elna.ir;
import elna.extended;
@@ -17,7 +18,7 @@ import tanya.container.array;
import tanya.container.string;
import tanya.memory.allocator;
private Nullable!String readSource(string source) @nogc
private char* readSource(string source) @nogc
{
enum size_t bufferSize = 255;
auto sourceFilename = String(source);
@@ -25,31 +26,39 @@ private Nullable!String readSource(string source) @nogc
return readFile(sourceFilename).match!(
(ErrorCode errorCode) {
perror(sourceFilename.toStringz);
return Nullable!String();
return null;
},
(Array!ubyte contents) => nullable(String(cast(char[]) contents.get))
(Array!ubyte contents) {
char* cString = cast(char*) malloc(contents.length + 1);
memcpy(cString, contents.get.ptr, contents.length);
cString[contents.length] = '\0';
return cString;
}
);
}
int generate(string inFile, ref String outputFilename) @nogc
{
auto sourceText = readSource(inFile);
if (sourceText.isNull)
if (sourceText is null)
{
return 3;
}
auto tokens = lex(sourceText.get.get);
if (!tokens.valid)
CompileError compileError = void;
size_t tokensCount;
auto tokens = lex(sourceText, &compileError, &tokensCount);
free(sourceText);
if (tokens is null)
{
auto compileError = tokens.error.get;
printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.message.ptr);
printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.what);
return 1;
}
auto ast = parse(tokens.result);
auto ast = parse(tokens[0 .. tokensCount]);
if (!ast.valid)
{
auto compileError = ast.error.get;
printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.message.ptr);
compileError = ast.error.get;
printf("%lu:%lu: %s\n", compileError.line, compileError.column, compileError.what);
return 2;
}
auto transformVisitor = cast(TransformVisitor) malloc(__traits(classInstanceSize, TransformVisitor));
@@ -85,18 +94,18 @@ int generate(string inFile, ref String outputFilename) @nogc
final switch (reference.target)
{
case Reference.Target.text:
case Target.text:
relocationEntry.r_info = R_RISCV_CALL;
break;
case Reference.Target.high20:
case Target.high20:
relocationEntry.r_info = R_RISCV_HI20;
break;
case Reference.Target.lower12i:
case Target.lower12i:
relocationEntry.r_info = R_RISCV_LO12_I;
break;
}
elf.relocate(reference.name, relocationEntry, relocationSub);
elf.relocate(String(reference.name[0 .. strlen(reference.name)]), relocationEntry, relocationSub);
}
elf.finish();

104
source/elna/ir.d
View File

@@ -1,5 +1,6 @@
module elna.ir;
import core.stdc.stdlib;
import parser = elna.parser;
import tanya.container.array;
import tanya.container.hashtable;
@@ -14,7 +15,6 @@ struct ASTMapping
{
alias Node = .Node;
alias Definition = .Definition;
alias VariableDeclaration = .VariableDeclaration;
alias Statement = .Operand;
alias BangStatement = .Operand;
alias Block = .Definition;
@@ -28,20 +28,21 @@ struct ASTMapping
/**
* IR visitor.
*/
interface IRVisitor
extern(C++, "elna", "ir")
abstract class IRVisitor
{
abstract void visit(Node) @nogc;
abstract void visit(Definition) @nogc;
abstract void visit(Operand) @nogc;
abstract void visit(BinaryExpression) @nogc;
abstract void visit(Variable) @nogc;
abstract void visit(VariableDeclaration) @nogc;
abstract void visit(Number) @nogc;
}
/**
* AST node.
*/
extern(C++, "elna", "ir")
abstract class Node
{
abstract void accept(IRVisitor) @nogc;
@@ -50,99 +51,69 @@ abstract class Node
/**
* Definition.
*/
extern(C++, "elna", "ir")
class Definition : Node
{
char[] identifier;
Array!BinaryExpression statements;
Array!VariableDeclaration variableDeclarations;
BinaryExpression* statements;
size_t statementsLength;
Operand result;
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
extern(C++, "elna", "ir")
abstract class Statement : Node
{
}
extern(C++, "elna", "ir")
abstract class Operand : Node
{
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
extern(C++, "elna", "ir")
class Number : Operand
{
int value;
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
extern(C++, "elna", "ir")
class Variable : Operand
{
size_t counter;
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
}
class VariableDeclaration : Node
{
String identifier;
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
extern(C++, "elna", "ir")
class BinaryExpression : Statement
{
Operand lhs, rhs;
BinaryOperator operator;
this(Operand lhs, Operand rhs, BinaryOperator operator)
@nogc
{
this.lhs = lhs;
this.rhs = rhs;
this.operator = operator;
}
this(Operand lhs, Operand rhs, BinaryOperator operator) @nogc;
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
extern(C++, "elna", "ir")
class BangExpression : Statement
{
Operand operand;
this(Operand operand)
{
this.operand = operand;
}
this(Operand operand);
override void accept(IRVisitor visitor) @nogc
{
visitor.visit(this);
}
override void accept(IRVisitor visitor) @nogc;
}
final class TransformVisitor : parser.ParserVisitor!ASTMapping
{
private HashTable!(String, int) constants;
private Array!BinaryExpression statements;
private BinaryExpression* statements;
private size_t statementsLength;
ASTMapping.Node visit(parser.Node node) @nogc
{
@@ -154,11 +125,6 @@ final class TransformVisitor : parser.ParserVisitor!ASTMapping
assert(false, "Not implemented");
}
ASTMapping.VariableDeclaration visit(parser.VariableDeclaration declaration) @nogc
{
assert(false, "Not implemented");
}
ASTMapping.BangStatement visit(parser.BangStatement statement) @nogc
{
return statement.expression.accept(this);
@@ -171,8 +137,7 @@ final class TransformVisitor : parser.ParserVisitor!ASTMapping
target.result = block.statement.accept(this);
target.statements = this.statements;
target.variableDeclarations = transformVariableDeclarations(block.variableDeclarations);
target.statementsLength = this.statementsLength;
return target;
}
@@ -217,10 +182,12 @@ final class TransformVisitor : parser.ParserVisitor!ASTMapping
binaryExpression.rhs.accept(this),
binaryExpression.operator
);
statements.insertBack(target);
this.statements = cast(BinaryExpression*)
realloc(this.statements, (this.statementsLength + 1) * BinaryExpression.sizeof);
this.statements[this.statementsLength++] = target;
auto newVariable = defaultAllocator.make!Variable;
newVariable.counter = statements.length;
newVariable.counter = this.statementsLength;
return newVariable;
}
@@ -250,19 +217,4 @@ final class TransformVisitor : parser.ParserVisitor!ASTMapping
return constants;
}
Array!VariableDeclaration transformVariableDeclarations(ref Array!(parser.VariableDeclaration) variableDeclarations)
@nogc
{
typeof(return) variables;
foreach (ref variableDeclaration; variableDeclarations)
{
auto newDeclaration = defaultAllocator.make!VariableDeclaration;
newDeclaration.identifier = variableDeclaration.identifier;
variables.insertBack(newDeclaration);
}
return variables;
}
}

209
source/elna/lexer.d
View File

@@ -8,28 +8,29 @@ import std.range;
import tanya.container.array;
import tanya.container.string;
extern(C++, "elna")
struct Token
{
enum Type
enum Type : ushort
{
number,
operator,
let,
identifier,
equals,
var,
semicolon,
leftParen,
rightParen,
bang,
dot,
comma,
number = 0,
operator = 1,
let = 2,
identifier = 3,
equals = 4,
var = 5,
semicolon = 6,
leftParen = 7,
rightParen = 8,
bang = 9,
dot = 10,
comma = 11,
}
union Value
{
int number;
String identifier;
const(char)* identifier;
}
private Type type;
@@ -38,62 +39,21 @@ struct Token
@disable this();
this(Type type, Position position) @nogc nothrow pure @safe
{
this.type = type;
this.position_ = position;
}
this(Type type, int value, Position position) @nogc nothrow pure @trusted
in (type == Type.number)
{
this(type, position);
this.value_.number = value;
}
this()(Type type, auto ref String value, Position position)
@nogc nothrow pure @trusted
in (type == Type.identifier || type == Type.operator)
{
this(type, position);
this.value_.identifier = value;
}
this(Type type, Position position) @nogc nothrow pure @safe;
this(Type type, int value, Position position) @nogc nothrow pure @trusted;
this(Type type, const(char)* value, Position position) @nogc nothrow;
/**
* Params:
* type = Expected type.
*
* Returns: Whether this token is of the expected type.
* Returns: Expected token type.
*/
bool ofType(Type type) const @nogc nothrow pure @safe
{
return this.type == type;
}
@property auto value(Type type)() @nogc nothrow pure @trusted
in (ofType(type))
{
static if (type == Type.number)
{
return this.value_.number;
}
else static if (type == Type.identifier || type == Type.operator)
{
return this.value_.identifier;
}
else
{
static assert(false, "This type doesn't have a value");
}
}
Type of() const @nogc nothrow pure @safe;
const(char)* identifier() const @nogc nothrow pure;
int number() const @nogc nothrow pure;
/**
* Returns: The token position in the source text.
*/
@property const(Position) position() const @nogc nothrow pure @safe
{
return this.position_;
}
@property const(Position) position() const @nogc nothrow pure @safe;
}
/**
@@ -101,10 +61,10 @@ struct Token
*/
struct Source
{
char[] buffer;
const(char)* buffer;
Position position;
this(char[] buffer) @nogc nothrow pure @safe
this(const(char)* buffer) @nogc nothrow pure @safe
{
this.buffer = buffer;
}
@@ -113,7 +73,7 @@ struct Source
bool empty() @nogc nothrow pure @safe
{
return this.length == 0;
return this.buffer is null || this.buffer[0] == '\0';
}
char front() @nogc nothrow pure @safe
@@ -122,133 +82,36 @@ struct Source
return this.buffer[0];
}
void popFront() @nogc nothrow pure @safe
void popFront() @nogc nothrow pure
in (!empty)
{
this.buffer = buffer[1 .. $];
++this.buffer;
++this.position.column;
}
void breakLine() @nogc nothrow pure @safe
void breakLine() @nogc nothrow pure
in (!empty)
{
this.buffer = buffer[1 .. $];
++this.buffer;
++this.position.line;
this.position.column = 1;
}
@property size_t length() const @nogc nothrow pure @safe
@property size_t length() const @nogc nothrow pure
{
return this.buffer.length;
return strlen(this.buffer);
}
char opIndex(size_t index) @nogc nothrow pure @safe
in (index < length)
char opIndex(size_t index) @nogc nothrow pure
{
return this.buffer[index];
}
char[] opSlice(size_t i, size_t j) @nogc nothrow pure @safe
in
{
assert(i <= j);
assert(j <= length);
}
do
const(char)[] opSlice(size_t i, size_t j) @nogc nothrow pure
{
return this.buffer[i .. j];
}
}
Result!(Array!Token) lex(char[] buffer) @nogc
{
Array!Token tokens;
auto source = Source(buffer);
while (!source.empty)
{
if (source.front == ' ')
{
source.popFront;
}
else if (source.front >= '0' && source.front <= '9') // Multi-digit.
{
tokens.insertBack(Token(Token.Type.number, source.front - '0', source.position));
source.popFront;
}
else if (source.front == '=')
{
tokens.insertBack(Token(Token.Type.equals, source.position));
source.popFront;
}
else if (source.front == '(')
{
tokens.insertBack(Token(Token.Type.leftParen, source.position));
source.popFront;
}
else if (source.front == ')')
{
tokens.insertBack(Token(Token.Type.rightParen, source.position));
source.popFront;
}
else if (source.front == ';')
{
tokens.insertBack(Token(Token.Type.semicolon, source.position));
source.popFront;
}
else if (source.front == ',')
{
tokens.insertBack(Token(Token.Type.comma, source.position));
source.popFront;
}
else if (source.front == '!')
{
tokens.insertBack(Token(Token.Type.bang, source.position));
source.popFront;
}
else if (source.front == '.')
{
tokens.insertBack(Token(Token.Type.dot, source.position));
source.popFront;
}
else if (isalpha(source.front))
{
size_t i = 1;
while (i < source.length && isalpha(source[i]))
{
++i;
}
if (source[0 .. i] == "const")
{
tokens.insertBack(Token(Token.Type.let, source.position));
}
else if (source[0 .. i] == "var")
{
tokens.insertBack(Token(Token.Type.var, source.position));
}
else
{
auto identifier = String(source[0 .. i]);
tokens.insertBack(Token(Token.Type.identifier, identifier, source.position));
}
source.popFrontN(i);
}
else if (source.front == '+' || source.front == '-')
{
String operator;
operator.insertBack(source.front);
tokens.insertBack(Token(Token.Type.operator, operator, source.position));
source.popFront;
}
else if (source.front == '\n')
{
source.breakLine;
}
else
{
return typeof(return)("Unexptected next character", source.position);
}
}
return typeof(return)(tokens);
}
extern(C++, "elna")
Token* lex(const(char)* buffer, CompileError* compileError, size_t* length) @nogc;

114
source/elna/parser.d
View File

@@ -1,11 +1,12 @@
module elna.parser;
import core.stdc.string;
import elna.lexer;
import elna.result;
import tanya.container.array;
import tanya.container.string;
import tanya.memory.allocator;
import std.array;
/**
* Parser visitor.
@@ -14,7 +15,6 @@ interface ParserVisitor(Mapping)
{
Mapping.Node visit(Node) @nogc;
Mapping.Definition visit(Definition) @nogc;
Mapping.VariableDeclaration visit(VariableDeclaration) @nogc;
Mapping.Statement visit(Statement) @nogc;
Mapping.BangStatement visit(BangStatement) @nogc;
Mapping.Block visit(Block) @nogc;
@@ -49,19 +49,6 @@ class Definition : Node
}
}
/**
* Variable declaration.
*/
class VariableDeclaration : Node
{
String identifier;
Mapping.VariableDeclaration accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
{
return visitor.visit(this);
}
}
abstract class Statement : Node
{
Mapping.Statement accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
@@ -83,7 +70,6 @@ class BangStatement : Statement
class Block : Node
{
Array!Definition definitions;
Array!VariableDeclaration variableDeclarations;
Statement statement;
Mapping.Block accept(Mapping)(ParserVisitor!Mapping visitor) @nogc
@@ -120,6 +106,7 @@ class Variable : Expression
}
}
extern(C++, "elna")
enum BinaryOperator
{
sum,
@@ -155,24 +142,24 @@ class BinaryExpression : Expression
}
}
private Result!Expression parseFactor(ref Array!Token.Range tokens) @nogc
private Result!Expression parseFactor(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected factor, got end of stream")
{
if (tokens.front.ofType(Token.Type.identifier))
if (tokens.front.of() == Token.Type.identifier)
{
auto variable = defaultAllocator.make!Variable;
variable.identifier = tokens.front.value!(Token.Type.identifier);
variable.identifier = tokens.front.identifier()[0 .. strlen(tokens.front.identifier())];
tokens.popFront;
return Result!Expression(variable);
}
else if (tokens.front.ofType(Token.Type.number))
else if (tokens.front.of() == Token.Type.number)
{
auto number = defaultAllocator.make!Number;
number.value = tokens.front.value!(Token.Type.number);
number.value = tokens.front.number();
tokens.popFront;
return Result!Expression(number);
}
else if (tokens.front.ofType(Token.Type.leftParen))
else if (tokens.front.of() == Token.Type.leftParen)
{
tokens.popFront;
@@ -184,20 +171,20 @@ in (!tokens.empty, "Expected factor, got end of stream")
return Result!Expression("Expected a factor", tokens.front.position);
}
private Result!Expression parseTerm(ref Array!(Token).Range tokens) @nogc
private Result!Expression parseTerm(ref Token[] tokens) @nogc
{
return parseFactor(tokens);
}
private Result!Expression parseExpression(ref Array!(Token).Range tokens) @nogc
private Result!Expression parseExpression(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected expression, got end of stream")
{
auto term = parseTerm(tokens);
if (!term.valid || tokens.empty || !tokens.front.ofType(Token.Type.operator))
if (!term.valid || tokens.empty || tokens.front.of() != Token.Type.operator)
{
return term;
}
auto operator = tokens.front.value!(Token.Type.operator);
auto operator = String(tokens.front.identifier()[0 .. strlen(tokens.front.identifier())]);
tokens.popFront;
auto expression = parseExpression(tokens);
@@ -215,19 +202,19 @@ in (!tokens.empty, "Expected expression, got end of stream")
}
}
private Result!Definition parseDefinition(ref Array!Token.Range tokens) @nogc
private Result!Definition parseDefinition(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected definition, got end of stream")
{
auto definition = defaultAllocator.make!Definition;
definition.identifier = tokens.front.value!(Token.Type.identifier); // Copy.
definition.identifier = tokens.front.identifier()[0 .. strlen(tokens.front.identifier())]; // Copy.
tokens.popFront();
tokens.popFront(); // Skip the equals sign.
if (tokens.front.ofType(Token.Type.number))
if (tokens.front.of() == Token.Type.number)
{
auto number = defaultAllocator.make!Number;
number.value = tokens.front.value!(Token.Type.number);
number.value = tokens.front.number();
definition.number = number;
tokens.popFront;
return Result!Definition(definition);
@@ -235,10 +222,10 @@ in (!tokens.empty, "Expected definition, got end of stream")
return Result!Definition("Expected a number", tokens.front.position);
}
private Result!Statement parseStatement(ref Array!Token.Range tokens) @nogc
private Result!Statement parseStatement(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected block, got end of stream")
{
if (tokens.front.ofType(Token.Type.bang))
if (tokens.front.of() == Token.Type.bang)
{
tokens.popFront;
auto statement = defaultAllocator.make!BangStatement;
@@ -256,7 +243,7 @@ in (!tokens.empty, "Expected block, got end of stream")
return Result!Statement("Expected ! statement", tokens.front.position);
}
private Result!(Array!Definition) parseDefinitions(ref Array!Token.Range tokens) @nogc
private Result!(Array!Definition) parseDefinitions(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected definition, got end of stream")
{
tokens.popFront; // Skip const.
@@ -271,11 +258,11 @@ in (!tokens.empty, "Expected definition, got end of stream")
return typeof(return)(definition.error.get);
}
definitions.insertBack(definition.result);
if (tokens.front.ofType(Token.Type.semicolon))
if (tokens.front.of() == Token.Type.semicolon)
{
break;
}
if (tokens.front.ofType(Token.Type.comma))
if (tokens.front.of() == Token.Type.comma)
{
tokens.popFront;
}
@@ -284,49 +271,11 @@ in (!tokens.empty, "Expected definition, got end of stream")
return typeof(return)(definitions);
}
private Result!(Array!VariableDeclaration) parseVariableDeclarations(ref Array!Token.Range tokens) @nogc
in (!tokens.empty, "Expected variable declarations, got end of stream")
{
tokens.popFront; // Skip var.
Array!VariableDeclaration variableDeclarations;
while (!tokens.empty)
{
auto currentToken = tokens.front;
if (currentToken.ofType(Token.Type.identifier))
{
auto variableDeclaration = defaultAllocator.make!VariableDeclaration;
variableDeclaration.identifier = currentToken.value!(Token.Type.identifier);
variableDeclarations.insertBack(variableDeclaration);
tokens.popFront;
}
else
{
return typeof(return)("Expected variable name", tokens.front.position);
}
if (tokens.empty)
{
return typeof(return)("Expected \";\" or \",\" name", currentToken.position);
}
if (tokens.front.ofType(Token.Type.semicolon))
{
break;
}
if (tokens.front.ofType(Token.Type.comma))
{
tokens.popFront;
}
}
return typeof(return)(variableDeclarations);
}
private Result!Block parseBlock(ref Array!Token.Range tokens) @nogc
private Result!Block parseBlock(ref Token[] tokens) @nogc
in (!tokens.empty, "Expected block, got end of stream")
{
auto block = defaultAllocator.make!Block;
if (tokens.front.ofType(Token.Type.let))
if (tokens.front.of() == Token.Type.let)
{
auto constDefinitions = parseDefinitions(tokens);
if (constDefinitions.valid)
@@ -339,19 +288,6 @@ in (!tokens.empty, "Expected block, got end of stream")
}
tokens.popFront;
}
if (tokens.front.ofType(Token.Type.var))
{
auto variableDeclarations = parseVariableDeclarations(tokens);
if (variableDeclarations.valid)
{
block.variableDeclarations = variableDeclarations.result;
}
else
{
return Result!Block(variableDeclarations.error.get);
}
tokens.popFront;
}
auto statement = parseStatement(tokens);
if (statement.valid)
{
@@ -365,7 +301,7 @@ in (!tokens.empty, "Expected block, got end of stream")
return Result!Block(block);
}
Result!Block parse(ref Array!Token tokenStream) @nogc
Result!Block parse(Token[] tokenStream) @nogc
{
auto tokens = tokenStream[];
return parseBlock(tokens);

45
source/elna/result.d
View File

@@ -7,6 +7,7 @@ import tanya.container.string;
/**
* Position in the source text.
*/
extern(C++, "elna")
struct Position
{
/// Line.
@@ -16,9 +17,10 @@ struct Position
size_t column = 1;
}
extern(C++, "elna")
struct CompileError
{
private string message_;
private const(char)* message_;
private Position position_;
@@ -29,29 +31,16 @@ struct CompileError
* message = Error text.
* position = Error position in the source text.
*/
this(string message, Position position) @nogc nothrow pure @safe
{
this.message_ = message;
this.position_ = position;
}
this(const(char)* message, const Position position) @nogc nothrow pure @safe;
/// Error text.
@property string message() const @nogc nothrow pure @safe
{
return this.message_;
}
@property const(char)* what() const @nogc nothrow pure @safe;
/// Error line in the source text.
@property size_t line() const @nogc nothrow pure @safe
{
return this.position_.line;
}
@property size_t line() const @nogc nothrow pure @safe;
/// Error column in the source text.
@property size_t column() const @nogc nothrow pure @safe
{
return this.position_.column;
}
@property size_t column() const @nogc nothrow pure @safe;
}
struct Result(T)
@@ -65,7 +54,7 @@ struct Result(T)
this.error = typeof(this.error).init;
}
this(string message, Position position)
this(const(char)* message, Position position)
{
this.result = T.init;
this.error = CompileError(message, position);
@@ -85,16 +74,18 @@ struct Result(T)
}
}
extern(C++, "elna")
enum Target
{
text,
high20,
lower12i
}
extern(C++, "elna")
struct Reference
{
enum Target
{
text,
high20,
lower12i
}
String name;
const(char)* name;
size_t offset;
Target target;
}

228
source/elna/riscv.d
View File

@@ -1,14 +1,12 @@
module elna.riscv;
import core.stdc.stdlib;
import elna.extended;
import elna.ir;
import elna.result;
import std.algorithm;
import std.typecons;
import tanya.container.array;
import tanya.container.string;
extern(C++, "elna")
enum XRegister : ubyte
{
zero = 0,
@@ -45,6 +43,7 @@ enum XRegister : ubyte
t6 = 31,
}
extern(C++, "elna")
enum Funct3 : ubyte
{
addi = 0b000,
@@ -92,18 +91,21 @@ enum Funct3 : ubyte
jalr = 0b000,
}
extern(C++, "elna")
enum Funct12 : ubyte
{
ecall = 0b000000000000,
ebreak = 0b000000000001,
}
extern(C++, "elna")
enum Funct7 : ubyte
{
none = 0,
sub = 0b0100000
}
extern(C++, "elna")
enum BaseOpcode : ubyte
{
opImm = 0b0010011,
@@ -119,243 +121,61 @@ enum BaseOpcode : ubyte
system = 0b1110011,
}
extern(C++, "elna")
struct Instruction
{
private uint instruction;
this(BaseOpcode opcode) @nogc
{
this.instruction = opcode;
}
this(BaseOpcode opcode) @nogc;
@disable this();
ref Instruction i(XRegister rd, Funct3 funct3, XRegister rs1, uint immediate)
return scope @nogc
{
this.instruction |= (rd << 7)
| (funct3 << 12)
| (rs1 << 15)
| (immediate << 20);
return this;
}
return scope @nogc;
ref Instruction s(uint imm1, Funct3 funct3, XRegister rs1, XRegister rs2)
return scope @nogc
{
this.instruction |= ((imm1 & 0b11111) << 7)
| (funct3 << 12)
| (rs1 << 15)
| (rs2 << 20)
| ((imm1 & 0b111111100000) << 20);
return this;
}
return scope @nogc;
ref Instruction r(XRegister rd, Funct3 funct3, XRegister rs1, XRegister rs2, Funct7 funct7 = Funct7.none)
return scope @nogc
{
this.instruction |= (rd << 7)
| (funct3 << 12)
| (rs1 << 15)
| (rs2 << 20)
| (funct7 << 25);
return this;
}
return scope @nogc;
ref Instruction u(XRegister rd, uint imm)
return scope @nogc
{
this.instruction |= (rd << 7) | (imm << 12);
return scope @nogc;
return this;
}
ubyte* encode() return scope @nogc
{
return cast(ubyte*) (&this.instruction);
}
ubyte* encode() return scope @nogc;
}
extern(C++, "elna")
class RiscVVisitor : IRVisitor
{
Array!Instruction instructions;
Instruction *instructions;
size_t instructionsLength;
bool registerInUse;
uint variableCounter = 1;
Array!Reference references;
Reference[3] references;
override void visit(Node) @nogc
{
}
override void visit(Definition definition) @nogc
{
const uint stackSize = cast(uint) (definition.statements.length * 4 + 12);
// Prologue.
this.instructions.insertBack(
Instruction(BaseOpcode.opImm)
.i(XRegister.sp, Funct3.addi, XRegister.sp, -stackSize)
);
this.instructions.insertBack(
Instruction(BaseOpcode.store)
.s(stackSize - 4, Funct3.sw, XRegister.sp, XRegister.s0)
);
this.instructions.insertBack(
Instruction(BaseOpcode.store)
.s(stackSize - 8, Funct3.sw, XRegister.sp, XRegister.ra)
);
this.instructions.insertBack(
Instruction(BaseOpcode.opImm)
.i(XRegister.s0, Funct3.addi, XRegister.sp, stackSize)
);
foreach (statement; definition.statements[])
{
statement.accept(this);
}
foreach (variableDeclaration; definition.variableDeclarations[])
{
variableDeclaration.accept(this);
}
this.registerInUse = true;
definition.result.accept(this);
this.registerInUse = false;
// Print the result.
this.instructions.insertBack(
Instruction(BaseOpcode.opImm)
.i(XRegister.a1, Funct3.addi, XRegister.a0, 0)
);
this.references.insertBack(Reference(String(".CL0"), instructions.length * 4, Reference.Target.high20));
this.instructions.insertBack(
Instruction(BaseOpcode.lui).u(XRegister.a5, 0)
);
this.references.insertBack(Reference(String(".CL0"), instructions.length * 4, Reference.Target.lower12i));
this.instructions.insertBack(
Instruction(BaseOpcode.opImm).i(XRegister.a0, Funct3.addi, XRegister.a5, 0)
);
this.references.insertBack(Reference(String("printf"), instructions.length * 4, Reference.Target.text));
this.instructions.insertBack(
Instruction(BaseOpcode.auipc).u(XRegister.ra, 0)
);
this.instructions.insertBack(
Instruction(BaseOpcode.jalr)
.i(XRegister.ra, Funct3.jalr, XRegister.ra, 0)
);
// Set the return value (0).
this.instructions.insertBack(
Instruction(BaseOpcode.op)
.r(XRegister.a0, Funct3.and, XRegister.zero, XRegister.zero)
);
// Epilogue.
this.instructions.insertBack(
Instruction(BaseOpcode.load)
.i(XRegister.s0, Funct3.lw, XRegister.sp, stackSize - 4)
);
this.instructions.insertBack(
Instruction(BaseOpcode.load)
.i(XRegister.ra, Funct3.lw, XRegister.sp, stackSize - 8)
);
this.instructions.insertBack(
Instruction(BaseOpcode.opImm)
.i(XRegister.sp, Funct3.addi, XRegister.sp, stackSize)
);
this.instructions.insertBack(
Instruction(BaseOpcode.jalr)
.i(XRegister.zero, Funct3.jalr, XRegister.ra, 0)
);
}
override void visit(Operand operand) @nogc
{
if ((cast(Variable) operand) !is null)
{
return (cast(Variable) operand).accept(this);
}
if ((cast(Number) operand) !is null)
{
return (cast(Number) operand).accept(this);
}
}
override void visit(Variable variable) @nogc
{
const freeRegister = this.registerInUse ? XRegister.a0 : XRegister.t0;
// movl -x(%rbp), %eax; where x is a number.
this.instructions.insertBack(
Instruction(BaseOpcode.load)
.i(freeRegister, Funct3.lw, XRegister.sp,
cast(byte) (variable.counter * 4))
);
}
override void visit(VariableDeclaration) @nogc
{
}
override void visit(Number number) @nogc
{
const freeRegister = this.registerInUse ? XRegister.a0 : XRegister.t0;
this.instructions.insertBack(
Instruction(BaseOpcode.opImm) // movl $x, %eax; where $x is a number.
.i(freeRegister, Funct3.addi, XRegister.zero, number.value)
);
}
override void visit(BinaryExpression expression) @nogc
{
this.registerInUse = true;
expression.lhs.accept(this);
this.registerInUse = false;
expression.rhs.accept(this);
// Calculate the result and assign it to a variable on the stack.
final switch (expression.operator)
{
case BinaryOperator.sum:
this.instructions.insertBack(
Instruction(BaseOpcode.op)
.r(XRegister.a0, Funct3.add, XRegister.a0, XRegister.t0)
);
break;
case BinaryOperator.subtraction:
this.instructions.insertBack(
Instruction(BaseOpcode.op)
.r(XRegister.a0, Funct3.sub, XRegister.a0, XRegister.t0, Funct7.sub)
);
break;
}
this.instructions.insertBack( // movl %eax, -x(%rbp); where x is a number.
Instruction(BaseOpcode.store)
.s(cast(uint) (this.variableCounter * 4), Funct3.sw, XRegister.sp, XRegister.a0)
);
++this.variableCounter;
}
override void visit(Node) @nogc;
override void visit(Definition definition) @nogc;
override void visit(Operand operand) @nogc;
override void visit(Variable variable) @nogc;
override void visit(Number number) @nogc;
override void visit(BinaryExpression expression) @nogc;
}
Symbol writeNext(Definition ast) @nogc
{
Array!Instruction instructions;
Array!Reference references;
auto visitor = cast(RiscVVisitor) malloc(__traits(classInstanceSize, RiscVVisitor));
(cast(void*) visitor)[0 .. __traits(classInstanceSize, RiscVVisitor)] = __traits(initSymbol, RiscVVisitor)[];
scope (exit)
{
visitor.__xdtor();
free(cast(void*) visitor);
}
visitor.visit(ast);
auto program = Symbol(String("main"));
program.symbols = move(visitor.references);
foreach (ref instruction; visitor.instructions)
program.symbols = Array!Reference(visitor.references[]);
foreach (ref instruction; visitor.instructions[0 .. visitor.instructionsLength])
{
program.text.insertBack(instruction.encode[0 .. uint.sizeof]);
}

53
source/ir.cpp Normal file
View File

@@ -0,0 +1,53 @@
#include "elna/ir.hpp"
namespace elna::ir
{
/**
* AST node.
*/
void Node::accept(IRVisitor *)
{
}
void Definition::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
void Operand::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
void Number::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
void Variable::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
BinaryExpression::BinaryExpression(Operand *lhs, Operand *rhs, BinaryOperator _operator)
{
this->lhs = lhs;
this->rhs = rhs;
this->_operator = _operator;
}
void BinaryExpression::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
BangExpression::BangExpression(Operand *operand)
{
this->operand = operand;
}
void BangExpression::accept(IRVisitor *visitor)
{
visitor->visit(this);
}
}

187
source/lexer.cpp
View File

@@ -14,18 +14,18 @@ namespace elna
source::const_iterator source::end() const
{
source_position end_position{ 0, 0 };
Position end_position{ 0, 0 };
return source::const_iterator(std::cend(m_buffer), end_position);
}
source::const_iterator::const_iterator(std::string::const_iterator buffer,
const source_position start_position)
const Position start_position)
: m_buffer(buffer), m_position(start_position)
{
}
const source_position& source::const_iterator::position() const noexcept
const Position& source::const_iterator::position() const noexcept
{
return this->m_position;
}
@@ -73,29 +73,109 @@ namespace elna
return !(*this == that);
}
token::token(const type of, source::const_iterator begin, source::const_iterator end)
: m_type(of), m_value(begin, end)
Token::Token(const Type of, const char *value, Position position)
: m_type(of), m_position(position)
{
std::size_t value_length = strlen(value);
char *buffer = reinterpret_cast<char *>(malloc(value_length + 1));
std::memcpy(buffer, value, value_length);
buffer[value_length] = 0;
m_value.identifier = buffer;
}
Token::Token(const Type of, std::int32_t number, Position position)
: m_type(of), m_position(position)
{
m_value.number = number;
}
Token::Token(const Type of, Position position)
: m_type(of), m_position(position)
{
}
token::type token::of() const noexcept
Token::Token(const Token& that)
: m_type(that.of()), m_position(that.position())
{
*this = that;
}
Token::Token(Token&& that)
: m_type(that.of()), m_position(that.position())
{
*this = std::move(that);
}
Token::~Token()
{
if (m_type == TOKEN_IDENTIFIER || m_type == TOKEN_OPERATOR)
{
std::free(const_cast<char*>(m_value.identifier));
}
}
Token& Token::operator=(const Token& that)
{
m_type = that.of();
m_position = that.position();
if (that.of() == TOKEN_IDENTIFIER || that.of() == TOKEN_OPERATOR)
{
std::size_t value_length = strlen(that.identifier());
char *buffer = reinterpret_cast<char *>(malloc(value_length + 1));
std::memcpy(buffer, that.identifier(), value_length);
buffer[value_length] = 0;
m_value.identifier = buffer;
}
else if (that.of() == TOKEN_NUMBER)
{
m_value.number = that.number();
}
return *this;
}
Token& Token::operator=(Token&& that)
{
m_type = that.of();
m_position = that.position();
if (that.of() == TOKEN_IDENTIFIER || that.of() == TOKEN_OPERATOR)
{
m_value.identifier = that.identifier();
that.m_value.identifier = nullptr;
}
else if (that.of() == TOKEN_NUMBER)
{
m_value.number = that.number();
}
return *this;
}
Token::Type Token::of() const noexcept
{
return m_type;
}
const token::value& token::identifier() const noexcept
const char *Token::identifier() const noexcept
{
return m_value;
return m_value.identifier;
}
const source_position& token::position() const noexcept
std::int32_t Token::number() const noexcept
{
return m_value.number;
}
const Position& Token::position() const noexcept
{
return m_position;
}
result<std::vector<token>> lex(const std::string& buffer)
Token *lex(const char *buffer, CompileError *compile_error, std::size_t *length)
{
std::vector<token> tokens;
std::vector<Token> tokens;
source input{ buffer };
for (auto iterator = input.begin(); iterator != input.end();)
@@ -103,23 +183,88 @@ namespace elna
if (*iterator == ' ' || *iterator == '\n')
{
}
else if (std::isgraph(*iterator))
else if (std::isdigit(*iterator))
{
auto current_position = iterator;
do
tokens.emplace_back(
Token::TOKEN_NUMBER,
static_cast<std::int32_t>(*iterator - '0'),
iterator.position()
);
}
else if (*iterator == '=')
{
tokens.emplace_back(Token::TOKEN_EQUALS, iterator.position());
}
else if (*iterator == '(')
{
tokens.emplace_back(Token::TOKEN_LEFT_PAREN, iterator.position());
}
else if (*iterator == ')')
{
tokens.emplace_back(Token::TOKEN_RIGHT_PAREN, iterator.position());
}
else if (*iterator == ';')
{
tokens.emplace_back(Token::TOKEN_SEMICOLON, iterator.position());
}
else if (*iterator == ',')
{
tokens.emplace_back(Token::TOKEN_COMMA, iterator.position());
}
else if (*iterator == '!')
{
tokens.emplace_back(Token::TOKEN_BANG, iterator.position());
}
else if (*iterator == '.')
{
tokens.emplace_back(Token::TOKEN_DOT, iterator.position());
}
else if (std::isalpha(*iterator))
{
std::string word;
auto i = iterator;
while (i != input.end() && std::isalpha(*i))
{
++current_position;
word.push_back(*i);
++i;
}
while (current_position != input.end() && std::isgraph(*current_position));
token new_token{ token::type::word, iterator, current_position };
tokens.push_back(new_token);
iterator = current_position;
if (word == "const")
{
tokens.emplace_back(Token::TOKEN_LET, iterator.position());
}
else if (word == "var")
{
tokens.emplace_back(Token::TOKEN_VAR, iterator.position());
}
else
{
tokens.emplace_back(Token::TOKEN_IDENTIFIER, word.c_str(), iterator.position());
}
iterator = i;
continue;
}
else if (*iterator == '+' || *iterator == '-')
{
std::string _operator{ *iterator };
tokens.emplace_back(Token::TOKEN_OPERATOR, _operator.c_str(), iterator.position());
}
else
{
*compile_error = CompileError("Unexpected next character", iterator.position());
return nullptr;
}
++iterator;
}
Token *target = reinterpret_cast<Token *>(malloc(tokens.size() * sizeof(Token) + sizeof(Token)));
int i = 0;
for (auto& token : tokens)
{
target[i] = std::move(token);
++i;
}
*length = i;
return tokens;
return target;
}
}

8
shell/result.cpp → source/result.cpp
View File

@@ -2,23 +2,23 @@
namespace elna
{
compile_error::compile_error(const char *message, const source_position position) noexcept
CompileError::CompileError(const char *message, const Position position) noexcept
{
this->message = message;
this->position = position;
}
char const *compile_error::what() const noexcept
char const *CompileError::what() const noexcept
{
return this->message;
}
std::size_t compile_error::line() const noexcept
std::size_t CompileError::line() const noexcept
{
return this->position.line;
}
std::size_t compile_error::column() const noexcept
std::size_t CompileError::column() const noexcept
{
return this->position.column;
}

191
source/riscv.cpp Normal file
View File

@@ -0,0 +1,191 @@
#include "elna/parser.hpp"
#include "elna/riscv.hpp"
#include <type_traits>
namespace elna
{
Instruction::Instruction(BaseOpcode opcode)
{
this->instruction = static_cast<std::underlying_type<BaseOpcode>::type>(opcode);
}
Instruction& Instruction::i(XRegister rd, Funct3 funct3, XRegister rs1, std::uint32_t immediate)
{
this->instruction |= (static_cast<std::underlying_type<XRegister>::type>(rd) << 7)
| (static_cast<std::underlying_type<Funct3>::type>(funct3) << 12)
| (static_cast<std::underlying_type<XRegister>::type>(rs1) << 15)
| (immediate << 20);
return *this;
}
Instruction& Instruction::s(std::uint32_t imm1, Funct3 funct3, XRegister rs1, XRegister rs2)
{
this->instruction |= ((imm1 & 0b11111) << 7)
| (static_cast<std::underlying_type<Funct3>::type>(funct3) << 12)
| (static_cast<std::underlying_type<XRegister>::type>(rs1) << 15)
| (static_cast<std::underlying_type<XRegister>::type>(rs2) << 20)
| ((imm1 & 0b111111100000) << 20);
return *this;
}
Instruction& Instruction::r(XRegister rd, Funct3 funct3, XRegister rs1, XRegister rs2, Funct7 funct7)
{
this->instruction |= (static_cast<std::underlying_type<XRegister>::type>(rd) << 7)
| (static_cast<std::underlying_type<Funct3>::type>(funct3) << 12)
| (static_cast<std::underlying_type<XRegister>::type>(rs1) << 15)
| (static_cast<std::underlying_type<XRegister>::type>(rs2) << 20)
| (static_cast<std::underlying_type<Funct7>::type>(funct7) << 25);
return *this;
}
Instruction& Instruction::u(XRegister rd, std::uint32_t imm)
{
this->instruction |= (static_cast<std::underlying_type<XRegister>::type>(rd) << 7) | (imm << 12);
return *this;
}
std::uint8_t *Instruction::encode()
{
return reinterpret_cast<std::uint8_t *>(&this->instruction);
}
void RiscVVisitor::visit(ir::Node *)
{
}
void RiscVVisitor::visit(ir::Definition *definition)
{
const uint stackSize = static_cast<std::uint32_t>(definition->statementsLength * 4 + 12);
this->instructionsLength += 4;
this->instructions = reinterpret_cast<Instruction *>(
realloc(this->instructions, this->instructionsLength * sizeof(Instruction)));
// Prologue.
this->instructions[instructionsLength - 4] = Instruction(BaseOpcode::opImm)
.i(XRegister::sp, Funct3::addi, XRegister::sp, -stackSize);
this->instructions[instructionsLength - 3] = Instruction(BaseOpcode::store)
.s(stackSize - 4, Funct3::sw, XRegister::sp, XRegister::s0);
this->instructions[instructionsLength - 2] = Instruction(BaseOpcode::store)
.s(stackSize - 8, Funct3::sw, XRegister::sp, XRegister::ra);
this->instructions[instructionsLength - 1] = Instruction(BaseOpcode::opImm)
.i(XRegister::s0, Funct3::addi, XRegister::sp, stackSize);
for (std::size_t i = 0; i < definition->statementsLength; ++i)
{
definition->statements[i]->accept(this);
}
this->registerInUse = true;
definition->result->accept(this);
this->registerInUse = false;
this->instructions = reinterpret_cast<Instruction*>(
realloc(this->instructions, (this->instructionsLength + 10) * sizeof(Instruction)));
// Print the result.
this->instructions[instructionsLength++] = Instruction(BaseOpcode::opImm)
.i(XRegister::a1, Funct3::addi, XRegister::a0, 0);
this->references[0] = Reference();
this->references[0].name = ".CL0";
this->references[0].offset = instructionsLength * 4;
this->references[0].target = Target::high20;
this->instructions[instructionsLength++] = Instruction(BaseOpcode::lui).u(XRegister::a5, 0);
this->references[1] = Reference();
this->references[1].name = ".CL0";
this->references[1].offset = instructionsLength * 4;
this->references[1].target = Target::lower12i;
this->instructions[instructionsLength++] = Instruction(BaseOpcode::opImm)
.i(XRegister::a0, Funct3::addi, XRegister::a5, 0);
this->references[2] = Reference();
this->references[2].name = "printf";
this->references[2].offset = instructionsLength * 4;
this->references[2].target = Target::text;
this->instructions[instructionsLength++] = Instruction(BaseOpcode::auipc).u(XRegister::ra, 0);
this->instructions[instructionsLength++] = Instruction(BaseOpcode::jalr)
.i(XRegister::ra, Funct3::jalr, XRegister::ra, 0);
// Set the return value (0).
this->instructions[instructionsLength++] = Instruction(BaseOpcode::op)
.r(XRegister::a0, Funct3::_and, XRegister::zero, XRegister::zero);
// Epilogue.
this->instructions[instructionsLength++] = Instruction(BaseOpcode::load)
.i(XRegister::s0, Funct3::lw, XRegister::sp, stackSize - 4);
this->instructions[instructionsLength++] = Instruction(BaseOpcode::load)
.i(XRegister::ra, Funct3::lw, XRegister::sp, stackSize - 8);
this->instructions[instructionsLength++] = Instruction(BaseOpcode::opImm)
.i(XRegister::sp, Funct3::addi, XRegister::sp, stackSize);
this->instructions[instructionsLength++] = Instruction(BaseOpcode::jalr)
.i(XRegister::zero, Funct3::jalr, XRegister::ra, 0);
}
void RiscVVisitor::visit(ir::Operand *operand)
{
if (dynamic_cast<ir::Variable *>(operand) != nullptr)
{
return dynamic_cast<ir::Variable *>(operand)->accept(this);
}
if (dynamic_cast<ir::Number *>(operand) != nullptr)
{
return dynamic_cast<ir::Number *>(operand)->accept(this);
}
}
void RiscVVisitor::visit(ir::Variable *variable)
{
const auto freeRegister = this->registerInUse ? XRegister::a0 : XRegister::t0;
++this->instructionsLength;
this->instructions = reinterpret_cast<Instruction *>(
realloc(this->instructions, this->instructionsLength * sizeof(Instruction)));
// movl -x(%rbp), %eax; where x is a number.
this->instructions[instructionsLength - 1] = Instruction(BaseOpcode::load)
.i(freeRegister, Funct3::lw, XRegister::sp,
static_cast<std::int8_t>(variable->counter * 4));
}
void RiscVVisitor::visit(ir::Number *number)
{
const auto freeRegister = this->registerInUse ? XRegister::a0 : XRegister::t0;
++this->instructionsLength;
this->instructions = reinterpret_cast<Instruction *>(
realloc(this->instructions, this->instructionsLength * sizeof(Instruction)));
this->instructions[this->instructionsLength - 1] =
Instruction(BaseOpcode::opImm) // movl $x, %eax; where $x is a number.
.i(freeRegister, Funct3::addi, XRegister::zero, number->value);
}
void RiscVVisitor::visit(ir::BinaryExpression *expression)
{
this->registerInUse = true;
expression->lhs->accept(this);
this->registerInUse = false;
expression->rhs->accept(this);
this->instructionsLength += 2;
this->instructions = reinterpret_cast<Instruction *>(
realloc(this->instructions, this->instructionsLength * sizeof(Instruction)));
// Calculate the result and assign it to a variable on the stack.
switch (expression->_operator)
{
case BinaryOperator::sum:
this->instructions[instructionsLength - 2] = Instruction(BaseOpcode::op)
.r(XRegister::a0, Funct3::add, XRegister::a0, XRegister::t0);
break;
case BinaryOperator::subtraction:
this->instructions[instructionsLength - 2] = Instruction(BaseOpcode::op)
.r(XRegister::a0, Funct3::sub, XRegister::a0, XRegister::t0, Funct7::sub);
break;
}
this->instructions[instructionsLength - 1] = // movl %eax, -x(%rbp); where x is a number.
Instruction(BaseOpcode::store)
.s(static_cast<std::uint32_t>(this->variableCounter * 4), Funct3::sw, XRegister::sp, XRegister::a0);
++this->variableCounter;
}
}