2014-05-26 09:22:19 +00:00
|
|
|
/*
|
|
|
|
This file is part of cpp-ethereum.
|
|
|
|
|
|
|
|
cpp-ethereum is free software: you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
cpp-ethereum is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
*/
|
|
|
|
/** @file CodeFragment.cpp
|
|
|
|
* @author Gav Wood <i@gavwood.com>
|
|
|
|
* @date 2014
|
|
|
|
*/
|
|
|
|
|
|
|
|
#include "CodeFragment.h"
|
|
|
|
|
|
|
|
#include <boost/algorithm/string.hpp>
|
2015-08-06 19:00:29 +00:00
|
|
|
#pragma warning(push)
|
|
|
|
#pragma GCC diagnostic push
|
|
|
|
#pragma GCC diagnostic ignored "-Wunused-parameter"
|
2014-05-26 09:22:19 +00:00
|
|
|
#include <boost/spirit/include/support_utree.hpp>
|
2015-08-06 19:00:29 +00:00
|
|
|
#pragma warning(pop)
|
|
|
|
#pragma GCC diagnostic pop
|
2014-10-07 21:07:56 +00:00
|
|
|
#include <libdevcore/CommonIO.h>
|
2016-04-01 20:11:01 +00:00
|
|
|
#include <libevmasm/Instruction.h>
|
2014-05-26 09:22:19 +00:00
|
|
|
#include "CompilerState.h"
|
2014-06-30 22:16:01 +00:00
|
|
|
#include "Parser.h"
|
2014-05-26 09:22:19 +00:00
|
|
|
using namespace std;
|
2014-09-05 15:09:58 +00:00
|
|
|
using namespace dev;
|
|
|
|
using namespace dev::eth;
|
2014-05-26 09:22:19 +00:00
|
|
|
namespace qi = boost::spirit::qi;
|
|
|
|
namespace px = boost::phoenix;
|
|
|
|
namespace sp = boost::spirit;
|
|
|
|
|
2014-06-30 22:16:01 +00:00
|
|
|
void CodeFragment::finalise(CompilerState const& _cs)
|
|
|
|
{
|
|
|
|
if (_cs.usedAlloc && _cs.vars.size() && !m_finalised)
|
|
|
|
{
|
|
|
|
m_finalised = true;
|
|
|
|
m_asm.injectStart(Instruction::MSTORE8);
|
|
|
|
m_asm.injectStart((u256)((_cs.vars.size() + 2) * 32) - 1);
|
|
|
|
m_asm.injectStart((u256)1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-05-26 09:22:19 +00:00
|
|
|
CodeFragment::CodeFragment(sp::utree const& _t, CompilerState& _s, bool _allowASM)
|
|
|
|
{
|
2016-10-15 11:58:57 +00:00
|
|
|
/*
|
|
|
|
std::cout << "CodeFragment. Locals:";
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _s.defs)
|
2016-10-15 11:58:57 +00:00
|
|
|
std::cout << i.first << ":" << i.second.m_asm.out();
|
|
|
|
std::cout << "Args:";
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _s.args)
|
2016-10-15 11:58:57 +00:00
|
|
|
std::cout << i.first << ":" << i.second.m_asm.out();
|
|
|
|
std::cout << "Outers:";
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _s.outers)
|
2016-10-15 11:58:57 +00:00
|
|
|
std::cout << i.first << ":" << i.second.m_asm.out();
|
|
|
|
debugOutAST(std::cout, _t);
|
|
|
|
std::cout << endl << flush;
|
2014-05-26 09:22:19 +00:00
|
|
|
*/
|
|
|
|
switch (_t.which())
|
|
|
|
{
|
|
|
|
case sp::utree_type::list_type:
|
|
|
|
constructOperation(_t, _s);
|
|
|
|
break;
|
|
|
|
case sp::utree_type::string_type:
|
|
|
|
{
|
|
|
|
auto sr = _t.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::string_type>>();
|
|
|
|
string s(sr.begin(), sr.end());
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(s);
|
2014-05-26 09:22:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
case sp::utree_type::symbol_type:
|
|
|
|
{
|
|
|
|
auto sr = _t.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::symbol_type>>();
|
|
|
|
string s(sr.begin(), sr.end());
|
|
|
|
string us = boost::algorithm::to_upper_copy(s);
|
2014-05-26 17:41:46 +00:00
|
|
|
if (_allowASM && c_instructions.count(us))
|
|
|
|
m_asm.append(c_instructions.at(us));
|
2014-08-21 14:14:12 +00:00
|
|
|
else if (_s.defs.count(s))
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(_s.defs.at(s).m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
else if (_s.args.count(s))
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(_s.args.at(s).m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
else if (_s.outers.count(s))
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(_s.outers.at(s).m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
else if (us.find_first_of("1234567890") != 0 && us.find_first_not_of("QWERTYUIOPASDFGHJKLZXCVBNM1234567890_") == string::npos)
|
|
|
|
{
|
|
|
|
auto it = _s.vars.find(s);
|
|
|
|
if (it == _s.vars.end())
|
|
|
|
{
|
|
|
|
bool ok;
|
2014-06-11 18:25:21 +00:00
|
|
|
tie(it, ok) = _s.vars.insert(make_pair(s, make_pair(_s.stackSize, 32)));
|
|
|
|
_s.stackSize += 32;
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
2014-06-11 18:25:21 +00:00
|
|
|
m_asm.append((u256)it->second.first);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
error<BareSymbol>();
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case sp::utree_type::any_type:
|
|
|
|
{
|
|
|
|
bigint i = *_t.get<bigint*>();
|
|
|
|
if (i < 0 || i > bigint(u256(0) - 1))
|
|
|
|
error<IntegerOutOfRange>();
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append((u256)i);
|
2014-05-26 09:22:19 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
default: break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CodeFragment::constructOperation(sp::utree const& _t, CompilerState& _s)
|
|
|
|
{
|
2014-05-26 18:09:15 +00:00
|
|
|
if (_t.tag() == 0 && _t.empty())
|
2014-05-26 09:22:19 +00:00
|
|
|
error<EmptyList>();
|
|
|
|
else if (_t.tag() == 0 && _t.front().which() != sp::utree_type::symbol_type)
|
|
|
|
error<DataNotExecutable>();
|
|
|
|
else
|
|
|
|
{
|
|
|
|
string s;
|
|
|
|
string us;
|
|
|
|
switch (_t.tag())
|
|
|
|
{
|
|
|
|
case 0:
|
|
|
|
{
|
|
|
|
auto sr = _t.front().get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::symbol_type>>();
|
|
|
|
s = string(sr.begin(), sr.end());
|
|
|
|
us = boost::algorithm::to_upper_copy(s);
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
case 1:
|
|
|
|
us = "MLOAD";
|
|
|
|
break;
|
|
|
|
case 2:
|
|
|
|
us = "SLOAD";
|
|
|
|
break;
|
|
|
|
case 3:
|
|
|
|
us = "MSTORE";
|
|
|
|
break;
|
|
|
|
case 4:
|
|
|
|
us = "SSTORE";
|
|
|
|
break;
|
|
|
|
case 5:
|
|
|
|
us = "SEQ";
|
|
|
|
break;
|
2014-07-06 02:23:13 +00:00
|
|
|
case 6:
|
|
|
|
us = "CALLDATALOAD";
|
|
|
|
break;
|
2014-05-26 09:22:19 +00:00
|
|
|
default:;
|
|
|
|
}
|
|
|
|
|
2014-06-11 18:25:21 +00:00
|
|
|
auto firstAsString = [&]()
|
|
|
|
{
|
|
|
|
auto i = *++_t.begin();
|
|
|
|
if (i.tag())
|
|
|
|
error<InvalidName>();
|
|
|
|
if (i.which() == sp::utree_type::string_type)
|
|
|
|
{
|
|
|
|
auto sr = i.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::string_type>>();
|
|
|
|
return string(sr.begin(), sr.end());
|
|
|
|
}
|
|
|
|
else if (i.which() == sp::utree_type::symbol_type)
|
|
|
|
{
|
|
|
|
auto sr = i.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::symbol_type>>();
|
|
|
|
return _s.getDef(string(sr.begin(), sr.end())).m_asm.backString();
|
|
|
|
}
|
|
|
|
return string();
|
|
|
|
};
|
|
|
|
|
|
|
|
auto varAddress = [&](string const& n)
|
|
|
|
{
|
|
|
|
auto it = _s.vars.find(n);
|
|
|
|
if (it == _s.vars.end())
|
|
|
|
{
|
|
|
|
bool ok;
|
|
|
|
tie(it, ok) = _s.vars.insert(make_pair(n, make_pair(_s.stackSize, 32)));
|
|
|
|
_s.stackSize += 32;
|
|
|
|
}
|
|
|
|
return it->second.first;
|
|
|
|
};
|
|
|
|
|
2014-05-26 09:22:19 +00:00
|
|
|
// Operations who args are not standard stack-pushers.
|
|
|
|
bool nonStandard = true;
|
|
|
|
if (us == "ASM")
|
|
|
|
{
|
|
|
|
int c = 0;
|
|
|
|
for (auto const& i: _t)
|
|
|
|
if (c++)
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(CodeFragment(i, _s, true).m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "INCLUDE")
|
|
|
|
{
|
|
|
|
if (_t.size() != 2)
|
|
|
|
error<IncorrectParameterCount>();
|
2015-06-16 12:58:03 +00:00
|
|
|
m_asm.append(CodeFragment::compile(contentsString(firstAsString()), _s).m_asm);
|
2014-06-11 18:25:21 +00:00
|
|
|
}
|
|
|
|
else if (us == "SET")
|
|
|
|
{
|
|
|
|
if (_t.size() != 3)
|
|
|
|
error<IncorrectParameterCount>();
|
|
|
|
int c = 0;
|
|
|
|
for (auto const& i: _t)
|
|
|
|
if (c++ == 2)
|
|
|
|
m_asm.append(CodeFragment(i, _s, false).m_asm);
|
|
|
|
m_asm.append((u256)varAddress(firstAsString()));
|
|
|
|
m_asm.append(Instruction::MSTORE);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
2014-06-11 18:25:21 +00:00
|
|
|
else if (us == "GET")
|
|
|
|
{
|
|
|
|
if (_t.size() != 2)
|
|
|
|
error<IncorrectParameterCount>();
|
|
|
|
m_asm.append((u256)varAddress(firstAsString()));
|
|
|
|
m_asm.append(Instruction::MLOAD);
|
|
|
|
}
|
|
|
|
else if (us == "REF")
|
|
|
|
m_asm.append((u256)varAddress(firstAsString()));
|
2014-05-26 09:22:19 +00:00
|
|
|
else if (us == "DEF")
|
|
|
|
{
|
|
|
|
string n;
|
|
|
|
unsigned ii = 0;
|
|
|
|
if (_t.size() != 3 && _t.size() != 4)
|
|
|
|
error<IncorrectParameterCount>();
|
2014-05-30 12:55:07 +00:00
|
|
|
vector<string> args;
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _t)
|
|
|
|
{
|
|
|
|
if (ii == 1)
|
|
|
|
{
|
|
|
|
if (i.tag())
|
|
|
|
error<InvalidName>();
|
|
|
|
if (i.which() == sp::utree_type::string_type)
|
|
|
|
{
|
|
|
|
auto sr = i.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::string_type>>();
|
|
|
|
n = string(sr.begin(), sr.end());
|
|
|
|
}
|
|
|
|
else if (i.which() == sp::utree_type::symbol_type)
|
|
|
|
{
|
|
|
|
auto sr = i.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::symbol_type>>();
|
2014-05-26 17:41:46 +00:00
|
|
|
n = _s.getDef(string(sr.begin(), sr.end())).m_asm.backString();
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ii == 2)
|
|
|
|
if (_t.size() == 3)
|
|
|
|
_s.defs[n] = CodeFragment(i, _s);
|
|
|
|
else
|
|
|
|
for (auto const& j: i)
|
|
|
|
{
|
|
|
|
if (j.tag() || j.which() != sp::utree_type::symbol_type)
|
|
|
|
error<InvalidMacroArgs>();
|
|
|
|
auto sr = j.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::symbol_type>>();
|
2014-05-30 12:55:07 +00:00
|
|
|
args.push_back(string(sr.begin(), sr.end()));
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (ii == 3)
|
|
|
|
{
|
2014-05-30 12:55:07 +00:00
|
|
|
auto k = make_pair(n, args.size());
|
|
|
|
_s.macros[k].code = i;
|
|
|
|
_s.macros[k].env = _s.outers;
|
|
|
|
_s.macros[k].args = args;
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _s.args)
|
2014-05-30 12:55:07 +00:00
|
|
|
_s.macros[k].env[i.first] = i.second;
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: _s.defs)
|
2014-05-30 12:55:07 +00:00
|
|
|
_s.macros[k].env[i.first] = i.second;
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
++ii;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (us == "LIT")
|
|
|
|
{
|
|
|
|
if (_t.size() < 3)
|
|
|
|
error<IncorrectParameterCount>();
|
|
|
|
unsigned ii = 0;
|
|
|
|
CodeFragment pos;
|
|
|
|
bytes data;
|
|
|
|
for (auto const& i: _t)
|
|
|
|
{
|
|
|
|
if (ii == 1)
|
|
|
|
{
|
|
|
|
pos = CodeFragment(i, _s);
|
2014-05-26 17:41:46 +00:00
|
|
|
if (pos.m_asm.deposit() != 1)
|
2014-05-26 09:22:19 +00:00
|
|
|
error<InvalidDeposit>();
|
|
|
|
}
|
|
|
|
else if (ii == 2 && !i.tag() && i.which() == sp::utree_type::string_type)
|
|
|
|
{
|
|
|
|
auto sr = i.get<sp::basic_string<boost::iterator_range<char const*>, sp::utree_type::string_type>>();
|
|
|
|
data = bytes((byte const*)sr.begin(), (byte const*)sr.end());
|
|
|
|
}
|
|
|
|
else if (ii >= 2 && !i.tag() && i.which() == sp::utree_type::any_type)
|
|
|
|
{
|
|
|
|
bigint bi = *i.get<bigint*>();
|
|
|
|
if (bi < 0)
|
|
|
|
error<IntegerOutOfRange>();
|
|
|
|
else if (bi > bigint(u256(0) - 1))
|
|
|
|
{
|
|
|
|
if (ii == 2 && _t.size() == 3)
|
|
|
|
{
|
|
|
|
// One big int - allow it as hex.
|
|
|
|
data.resize(bytesRequired(bi));
|
|
|
|
toBigEndian(bi, data);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
error<IntegerOutOfRange>();
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
data.resize(data.size() + 32);
|
|
|
|
*(h256*)(&data.back() - 31) = (u256)bi;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if (ii)
|
|
|
|
error<InvalidLiteral>();
|
|
|
|
++ii;
|
|
|
|
}
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append((u256)data.size());
|
2014-08-21 13:53:59 +00:00
|
|
|
m_asm.append(Instruction::DUP1);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(data);
|
|
|
|
m_asm.append(pos.m_asm, 1);
|
|
|
|
m_asm.append(Instruction::CODECOPY);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else
|
|
|
|
nonStandard = false;
|
|
|
|
|
|
|
|
if (nonStandard)
|
|
|
|
return;
|
|
|
|
|
|
|
|
std::map<std::string, Instruction> const c_arith = { { "+", Instruction::ADD }, { "-", Instruction::SUB }, { "*", Instruction::MUL }, { "/", Instruction::DIV }, { "%", Instruction::MOD }, { "&", Instruction::AND }, { "|", Instruction::OR }, { "^", Instruction::XOR } };
|
|
|
|
std::map<std::string, pair<Instruction, bool>> const c_binary = { { "<", { Instruction::LT, false } }, { "<=", { Instruction::GT, true } }, { ">", { Instruction::GT, false } }, { ">=", { Instruction::LT, true } }, { "S<", { Instruction::SLT, false } }, { "S<=", { Instruction::SGT, true } }, { "S>", { Instruction::SGT, false } }, { "S>=", { Instruction::SLT, true } }, { "=", { Instruction::EQ, false } }, { "!=", { Instruction::EQ, true } } };
|
2014-10-31 13:32:32 +00:00
|
|
|
std::map<std::string, Instruction> const c_unary = { { "!", Instruction::ISZERO } };
|
2014-05-26 09:22:19 +00:00
|
|
|
|
|
|
|
vector<CodeFragment> code;
|
|
|
|
CompilerState ns = _s;
|
|
|
|
ns.vars.clear();
|
2014-06-30 22:16:01 +00:00
|
|
|
ns.usedAlloc = false;
|
2014-05-26 09:22:19 +00:00
|
|
|
int c = _t.tag() ? 1 : 0;
|
|
|
|
for (auto const& i: _t)
|
|
|
|
if (c++)
|
|
|
|
{
|
|
|
|
if (us == "LLL" && c == 1)
|
|
|
|
code.push_back(CodeFragment(i, ns));
|
|
|
|
else
|
|
|
|
code.push_back(CodeFragment(i, _s));
|
|
|
|
}
|
|
|
|
auto requireSize = [&](unsigned s) { if (code.size() != s) error<IncorrectParameterCount>(); };
|
|
|
|
auto requireMinSize = [&](unsigned s) { if (code.size() < s) error<IncorrectParameterCount>(); };
|
|
|
|
auto requireMaxSize = [&](unsigned s) { if (code.size() > s) error<IncorrectParameterCount>(); };
|
2014-05-26 17:41:46 +00:00
|
|
|
auto requireDeposit = [&](unsigned i, int s) { if (code[i].m_asm.deposit() != s) error<InvalidDeposit>(); };
|
2014-05-26 09:22:19 +00:00
|
|
|
|
2014-05-30 12:55:07 +00:00
|
|
|
if (_s.macros.count(make_pair(s, code.size())))
|
2014-05-26 09:22:19 +00:00
|
|
|
{
|
2014-05-30 12:55:07 +00:00
|
|
|
Macro const& m = _s.macros.at(make_pair(s, code.size()));
|
2014-05-26 09:22:19 +00:00
|
|
|
CompilerState cs = _s;
|
|
|
|
for (auto const& i: m.env)
|
|
|
|
cs.outers[i.first] = i.second;
|
|
|
|
for (auto const& i: cs.defs)
|
|
|
|
cs.outers[i.first] = i.second;
|
|
|
|
cs.defs.clear();
|
|
|
|
for (unsigned i = 0; i < m.args.size(); ++i)
|
|
|
|
{
|
2014-06-12 17:35:39 +00:00
|
|
|
//requireDeposit(i, 1);
|
2014-05-26 09:22:19 +00:00
|
|
|
cs.args[m.args[i]] = code[i];
|
|
|
|
}
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(CodeFragment(m.code, cs).m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
for (auto const& i: cs.defs)
|
|
|
|
_s.defs[i.first] = i.second;
|
|
|
|
for (auto const& i: cs.macros)
|
|
|
|
_s.macros.insert(i);
|
|
|
|
}
|
|
|
|
else if (c_instructions.count(us))
|
|
|
|
{
|
|
|
|
auto it = c_instructions.find(us);
|
2016-04-04 11:27:09 +00:00
|
|
|
int ea = instructionInfo(it->second).args;
|
2014-05-26 09:22:19 +00:00
|
|
|
if (ea >= 0)
|
|
|
|
requireSize(ea);
|
|
|
|
else
|
|
|
|
requireMinSize(-ea);
|
|
|
|
|
|
|
|
for (unsigned i = code.size(); i; --i)
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[i - 1].m_asm, 1);
|
|
|
|
m_asm.append(it->second);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (c_arith.count(us))
|
|
|
|
{
|
|
|
|
auto it = c_arith.find(us);
|
|
|
|
requireMinSize(1);
|
|
|
|
for (unsigned i = code.size(); i; --i)
|
|
|
|
{
|
|
|
|
requireDeposit(i - 1, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[i - 1].m_asm, 1);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
for (unsigned i = 1; i < code.size(); ++i)
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(it->second);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (c_binary.count(us))
|
|
|
|
{
|
|
|
|
auto it = c_binary.find(us);
|
|
|
|
requireSize(2);
|
|
|
|
requireDeposit(0, 1);
|
|
|
|
requireDeposit(1, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[1].m_asm, 1);
|
|
|
|
m_asm.append(code[0].m_asm, 1);
|
|
|
|
m_asm.append(it->second.first);
|
2014-05-26 09:22:19 +00:00
|
|
|
if (it->second.second)
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (c_unary.count(us))
|
|
|
|
{
|
|
|
|
auto it = c_unary.find(us);
|
|
|
|
requireSize(1);
|
|
|
|
requireDeposit(0, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[0].m_asm, 1);
|
|
|
|
m_asm.append(it->second);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "IF")
|
|
|
|
{
|
|
|
|
requireSize(3);
|
|
|
|
requireDeposit(0, 1);
|
2014-05-26 18:09:15 +00:00
|
|
|
int minDep = min(code[1].m_asm.deposit(), code[2].m_asm.deposit());
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
m_asm.append(code[0].m_asm);
|
|
|
|
auto pos = m_asm.appendJumpI();
|
|
|
|
m_asm.onePath();
|
2014-05-26 18:09:15 +00:00
|
|
|
m_asm.append(code[2].m_asm, minDep);
|
2014-05-26 17:41:46 +00:00
|
|
|
auto end = m_asm.appendJump();
|
|
|
|
m_asm.otherPath();
|
2014-05-26 18:09:15 +00:00
|
|
|
m_asm << pos.tag();
|
|
|
|
m_asm.append(code[1].m_asm, minDep);
|
|
|
|
m_asm << end.tag();
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.donePaths();
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "WHEN" || us == "UNLESS")
|
|
|
|
{
|
|
|
|
requireSize(2);
|
|
|
|
requireDeposit(0, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
m_asm.append(code[0].m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
if (us == "WHEN")
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 17:41:46 +00:00
|
|
|
auto end = m_asm.appendJumpI();
|
|
|
|
m_asm.onePath();
|
|
|
|
m_asm.otherPath();
|
2014-05-29 21:21:51 +00:00
|
|
|
m_asm.append(code[1].m_asm, 0);
|
|
|
|
m_asm << end.tag();
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.donePaths();
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "WHILE")
|
|
|
|
{
|
|
|
|
requireSize(2);
|
|
|
|
requireDeposit(0, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
auto begin = m_asm.append();
|
|
|
|
m_asm.append(code[0].m_asm);
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 17:41:46 +00:00
|
|
|
auto end = m_asm.appendJumpI();
|
|
|
|
m_asm.append(code[1].m_asm, 0);
|
|
|
|
m_asm.appendJump(begin);
|
|
|
|
m_asm << end.tag();
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "FOR")
|
|
|
|
{
|
|
|
|
requireSize(4);
|
|
|
|
requireDeposit(1, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
m_asm.append(code[0].m_asm, 0);
|
|
|
|
auto begin = m_asm.append();
|
|
|
|
m_asm.append(code[1].m_asm);
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 17:41:46 +00:00
|
|
|
auto end = m_asm.appendJumpI();
|
|
|
|
m_asm.append(code[3].m_asm, 0);
|
|
|
|
m_asm.append(code[2].m_asm, 0);
|
|
|
|
m_asm.appendJump(begin);
|
|
|
|
m_asm << end.tag();
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
2014-06-30 22:16:01 +00:00
|
|
|
else if (us == "ALLOC")
|
|
|
|
{
|
|
|
|
requireSize(1);
|
|
|
|
requireDeposit(0, 1);
|
|
|
|
|
2014-07-09 15:05:07 +00:00
|
|
|
m_asm.append(Instruction::MSIZE);
|
2014-06-30 22:16:01 +00:00
|
|
|
m_asm.append(u256(0));
|
|
|
|
m_asm.append(u256(1));
|
|
|
|
m_asm.append(code[0].m_asm, 1);
|
2014-07-09 15:05:07 +00:00
|
|
|
m_asm.append(Instruction::MSIZE);
|
2014-06-30 22:16:01 +00:00
|
|
|
m_asm.append(Instruction::ADD);
|
|
|
|
m_asm.append(Instruction::SUB);
|
|
|
|
m_asm.append(Instruction::MSTORE8);
|
|
|
|
|
|
|
|
_s.usedAlloc = true;
|
|
|
|
}
|
2014-05-26 09:22:19 +00:00
|
|
|
else if (us == "LLL")
|
|
|
|
{
|
|
|
|
requireMinSize(2);
|
|
|
|
requireMaxSize(3);
|
|
|
|
requireDeposit(1, 1);
|
|
|
|
|
2014-07-27 11:09:36 +00:00
|
|
|
auto subPush = m_asm.appendSubSize(code[0].assembly(ns));
|
2014-08-21 13:53:59 +00:00
|
|
|
m_asm.append(Instruction::DUP1);
|
2014-05-26 09:22:19 +00:00
|
|
|
if (code.size() == 3)
|
|
|
|
{
|
|
|
|
requireDeposit(2, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[2].m_asm, 1);
|
|
|
|
m_asm.append(Instruction::LT);
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(Instruction::MUL);
|
2014-08-21 13:53:59 +00:00
|
|
|
m_asm.append(Instruction::DUP1);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
2014-07-27 11:09:36 +00:00
|
|
|
m_asm.append(subPush);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[1].m_asm, 1);
|
|
|
|
m_asm.append(Instruction::CODECOPY);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "&&" || us == "||")
|
|
|
|
{
|
|
|
|
requireMinSize(1);
|
|
|
|
for (unsigned i = 0; i < code.size(); ++i)
|
|
|
|
requireDeposit(i, 1);
|
|
|
|
|
2014-05-26 17:41:46 +00:00
|
|
|
auto end = m_asm.newTag();
|
2014-05-26 09:22:19 +00:00
|
|
|
if (code.size() > 1)
|
|
|
|
{
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append((u256)(us == "||" ? 1 : 0));
|
2014-05-26 09:22:19 +00:00
|
|
|
for (unsigned i = 1; i < code.size(); ++i)
|
|
|
|
{
|
|
|
|
// Check if true - predicate
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code[i - 1].m_asm, 1);
|
2014-05-26 09:22:19 +00:00
|
|
|
if (us == "&&")
|
2014-10-31 13:32:32 +00:00
|
|
|
m_asm.append(Instruction::ISZERO);
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.appendJumpI(end);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(Instruction::POP);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Check if true - predicate
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(code.back().m_asm, 1);
|
2014-05-26 09:22:19 +00:00
|
|
|
|
|
|
|
// At end now.
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(end);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "~")
|
|
|
|
{
|
|
|
|
requireSize(1);
|
|
|
|
requireDeposit(0, 1);
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
m_asm.append(code[0].m_asm, 1);
|
|
|
|
m_asm.append((u256)1);
|
|
|
|
m_asm.append((u256)0);
|
|
|
|
m_asm.append(Instruction::SUB);
|
|
|
|
m_asm.append(Instruction::SUB);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "SEQ")
|
|
|
|
{
|
|
|
|
unsigned ii = 0;
|
|
|
|
for (auto const& i: code)
|
|
|
|
if (++ii < code.size())
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(i.m_asm, 0);
|
2014-05-26 09:22:19 +00:00
|
|
|
else
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(i.m_asm);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us == "RAW")
|
|
|
|
{
|
|
|
|
for (auto const& i: code)
|
2014-05-26 17:41:46 +00:00
|
|
|
m_asm.append(i.m_asm);
|
|
|
|
m_asm.popTo(1);
|
2014-05-26 09:22:19 +00:00
|
|
|
}
|
|
|
|
else if (us.find_first_of("1234567890") != 0 && us.find_first_not_of("QWERTYUIOPASDFGHJKLZXCVBNM1234567890_") == string::npos)
|
2014-06-11 18:25:21 +00:00
|
|
|
m_asm.append((u256)varAddress(s));
|
2014-05-26 09:22:19 +00:00
|
|
|
else
|
|
|
|
error<InvalidOperation>();
|
|
|
|
}
|
|
|
|
}
|
2014-05-26 17:41:46 +00:00
|
|
|
|
|
|
|
CodeFragment CodeFragment::compile(string const& _src, CompilerState& _s)
|
|
|
|
{
|
|
|
|
CodeFragment ret;
|
|
|
|
sp::utree o;
|
|
|
|
parseTreeLLL(_src, o);
|
|
|
|
if (!o.empty())
|
|
|
|
ret = CodeFragment(o, _s);
|
|
|
|
_s.treesToKill.push_back(o);
|
|
|
|
return ret;
|
|
|
|
}
|