Website Summary Files Commits Branches @commit @diff @stats
path: root / spasm / src / asm / assembler.cpp
diff options
context:
space:
mode:
1 files changed, 212 insertions, 0 deletions
-rw-r--r--spasm/src/asm/assembler.cpp212
diff --git a/spasm/src/asm/assembler.cpp b/spasm/src/asm/assembler.cpp
new file mode 100644
index 0000000..1f69b1a
--- /dev/null
+++ b/spasm/src/asm/assembler.cpp
@@ -0,0 +1,212 @@
+#include <cassert>
+
+#include "assembler.hpp"
+#include "bytecode.hpp"
+#include "symbol.hpp"
+#include "tokenizer.hpp"
+
+namespace SpasmImpl
+{
+namespace ASM
+{
+Assembler::Assembler(Lexer::Tokenizer& tokenizer, Bytecode_Stream& bytecode)
+ : _tokenizer(&tokenizer), _bytecode(&bytecode)
+{
+}
+
+int get_arg_size(const Lexer::Token args[])
+{
+ int size = 0;
+ for (int i = 0; i < 3; ++i)
+ {
+ switch (args[i].type())
+ {
+ case Lexer::Token::Integer:
+ case Lexer::Token::XInteger:
+ {
+ if (args[i].value_int() > 0xffffffff)
+ {
+ size = std::max(size, 3);
+ }
+ else if (args[i].value_int() > 0xffff)
+ {
+ size = std::max(size, 2);
+ }
+ else if (args[i].value_int() > 0xff)
+ {
+ size = std::max(size, 1);
+ }
+ else if (args[i].value_int() < -0xffffffffLL)
+ {
+ size = std::max(size, 3);
+ }
+ else if (args[i].value_int() < -0xffff)
+ {
+ size = std::max(size, 2);
+ }
+ else if (args[i].value_int() < -0xff)
+ {
+ size = std::max(size, 1);
+ }
+ break;
+ }
+ case Lexer::Token::FloatingPoint:
+ {
+ size = std::max(size, 3);
+ break;
+ }
+ case Lexer::Token::StringValue:
+ {
+ const auto length = args[i].value_str().size();
+ if (length > 0xffffffff)
+ {
+ size = std::max(size, 3);
+ }
+ else if (length > 0xffff)
+ {
+ size = std::max(size, 2);
+ }
+ else if (length > 0xff)
+ {
+ size = std::max(size, 1);
+ }
+ break;
+ }
+ default:
+ break;
+ }
+ }
+ return size;
+}
+
+void Assembler::assemble()
+{
+ Lexer::Token token = _tokenizer->next_token();
+
+ while (token.type() != Lexer::Token::EndInput)
+ {
+ const auto type = token.type();
+ if (type >= Lexer::Token::_NotOpCodeBegin)
+ {
+ switch (token.type())
+ {
+ case Lexer::Token::Ident:
+ assemble_identifier(token);
+ break;
+ case Lexer::Token::Label:
+ token = _tokenizer->next_token();
+ assert(token.type() == Lexer::Token::Ident);
+ _symbols.define(token.value_str(), _bytecode->size());
+ break;
+ default:
+ break;
+ }
+ }
+ else
+ {
+ Lexer::Token args[3];
+ if (type >= Lexer::Token::_OneArgBegin)
+ {
+ args[0] = _tokenizer->next_token();
+ }
+ if (type >= Lexer::Token::_TwoArgBegin)
+ {
+ args[1] = _tokenizer->next_token();
+ }
+ if (type >= Lexer::Token::_ThreeArgBegin)
+ {
+ args[2] = _tokenizer->next_token();
+ }
+ const auto size = get_arg_size(args);
+ _bytecode->push_opcode(
+ (Bytecode_Stream::Opcode_t)((size << 6) | token.type()));
+ const auto arg_size = 1 << size;
+
+ if (args[0].type() != Lexer::Token::NotUsed)
+ {
+ if (type == Lexer::Token::Call || type == Lexer::Token::Jump)
+ {
+ assert(args[0].type() == Lexer::Token::Ident);
+ assemble_identifier(args[0]);
+ }
+ else
+ {
+ assert(args[0].type() == Lexer::Token::Integer);
+ _bytecode->push_integer(args[0].value_int(), arg_size);
+ }
+ }
+ if (args[1].type() != Lexer::Token::NotUsed)
+ {
+ if (type == Lexer::Token::JumpF || type == Lexer::Token::JumpT)
+ {
+ assert(args[1].type() == Lexer::Token::Ident);
+ assemble_identifier(args[1]);
+ }
+ else if (type == Lexer::Token::String)
+ {
+ assert(args[1].type() == Lexer::Token::StringValue);
+ const auto& s = args[1].value_str();
+ _bytecode->push_string(s.data(), s.size(), arg_size);
+ }
+ else
+ {
+ if (args[1].type() == Lexer::Token::Integer)
+ {
+ _bytecode->push_integer(args[1].value_int(), arg_size);
+ }
+ else if (args[1].type() == Lexer::Token::FloatingPoint)
+ {
+ _bytecode->push_double(args[1].value_double());
+ }
+ else
+ {
+ assert(false && "expected a number type");
+ }
+ }
+ }
+ if (args[2].type() != Lexer::Token::NotUsed)
+ {
+ assert(args[2].type() == Lexer::Token::Integer);
+ _bytecode->push_integer(args[2].value_int(), arg_size);
+ }
+ }
+
+ token = _tokenizer->next_token();
+ }
+
+ Symbol_Table::const_iterator i = _symbols.begin();
+ while (i != _symbols.end())
+ {
+ backpatch(i->second);
+ ++i;
+ }
+}
+
+void Assembler::backpatch(const Symbol* symbol)
+{
+ Symbol::Positions_t::const_iterator i = symbol->positions_begin();
+ while (i != symbol->positions_end())
+ {
+ _bytecode->set_location(*i, symbol->definition());
+ ++i;
+ }
+}
+
+void Assembler::assemble_identifier(const Lexer::Token& token)
+{
+ Symbol* symbol = _symbols.insert(token.value_str(), _bytecode->size());
+ _bytecode->push_location(symbol->definition());
+}
+
+bool compile(std::istream& istr, Bytecode_Stream& bytecode)
+{
+ Lexer::Tokenizer tokenizer(istr);
+ Assembler assembler(tokenizer, bytecode);
+
+ assembler.assemble();
+
+ return true;
+}
+
+} // namespace ASM
+} // namespace SpasmImpl