CJentzsch
10 years ago
117 changed files with 6935 additions and 2359 deletions
@ -1,46 +0,0 @@ |
|||
/*
|
|||
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 Manifest.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "Manifest.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
Manifest::Manifest(bytesConstRef _r) |
|||
{ |
|||
RLP r(_r); |
|||
from = r[0].toHash<Address>(); |
|||
to = r[1].toHash<Address>(); |
|||
value = r[2].toInt<u256>(); |
|||
altered = r[3].toVector<u256>(); |
|||
input = r[4].toBytes(); |
|||
output = r[5].toBytes(); |
|||
for (auto const& i: r[6]) |
|||
internal.emplace_back(i.data()); |
|||
} |
|||
|
|||
void Manifest::streamRLP(RLPStream& _s) const |
|||
{ |
|||
_s.appendList(7) << from << to << value << altered << input << output; |
|||
_s.appendList(internal.size()); |
|||
for (auto const& i: internal) |
|||
i.streamRLP(_s); |
|||
} |
|||
@ -1,73 +0,0 @@ |
|||
/*
|
|||
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 Manifest.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <iostream> |
|||
#include <sstream> |
|||
#include <libdevcore/RLP.h> |
|||
#include <libethcore/CommonEth.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
struct Manifest; |
|||
using Manifests = std::vector<Manifest>; |
|||
|
|||
/**
|
|||
* @brief A record of the state-interaction of a transaction/call/create. |
|||
*/ |
|||
struct Manifest |
|||
{ |
|||
Manifest() {} |
|||
Manifest(bytesConstRef _r); |
|||
void streamRLP(RLPStream& _s) const; |
|||
|
|||
h256 bloom() const { h256 ret = from.bloom() | to.bloom(); for (auto const& i: internal) ret |= i.bloom(); for (auto const& i: altered) ret |= h256(i).bloom(); return ret; } |
|||
|
|||
std::string toString(unsigned _indent = 0) const |
|||
{ |
|||
std::ostringstream oss; |
|||
oss << std::string(_indent * 3, ' ') << from << " -> " << to << " [" << value << "]: {"; |
|||
if (internal.size()) |
|||
{ |
|||
oss << std::endl; |
|||
for (auto const& m: internal) |
|||
oss << m.toString(_indent + 1) << std::endl; |
|||
oss << std::string(_indent * 3, ' '); |
|||
} |
|||
oss << "} I:" << toHex(input) << "; O:" << toHex(output); |
|||
return oss.str(); |
|||
} |
|||
|
|||
Address from; |
|||
Address to; |
|||
u256 value; |
|||
u256s altered; |
|||
bytes input; |
|||
bytes output; |
|||
Manifests internal; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -1,28 +0,0 @@ |
|||
/*
|
|||
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 PastMessage.cpp
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include "PastMessage.h" |
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::eth; |
|||
|
|||
#pragma GCC diagnostic ignored "-Wunused-variable" |
|||
namespace { char dummy; }; |
|||
@ -1,56 +0,0 @@ |
|||
/*
|
|||
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 PastMessage.h
|
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libdevcore/Common.h> |
|||
#include <libethcore/CommonEth.h> |
|||
#include "Manifest.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
struct PastMessage |
|||
{ |
|||
PastMessage(Manifest const& _m, std::vector<unsigned> _path, Address _o): to(_m.to), from(_m.from), value(_m.value), input(_m.input), output(_m.output), path(_path), origin(_o) {} |
|||
|
|||
PastMessage& polish(h256 _b, u256 _ts, unsigned _n, Address _coinbase) { block = _b; timestamp = _ts; number = _n; coinbase = _coinbase; return *this; } |
|||
|
|||
Address to; ///< The receiving address of the transaction. Address() in the case of a creation.
|
|||
Address from; ///< The receiving address of the transaction. Address() in the case of a creation.
|
|||
u256 value; ///< The value associated with the call.
|
|||
bytes input; ///< The data associated with the message, or the initialiser if it's a creation transaction.
|
|||
bytes output; ///< The data returned by the message, or the body code if it's a creation transaction.
|
|||
|
|||
std::vector<unsigned> path; ///< Call path into the block transaction. size() is always > 0. First item is the transaction index in the block.
|
|||
Address origin; ///< Originating sender of the transaction.
|
|||
Address coinbase; ///< Block coinbase.
|
|||
h256 block; ///< Block hash.
|
|||
u256 timestamp; ///< Block timestamp.
|
|||
unsigned number; ///< Block number.
|
|||
}; |
|||
|
|||
typedef std::vector<PastMessage> PastMessages; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,55 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
#pragma once |
|||
|
|||
#include <memory> |
|||
#include <libdevcore/Exceptions.h> |
|||
#include "ExtVMFace.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
struct VMException: virtual Exception {}; |
|||
struct StepsDone: virtual VMException {}; |
|||
struct BreakPointHit: virtual VMException {}; |
|||
struct BadInstruction: virtual VMException {}; |
|||
struct BadJumpDestination: virtual VMException {}; |
|||
struct OutOfGas: virtual VMException {}; |
|||
struct StackTooSmall: virtual VMException {}; |
|||
|
|||
/// EVM Virtual Machine interface
|
|||
class VMFace |
|||
{ |
|||
public: |
|||
explicit VMFace(u256 _gas): m_gas(_gas) {} |
|||
virtual ~VMFace() = default; |
|||
VMFace(VMFace const&) = delete; |
|||
void operator=(VMFace const&) = delete; |
|||
|
|||
virtual void reset(u256 _gas = 0) noexcept { m_gas = _gas; } |
|||
u256 gas() const noexcept { return m_gas; } |
|||
|
|||
virtual bytesConstRef go(ExtVMFace& _ext, OnOpFunc const& _onOp = {}, uint64_t _steps = (uint64_t)-1) = 0; |
|||
|
|||
protected: |
|||
u256 m_gas = 0; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,42 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
|
|||
#include "VMFactory.h" |
|||
#include "VM.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
namespace |
|||
{ |
|||
VMKind g_kind = VMKind::Interpreter; |
|||
} |
|||
|
|||
void VMFactory::setKind(VMKind _kind) |
|||
{ |
|||
g_kind = _kind; |
|||
} |
|||
|
|||
std::unique_ptr<VMFace> VMFactory::create(u256 _gas) |
|||
{ |
|||
asserts(g_kind == VMKind::Interpreter && "Only interpreter supported for now"); |
|||
return std::unique_ptr<VMFace>(new VM(_gas)); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,42 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
#pragma once |
|||
|
|||
#include "VMFace.h" |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace eth |
|||
{ |
|||
|
|||
enum class VMKind: bool |
|||
{ |
|||
Interpreter, |
|||
JIT |
|||
}; |
|||
|
|||
class VMFactory |
|||
{ |
|||
public: |
|||
VMFactory() = delete; |
|||
|
|||
static std::unique_ptr<VMFace> create(u256 _gas); |
|||
static void setKind(VMKind _kind); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,187 @@ |
|||
/*
|
|||
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 Network.cpp
|
|||
* @author Alex Leverington <nessence@gmail.com> |
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @author Eric Lombrozo <elombrozo@gmail.com> (Windows version of getInterfaceAddresses()) |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#include <sys/types.h> |
|||
#ifndef _WIN32 |
|||
#include <ifaddrs.h> |
|||
#endif |
|||
|
|||
#include <boost/algorithm/string.hpp> |
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcore/CommonIO.h> |
|||
#include <libethcore/Exceptions.h> |
|||
#include "Common.h" |
|||
#include "UPnP.h" |
|||
#include "Network.h" |
|||
|
|||
using namespace std; |
|||
using namespace dev; |
|||
using namespace dev::p2p; |
|||
|
|||
std::vector<bi::address> Network::getInterfaceAddresses() |
|||
{ |
|||
std::vector<bi::address> addresses; |
|||
|
|||
#ifdef _WIN32 |
|||
WSAData wsaData; |
|||
if (WSAStartup(MAKEWORD(1, 1), &wsaData) != 0) |
|||
BOOST_THROW_EXCEPTION(NoNetworking()); |
|||
|
|||
char ac[80]; |
|||
if (gethostname(ac, sizeof(ac)) == SOCKET_ERROR) |
|||
{ |
|||
clog(NetWarn) << "Error " << WSAGetLastError() << " when getting local host name."; |
|||
WSACleanup(); |
|||
BOOST_THROW_EXCEPTION(NoNetworking()); |
|||
} |
|||
|
|||
struct hostent* phe = gethostbyname(ac); |
|||
if (phe == 0) |
|||
{ |
|||
clog(NetWarn) << "Bad host lookup."; |
|||
WSACleanup(); |
|||
BOOST_THROW_EXCEPTION(NoNetworking()); |
|||
} |
|||
|
|||
for (int i = 0; phe->h_addr_list[i] != 0; ++i) |
|||
{ |
|||
struct in_addr addr; |
|||
memcpy(&addr, phe->h_addr_list[i], sizeof(struct in_addr)); |
|||
char *addrStr = inet_ntoa(addr); |
|||
bi::address address(bi::address::from_string(addrStr)); |
|||
if (!isLocalHostAddress(address)) |
|||
addresses.push_back(address.to_v4()); |
|||
} |
|||
|
|||
WSACleanup(); |
|||
#else |
|||
ifaddrs* ifaddr; |
|||
if (getifaddrs(&ifaddr) == -1) |
|||
BOOST_THROW_EXCEPTION(NoNetworking()); |
|||
|
|||
for (auto ifa = ifaddr; ifa != NULL; ifa = ifa->ifa_next) |
|||
{ |
|||
if (!ifa->ifa_addr || string(ifa->ifa_name) == "lo0") |
|||
continue; |
|||
|
|||
if (ifa->ifa_addr->sa_family == AF_INET) |
|||
{ |
|||
in_addr addr = ((struct sockaddr_in *)ifa->ifa_addr)->sin_addr; |
|||
boost::asio::ip::address_v4 address(boost::asio::detail::socket_ops::network_to_host_long(addr.s_addr)); |
|||
if (!isLocalHostAddress(address)) |
|||
addresses.push_back(address); |
|||
} |
|||
else if (ifa->ifa_addr->sa_family == AF_INET6) |
|||
{ |
|||
sockaddr_in6* sockaddr = ((struct sockaddr_in6 *)ifa->ifa_addr); |
|||
in6_addr addr = sockaddr->sin6_addr; |
|||
boost::asio::ip::address_v6::bytes_type bytes; |
|||
memcpy(&bytes[0], addr.s6_addr, 16); |
|||
boost::asio::ip::address_v6 address(bytes, sockaddr->sin6_scope_id); |
|||
if (!isLocalHostAddress(address)) |
|||
addresses.push_back(address); |
|||
} |
|||
} |
|||
|
|||
if (ifaddr!=NULL) |
|||
freeifaddrs(ifaddr); |
|||
|
|||
#endif |
|||
|
|||
return std::move(addresses); |
|||
} |
|||
|
|||
int Network::listen4(bi::tcp::acceptor& _acceptor, unsigned short _listenPort) |
|||
{ |
|||
int retport = -1; |
|||
for (unsigned i = 0; i < 2; ++i) |
|||
{ |
|||
// try to connect w/listenPort, else attempt net-allocated port
|
|||
bi::tcp::endpoint endpoint(bi::tcp::v4(), i ? 0 : _listenPort); |
|||
try |
|||
{ |
|||
_acceptor.open(endpoint.protocol()); |
|||
_acceptor.set_option(ba::socket_base::reuse_address(true)); |
|||
_acceptor.bind(endpoint); |
|||
_acceptor.listen(); |
|||
retport = _acceptor.local_endpoint().port(); |
|||
break; |
|||
} |
|||
catch (...) |
|||
{ |
|||
if (i) |
|||
{ |
|||
// both attempts failed
|
|||
cwarn << "Couldn't start accepting connections on host. Something very wrong with network?\n" << boost::current_exception_diagnostic_information(); |
|||
} |
|||
|
|||
// first attempt failed
|
|||
_acceptor.close(); |
|||
continue; |
|||
} |
|||
} |
|||
return retport; |
|||
} |
|||
|
|||
bi::tcp::endpoint Network::traverseNAT(std::vector<bi::address> const& _ifAddresses, unsigned short _listenPort, bi::address& o_upnpifaddr) |
|||
{ |
|||
asserts(_listenPort != 0); |
|||
|
|||
UPnP* upnp = nullptr; |
|||
try |
|||
{ |
|||
upnp = new UPnP; |
|||
} |
|||
// let m_upnp continue as null - we handle it properly.
|
|||
catch (NoUPnPDevice) {} |
|||
|
|||
bi::tcp::endpoint upnpep; |
|||
if (upnp && upnp->isValid()) |
|||
{ |
|||
bi::address paddr; |
|||
int extPort = 0; |
|||
for (auto const& addr: _ifAddresses) |
|||
if (addr.is_v4() && isPrivateAddress(addr) && (extPort = upnp->addRedirect(addr.to_string().c_str(), _listenPort))) |
|||
{ |
|||
paddr = addr; |
|||
break; |
|||
} |
|||
|
|||
auto eip = upnp->externalIP(); |
|||
bi::address eipaddr(bi::address::from_string(eip)); |
|||
if (extPort && eip != string("0.0.0.0") && !isPrivateAddress(eipaddr)) |
|||
{ |
|||
clog(NetNote) << "Punched through NAT and mapped local port" << _listenPort << "onto external port" << extPort << "."; |
|||
clog(NetNote) << "External addr:" << eip; |
|||
o_upnpifaddr = paddr; |
|||
upnpep = bi::tcp::endpoint(eipaddr, (unsigned short)extPort); |
|||
} |
|||
else |
|||
clog(NetWarn) << "Couldn't punch through NAT (or no NAT in place)."; |
|||
|
|||
if (upnp) |
|||
delete upnp; |
|||
} |
|||
|
|||
return upnpep; |
|||
} |
|||
@ -0,0 +1,63 @@ |
|||
/*
|
|||
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 Network.h
|
|||
* @author Alex Leverington <nessence@gmail.com> |
|||
* @author Gav Wood <i@gavwood.com> |
|||
* @date 2014 |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <vector> |
|||
namespace ba = boost::asio; |
|||
namespace bi = ba::ip; |
|||
|
|||
namespace dev |
|||
{ |
|||
|
|||
namespace p2p |
|||
{ |
|||
|
|||
struct NetworkPreferences |
|||
{ |
|||
NetworkPreferences(unsigned short p = 30303, std::string i = std::string(), bool u = true, bool l = false): listenPort(p), publicIP(i), upnp(u), localNetworking(l) {} |
|||
|
|||
unsigned short listenPort = 30303; |
|||
std::string publicIP; |
|||
bool upnp = true; |
|||
bool localNetworking = false; |
|||
}; |
|||
|
|||
/**
|
|||
* @brief Network Class |
|||
* Static network operations and interface(s). |
|||
*/ |
|||
class Network |
|||
{ |
|||
public: |
|||
/// @returns public and private interface addresses
|
|||
static std::vector<bi::address> getInterfaceAddresses(); |
|||
|
|||
/// Try to bind and listen on _listenPort, else attempt net-allocated port.
|
|||
static int listen4(bi::tcp::acceptor& _acceptor, unsigned short _listenPort); |
|||
|
|||
/// Return public endpoint of upnp interface. If successful o_upnpifaddr will be a private interface address and endpoint will contain public address and port.
|
|||
static bi::tcp::endpoint traverseNAT(std::vector<bi::address> const& _ifAddresses, unsigned short _listenPort, bi::address& o_upnpifaddr); |
|||
}; |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,493 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2014 |
|||
* Implementation of the accept functions of AST nodes, included by AST.cpp to not clutter that |
|||
* file with these mechanical implementations. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/ASTVisitor.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
void SourceUnit::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_nodes, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void SourceUnit::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_nodes, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ImportDirective::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ImportDirective::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ContractDefinition::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
listAccept(m_definedStructs, _visitor); |
|||
listAccept(m_stateVariables, _visitor); |
|||
listAccept(m_definedFunctions, _visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ContractDefinition::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
listAccept(m_definedStructs, _visitor); |
|||
listAccept(m_stateVariables, _visitor); |
|||
listAccept(m_definedFunctions, _visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void StructDefinition::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_members, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void StructDefinition::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_members, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void StructDefinition::checkValidityOfMembers() const |
|||
{ |
|||
checkMemberTypes(); |
|||
checkRecursion(); |
|||
} |
|||
|
|||
void ParameterList::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_parameters, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ParameterList::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_parameters, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void FunctionDefinition::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_parameters->accept(_visitor); |
|||
if (m_returnParameters) |
|||
m_returnParameters->accept(_visitor); |
|||
m_body->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void FunctionDefinition::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_parameters->accept(_visitor); |
|||
if (m_returnParameters) |
|||
m_returnParameters->accept(_visitor); |
|||
m_body->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void VariableDeclaration::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_typeName) |
|||
m_typeName->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void VariableDeclaration::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_typeName) |
|||
m_typeName->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void TypeName::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void TypeName::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ElementaryTypeName::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ElementaryTypeName::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void UserDefinedTypeName::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void UserDefinedTypeName::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Mapping::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_keyType->accept(_visitor); |
|||
m_valueType->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Mapping::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_keyType->accept(_visitor); |
|||
m_valueType->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Block::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_statements, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Block::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
listAccept(m_statements, _visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void IfStatement::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_condition->accept(_visitor); |
|||
m_trueBody->accept(_visitor); |
|||
if (m_falseBody) |
|||
m_falseBody->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void IfStatement::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_condition->accept(_visitor); |
|||
m_trueBody->accept(_visitor); |
|||
if (m_falseBody) |
|||
m_falseBody->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void WhileStatement::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_condition->accept(_visitor); |
|||
m_body->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void WhileStatement::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_condition->accept(_visitor); |
|||
m_body->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Continue::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Continue::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Break::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Break::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Return::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_expression) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Return::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_expression) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ExpressionStatement::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_expression) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ExpressionStatement::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
if (m_expression) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void VariableDefinition::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_variable->accept(_visitor); |
|||
if (m_value) |
|||
m_value->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void VariableDefinition::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_variable->accept(_visitor); |
|||
if (m_value) |
|||
m_value->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Assignment::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_leftHandSide->accept(_visitor); |
|||
m_rightHandSide->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Assignment::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_leftHandSide->accept(_visitor); |
|||
m_rightHandSide->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void UnaryOperation::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
m_subExpression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void UnaryOperation::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
m_subExpression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void BinaryOperation::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_left->accept(_visitor); |
|||
m_right->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void BinaryOperation::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_left->accept(_visitor); |
|||
m_right->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void FunctionCall::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_expression->accept(_visitor); |
|||
listAccept(m_arguments, _visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void FunctionCall::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_expression->accept(_visitor); |
|||
listAccept(m_arguments, _visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void MemberAccess::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void MemberAccess::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
m_expression->accept(_visitor); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void IndexAccess::accept(ASTVisitor& _visitor) |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_base->accept(_visitor); |
|||
m_index->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void IndexAccess::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
if (_visitor.visit(*this)) |
|||
{ |
|||
m_base->accept(_visitor); |
|||
m_index->accept(_visitor); |
|||
} |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Identifier::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Identifier::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ElementaryTypeNameExpression::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void ElementaryTypeNameExpression::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Literal::accept(ASTVisitor& _visitor) |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
void Literal::accept(ASTConstVisitor& _visitor) const |
|||
{ |
|||
_visitor.visit(*this); |
|||
_visitor.endVisit(*this); |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,111 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2014 |
|||
* Routines used by both the compiler and the expression compiler. |
|||
*/ |
|||
|
|||
#include <libsolidity/CompilerUtils.h> |
|||
#include <libsolidity/AST.h> |
|||
#include <libevmcore/Instruction.h> |
|||
|
|||
using namespace std; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
void CompilerUtils::loadFromMemory(unsigned _offset, unsigned _bytes, bool _leftAligned, bool _fromCalldata) |
|||
{ |
|||
if (_bytes == 0) |
|||
{ |
|||
m_context << u256(0); |
|||
return; |
|||
} |
|||
eth::Instruction load = _fromCalldata ? eth::Instruction::CALLDATALOAD : eth::Instruction::MLOAD; |
|||
if (asserts(_bytes <= 32)) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Memory load of more than 32 bytes requested.")); |
|||
if (_bytes == 32) |
|||
m_context << u256(_offset) << load; |
|||
else |
|||
{ |
|||
// load data and add leading or trailing zeros by dividing/multiplying depending on alignment
|
|||
u256 shiftFactor = u256(1) << ((32 - _bytes) * 8); |
|||
m_context << shiftFactor; |
|||
if (_leftAligned) |
|||
m_context << eth::Instruction::DUP1; |
|||
m_context << u256(_offset) << load << eth::Instruction::DIV; |
|||
if (_leftAligned) |
|||
m_context << eth::Instruction::MUL; |
|||
} |
|||
} |
|||
|
|||
void CompilerUtils::storeInMemory(unsigned _offset, unsigned _bytes, bool _leftAligned) |
|||
{ |
|||
if (_bytes == 0) |
|||
{ |
|||
m_context << eth::Instruction::POP; |
|||
return; |
|||
} |
|||
if (asserts(_bytes <= 32)) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Memory store of more than 32 bytes requested.")); |
|||
if (_bytes != 32 && !_leftAligned) |
|||
// shift the value accordingly before storing
|
|||
m_context << (u256(1) << ((32 - _bytes) * 8)) << eth::Instruction::MUL; |
|||
m_context << u256(_offset) << eth::Instruction::MSTORE; |
|||
} |
|||
|
|||
void CompilerUtils::moveToStackVariable(VariableDeclaration const& _variable) |
|||
{ |
|||
unsigned const stackPosition = m_context.baseToCurrentStackOffset(m_context.getBaseStackOffsetOfVariable(_variable)); |
|||
unsigned const size = _variable.getType()->getSizeOnStack(); |
|||
// move variable starting from its top end in the stack
|
|||
if (stackPosition - size + 1 > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_sourceLocation(_variable.getLocation()) |
|||
<< errinfo_comment("Stack too deep.")); |
|||
for (unsigned i = 0; i < size; ++i) |
|||
m_context << eth::swapInstruction(stackPosition - size + 1) << eth::Instruction::POP; |
|||
} |
|||
|
|||
void CompilerUtils::copyToStackTop(unsigned _stackDepth, Type const& _type) |
|||
{ |
|||
if (_stackDepth > 16) |
|||
BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Stack too deep.")); |
|||
unsigned const size = _type.getSizeOnStack(); |
|||
for (unsigned i = 0; i < size; ++i) |
|||
m_context << eth::dupInstruction(_stackDepth); |
|||
} |
|||
|
|||
void CompilerUtils::popStackElement(Type const& _type) |
|||
{ |
|||
unsigned const size = _type.getSizeOnStack(); |
|||
for (unsigned i = 0; i < size; ++i) |
|||
m_context << eth::Instruction::POP; |
|||
} |
|||
|
|||
unsigned CompilerUtils::getSizeOnStack(vector<shared_ptr<Type const>> const& _variableTypes) |
|||
{ |
|||
unsigned size = 0; |
|||
for (shared_ptr<Type const> const& type: _variableTypes) |
|||
size += type->getSizeOnStack(); |
|||
return size; |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,75 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Christian <c@ethdev.com> |
|||
* @date 2014 |
|||
* Routines used by both the compiler and the expression compiler. |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <libsolidity/CompilerContext.h> |
|||
#include <libsolidity/ASTForward.h> |
|||
|
|||
namespace dev { |
|||
namespace solidity { |
|||
|
|||
class Type; // forward
|
|||
|
|||
class CompilerUtils |
|||
{ |
|||
public: |
|||
CompilerUtils(CompilerContext& _context): m_context(_context) {} |
|||
|
|||
/// Loads data from memory to the stack.
|
|||
/// @param _offset offset in memory (or calldata)
|
|||
/// @param _bytes number of bytes to load
|
|||
/// @param _leftAligned if true, store left aligned on stack (otherwise right aligned)
|
|||
/// @param _fromCalldata if true, load from calldata, not from memory
|
|||
void loadFromMemory(unsigned _offset, unsigned _bytes = 32, bool _leftAligned = false, bool _fromCalldata = false); |
|||
/// Stores data from stack in memory.
|
|||
/// @param _offset offset in memory
|
|||
/// @param _bytes number of bytes to store
|
|||
/// @param _leftAligned if true, data is left aligned on stack (otherwise right aligned)
|
|||
void storeInMemory(unsigned _offset, unsigned _bytes = 32, bool _leftAligned = false); |
|||
|
|||
/// Moves the value that is at the top of the stack to a stack variable.
|
|||
void moveToStackVariable(VariableDeclaration const& _variable); |
|||
/// Copies a variable of type @a _type from a stack depth of @a _stackDepth to the top of the stack.
|
|||
void copyToStackTop(unsigned _stackDepth, Type const& _type); |
|||
/// Removes the current value from the top of the stack.
|
|||
void popStackElement(Type const& _type); |
|||
|
|||
template <class T> |
|||
static unsigned getSizeOnStack(std::vector<T> const& _variables); |
|||
static unsigned getSizeOnStack(std::vector<std::shared_ptr<Type const>> const& _variableTypes); |
|||
|
|||
private: |
|||
CompilerContext& m_context; |
|||
}; |
|||
|
|||
template <class T> |
|||
unsigned CompilerUtils::getSizeOnStack(std::vector<T> const& _variables) |
|||
{ |
|||
unsigned size = 0; |
|||
for (T const& variable: _variables) |
|||
size += variable->getType()->getSizeOnStack(); |
|||
return size; |
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,340 @@ |
|||
|
|||
#include <libsolidity/InterfaceHandler.h> |
|||
#include <libsolidity/AST.h> |
|||
#include <libsolidity/CompilerStack.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
/* -- public -- */ |
|||
|
|||
InterfaceHandler::InterfaceHandler() |
|||
{ |
|||
m_lastTag = DocTagType::NONE; |
|||
} |
|||
|
|||
std::unique_ptr<std::string> InterfaceHandler::getDocumentation(ContractDefinition& _contractDef, |
|||
DocumentationType _type) |
|||
{ |
|||
switch(_type) |
|||
{ |
|||
case DocumentationType::NATSPEC_USER: |
|||
return getUserDocumentation(_contractDef); |
|||
case DocumentationType::NATSPEC_DEV: |
|||
return getDevDocumentation(_contractDef); |
|||
case DocumentationType::ABI_INTERFACE: |
|||
return getABIInterface(_contractDef); |
|||
} |
|||
|
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation type")); |
|||
return nullptr; |
|||
} |
|||
|
|||
std::unique_ptr<std::string> InterfaceHandler::getABIInterface(ContractDefinition& _contractDef) |
|||
{ |
|||
Json::Value methods(Json::arrayValue); |
|||
|
|||
for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions()) |
|||
{ |
|||
Json::Value method; |
|||
Json::Value inputs(Json::arrayValue); |
|||
Json::Value outputs(Json::arrayValue); |
|||
|
|||
auto populateParameters = [](std::vector<ASTPointer<VariableDeclaration>> const& _vars) |
|||
{ |
|||
Json::Value params(Json::arrayValue); |
|||
for (ASTPointer<VariableDeclaration> const& var: _vars) |
|||
{ |
|||
Json::Value input; |
|||
input["name"] = var->getName(); |
|||
input["type"] = var->getType()->toString(); |
|||
params.append(input); |
|||
} |
|||
return params; |
|||
}; |
|||
|
|||
method["name"] = f->getName(); |
|||
method["inputs"] = populateParameters(f->getParameters()); |
|||
method["outputs"] = populateParameters(f->getReturnParameters()); |
|||
methods.append(method); |
|||
} |
|||
return std::unique_ptr<std::string>(new std::string(m_writer.write(methods))); |
|||
} |
|||
|
|||
std::unique_ptr<std::string> InterfaceHandler::getUserDocumentation(ContractDefinition& _contractDef) |
|||
{ |
|||
Json::Value doc; |
|||
Json::Value methods(Json::objectValue); |
|||
|
|||
for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions()) |
|||
{ |
|||
Json::Value user; |
|||
auto strPtr = f->getDocumentation(); |
|||
if (strPtr) |
|||
{ |
|||
resetUser(); |
|||
parseDocString(*strPtr, CommentOwner::FUNCTION); |
|||
if (!m_notice.empty()) |
|||
{// since @notice is the only user tag if missing function should not appear
|
|||
user["notice"] = Json::Value(m_notice); |
|||
methods[f->getName()] = user; |
|||
} |
|||
} |
|||
} |
|||
doc["methods"] = methods; |
|||
|
|||
return std::unique_ptr<std::string>(new std::string(m_writer.write(doc))); |
|||
} |
|||
|
|||
std::unique_ptr<std::string> InterfaceHandler::getDevDocumentation(ContractDefinition& _contractDef) |
|||
{ |
|||
// LTODO: Somewhere in this function warnings for mismatch of param names
|
|||
// should be thrown
|
|||
Json::Value doc; |
|||
Json::Value methods(Json::objectValue); |
|||
|
|||
auto contractDoc = _contractDef.getDocumentation(); |
|||
if (contractDoc) |
|||
{ |
|||
m_contractAuthor.clear(); |
|||
m_title.clear(); |
|||
parseDocString(*contractDoc, CommentOwner::CONTRACT); |
|||
|
|||
if (!m_contractAuthor.empty()) |
|||
doc["author"] = m_contractAuthor; |
|||
|
|||
if (!m_title.empty()) |
|||
doc["title"] = m_title; |
|||
} |
|||
|
|||
for (FunctionDefinition const* f: _contractDef.getInterfaceFunctions()) |
|||
{ |
|||
Json::Value method; |
|||
auto strPtr = f->getDocumentation(); |
|||
if (strPtr) |
|||
{ |
|||
resetDev(); |
|||
parseDocString(*strPtr, CommentOwner::FUNCTION); |
|||
|
|||
if (!m_dev.empty()) |
|||
method["details"] = Json::Value(m_dev); |
|||
|
|||
if (!m_author.empty()) |
|||
method["author"] = m_author; |
|||
|
|||
Json::Value params(Json::objectValue); |
|||
for (auto const& pair: m_params) |
|||
params[pair.first] = pair.second; |
|||
|
|||
if (!m_params.empty()) |
|||
method["params"] = params; |
|||
|
|||
if (!m_return.empty()) |
|||
method["return"] = m_return; |
|||
|
|||
if (!method.empty()) // add the function, only if we have any documentation to add
|
|||
methods[f->getName()] = method; |
|||
} |
|||
} |
|||
doc["methods"] = methods; |
|||
|
|||
return std::unique_ptr<std::string>(new std::string(m_writer.write(doc))); |
|||
} |
|||
|
|||
/* -- private -- */ |
|||
void InterfaceHandler::resetUser() |
|||
{ |
|||
m_notice.clear(); |
|||
} |
|||
|
|||
void InterfaceHandler::resetDev() |
|||
{ |
|||
m_dev.clear(); |
|||
m_author.clear(); |
|||
m_return.clear(); |
|||
m_params.clear(); |
|||
} |
|||
|
|||
static inline std::string::const_iterator skipLineOrEOS(std::string::const_iterator _nlPos, |
|||
std::string::const_iterator _end) |
|||
{ |
|||
return (_nlPos == _end) ? _end : ++_nlPos; |
|||
} |
|||
|
|||
std::string::const_iterator InterfaceHandler::parseDocTagLine(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
std::string& _tagString, |
|||
DocTagType _tagType) |
|||
{ |
|||
auto nlPos = std::find(_pos, _end, '\n'); |
|||
std::copy(_pos, nlPos, back_inserter(_tagString)); |
|||
m_lastTag = _tagType; |
|||
return skipLineOrEOS(nlPos, _end); |
|||
} |
|||
|
|||
std::string::const_iterator InterfaceHandler::parseDocTagParam(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end) |
|||
{ |
|||
// find param name
|
|||
auto currPos = std::find(_pos, _end, ' '); |
|||
if (currPos == _end) |
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("End of param name not found" + std::string(_pos, _end))); |
|||
|
|||
|
|||
auto paramName = std::string(_pos, currPos); |
|||
|
|||
currPos += 1; |
|||
auto nlPos = std::find(currPos, _end, '\n'); |
|||
auto paramDesc = std::string(currPos, nlPos); |
|||
m_params.push_back(std::make_pair(paramName, paramDesc)); |
|||
|
|||
m_lastTag = DocTagType::PARAM; |
|||
return skipLineOrEOS(nlPos, _end); |
|||
} |
|||
|
|||
std::string::const_iterator InterfaceHandler::appendDocTagParam(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end) |
|||
{ |
|||
// Should never be called with an empty vector
|
|||
if (asserts(!m_params.empty())) |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Internal: Tried to append to empty parameter")); |
|||
|
|||
auto pair = m_params.back(); |
|||
pair.second += " "; |
|||
auto nlPos = std::find(_pos, _end, '\n'); |
|||
std::copy(_pos, nlPos, back_inserter(pair.second)); |
|||
|
|||
m_params.at(m_params.size() - 1) = pair; |
|||
|
|||
return skipLineOrEOS(nlPos, _end); |
|||
} |
|||
|
|||
std::string::const_iterator InterfaceHandler::parseDocTag(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
std::string const& _tag, |
|||
CommentOwner _owner) |
|||
{ |
|||
// LTODO: need to check for @(start of a tag) between here and the end of line
|
|||
// for all cases. Also somehow automate list of acceptable tags for each
|
|||
// language construct since current way does not scale well.
|
|||
if (m_lastTag == DocTagType::NONE || _tag != "") |
|||
{ |
|||
if (_tag == "dev") |
|||
return parseDocTagLine(_pos, _end, m_dev, DocTagType::DEV); |
|||
else if (_tag == "notice") |
|||
return parseDocTagLine(_pos, _end, m_notice, DocTagType::NOTICE); |
|||
else if (_tag == "return") |
|||
return parseDocTagLine(_pos, _end, m_return, DocTagType::RETURN); |
|||
else if (_tag == "author") |
|||
{ |
|||
if (_owner == CommentOwner::CONTRACT) |
|||
return parseDocTagLine(_pos, _end, m_contractAuthor, DocTagType::AUTHOR); |
|||
else if (_owner == CommentOwner::FUNCTION) |
|||
return parseDocTagLine(_pos, _end, m_author, DocTagType::AUTHOR); |
|||
else |
|||
// LTODO: for now this else makes no sense but later comments will go to more language constructs
|
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("@author tag is legal only for contracts")); |
|||
} |
|||
else if (_tag == "title") |
|||
{ |
|||
if (_owner == CommentOwner::CONTRACT) |
|||
return parseDocTagLine(_pos, _end, m_title, DocTagType::TITLE); |
|||
else |
|||
// LTODO: Unknown tag, throw some form of warning and not just an exception
|
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("@title tag is legal only for contracts")); |
|||
} |
|||
else if (_tag == "param") |
|||
return parseDocTagParam(_pos, _end); |
|||
else |
|||
// LTODO: Unknown tag, throw some form of warning and not just an exception
|
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("Unknown tag " + _tag + " encountered")); |
|||
} |
|||
else |
|||
return appendDocTag(_pos, _end, _owner); |
|||
} |
|||
|
|||
std::string::const_iterator InterfaceHandler::appendDocTag(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
CommentOwner _owner) |
|||
{ |
|||
switch (m_lastTag) |
|||
{ |
|||
case DocTagType::DEV: |
|||
m_dev += " "; |
|||
return parseDocTagLine(_pos, _end, m_dev, DocTagType::DEV); |
|||
case DocTagType::NOTICE: |
|||
m_notice += " "; |
|||
return parseDocTagLine(_pos, _end, m_notice, DocTagType::NOTICE); |
|||
case DocTagType::RETURN: |
|||
m_return += " "; |
|||
return parseDocTagLine(_pos, _end, m_return, DocTagType::RETURN); |
|||
case DocTagType::AUTHOR: |
|||
if (_owner == CommentOwner::CONTRACT) |
|||
{ |
|||
m_contractAuthor += " "; |
|||
return parseDocTagLine(_pos, _end, m_contractAuthor, DocTagType::AUTHOR); |
|||
} |
|||
else if (_owner == CommentOwner::FUNCTION) |
|||
{ |
|||
m_author += " "; |
|||
return parseDocTagLine(_pos, _end, m_author, DocTagType::AUTHOR); |
|||
} |
|||
else |
|||
// LTODO: Unknown tag, throw some form of warning and not just an exception
|
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("@author tag in illegal comment")); |
|||
case DocTagType::TITLE: |
|||
if (_owner == CommentOwner::CONTRACT) |
|||
{ |
|||
m_title += " "; |
|||
return parseDocTagLine(_pos, _end, m_title, DocTagType::TITLE); |
|||
} |
|||
else |
|||
// LTODO: Unknown tag, throw some form of warning and not just an exception
|
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << errinfo_comment("@title tag in illegal comment")); |
|||
case DocTagType::PARAM: |
|||
return appendDocTagParam(_pos, _end); |
|||
default: |
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Internal: Illegal documentation tag type")); |
|||
break; |
|||
} |
|||
} |
|||
|
|||
static inline std::string::const_iterator getFirstSpaceOrNl(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end) |
|||
{ |
|||
auto spacePos = std::find(_pos, _end, ' '); |
|||
auto nlPos = std::find(_pos, _end, '\n'); |
|||
return (spacePos < nlPos) ? spacePos : nlPos; |
|||
} |
|||
|
|||
void InterfaceHandler::parseDocString(std::string const& _string, CommentOwner _owner) |
|||
{ |
|||
auto currPos = _string.begin(); |
|||
auto end = _string.end(); |
|||
|
|||
while (currPos != end) |
|||
{ |
|||
auto tagPos = std::find(currPos, end, '@'); |
|||
auto nlPos = std::find(currPos, end, '\n'); |
|||
|
|||
if (tagPos != end && tagPos < nlPos) |
|||
{ |
|||
// we found a tag
|
|||
auto tagNameEndPos = getFirstSpaceOrNl(tagPos, end); |
|||
if (tagNameEndPos == end) |
|||
BOOST_THROW_EXCEPTION(DocstringParsingError() << |
|||
errinfo_comment("End of tag " + std::string(tagPos, tagNameEndPos) + "not found")); |
|||
|
|||
currPos = parseDocTag(tagNameEndPos + 1, end, std::string(tagPos + 1, tagNameEndPos), _owner); |
|||
} |
|||
else if (m_lastTag != DocTagType::NONE) // continuation of the previous tag
|
|||
currPos = appendDocTag(currPos + 1, end, _owner); |
|||
else if (currPos != end) // skip the line if a newline was found
|
|||
currPos = nlPos + 1; |
|||
} |
|||
} |
|||
|
|||
} //solidity NS
|
|||
} // dev NS
|
|||
@ -0,0 +1,123 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Lefteris <lefteris@ethdev.com> |
|||
* @date 2014 |
|||
* Takes the parsed AST and produces the Natspec |
|||
* documentation and the ABI interface |
|||
* https://github.com/ethereum/wiki/wiki/Ethereum-Natural-Specification-Format
|
|||
* |
|||
* Can generally deal with JSON files |
|||
*/ |
|||
|
|||
#pragma once |
|||
|
|||
#include <string> |
|||
#include <memory> |
|||
#include <jsonrpc/json/json.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
// Forward declarations
|
|||
class ContractDefinition; |
|||
enum class DocumentationType: uint8_t; |
|||
|
|||
enum class DocTagType: uint8_t |
|||
{ |
|||
NONE = 0, |
|||
DEV, |
|||
NOTICE, |
|||
PARAM, |
|||
RETURN, |
|||
AUTHOR, |
|||
TITLE |
|||
}; |
|||
|
|||
enum class CommentOwner |
|||
{ |
|||
CONTRACT, |
|||
FUNCTION |
|||
}; |
|||
|
|||
class InterfaceHandler |
|||
{ |
|||
public: |
|||
InterfaceHandler(); |
|||
|
|||
/// Get the given type of documentation
|
|||
/// @param _contractDef The contract definition
|
|||
/// @param _type The type of the documentation. Can be one of the
|
|||
/// types provided by @c DocumentationType
|
|||
/// @return A unique pointer contained string with the json
|
|||
/// representation of provided type
|
|||
std::unique_ptr<std::string> getDocumentation(ContractDefinition& _contractDef, |
|||
DocumentationType _type); |
|||
/// Get the ABI Interface of the contract
|
|||
/// @param _contractDef The contract definition
|
|||
/// @return A unique pointer contained string with the json
|
|||
/// representation of the contract's ABI Interface
|
|||
std::unique_ptr<std::string> getABIInterface(ContractDefinition& _contractDef); |
|||
/// Get the User documentation of the contract
|
|||
/// @param _contractDef The contract definition
|
|||
/// @return A unique pointer contained string with the json
|
|||
/// representation of the contract's user documentation
|
|||
std::unique_ptr<std::string> getUserDocumentation(ContractDefinition& _contractDef); |
|||
/// Get the Developer's documentation of the contract
|
|||
/// @param _contractDef The contract definition
|
|||
/// @return A unique pointer contained string with the json
|
|||
/// representation of the contract's developer documentation
|
|||
std::unique_ptr<std::string> getDevDocumentation(ContractDefinition& _contractDef); |
|||
|
|||
private: |
|||
void resetUser(); |
|||
void resetDev(); |
|||
|
|||
std::string::const_iterator parseDocTagLine(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
std::string& _tagString, |
|||
DocTagType _tagType); |
|||
std::string::const_iterator parseDocTagParam(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end); |
|||
std::string::const_iterator appendDocTagParam(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end); |
|||
void parseDocString(std::string const& _string, CommentOwner _owner); |
|||
std::string::const_iterator appendDocTag(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
CommentOwner _owner); |
|||
std::string::const_iterator parseDocTag(std::string::const_iterator _pos, |
|||
std::string::const_iterator _end, |
|||
std::string const& _tag, |
|||
CommentOwner _owner); |
|||
|
|||
Json::StyledWriter m_writer; |
|||
|
|||
// internal state
|
|||
DocTagType m_lastTag; |
|||
std::string m_notice; |
|||
std::string m_dev; |
|||
std::string m_return; |
|||
std::string m_contractAuthor; |
|||
std::string m_author; |
|||
std::string m_title; |
|||
std::vector<std::pair<std::string, std::string>> m_params; |
|||
}; |
|||
|
|||
} //solidity NS
|
|||
} // dev NS
|
|||
@ -0,0 +1,383 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Lefteris <lefteris@ethdev.com> |
|||
* @date 2014 |
|||
* Solidity command line interface. |
|||
*/ |
|||
#include "CommandLineInterface.h" |
|||
|
|||
#include <string> |
|||
#include <iostream> |
|||
#include <fstream> |
|||
|
|||
#include <boost/filesystem.hpp> |
|||
|
|||
#include "BuildInfo.h" |
|||
#include <libdevcore/Common.h> |
|||
#include <libdevcore/CommonData.h> |
|||
#include <libdevcore/CommonIO.h> |
|||
#include <libevmcore/Instruction.h> |
|||
#include <libsolidity/Scanner.h> |
|||
#include <libsolidity/Parser.h> |
|||
#include <libsolidity/ASTPrinter.h> |
|||
#include <libsolidity/NameAndTypeResolver.h> |
|||
#include <libsolidity/Exceptions.h> |
|||
#include <libsolidity/CompilerStack.h> |
|||
#include <libsolidity/SourceReferenceFormatter.h> |
|||
|
|||
using namespace std; |
|||
namespace po = boost::program_options; |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
static void version() |
|||
{ |
|||
cout << "solc, the solidity complier commandline interface " << dev::Version << endl |
|||
<< " by Christian <c@ethdev.com> and Lefteris <lefteris@ethdev.com>, (c) 2014." << endl |
|||
<< "Build: " << DEV_QUOTED(ETH_BUILD_PLATFORM) << "/" << DEV_QUOTED(ETH_BUILD_TYPE) << endl; |
|||
exit(0); |
|||
} |
|||
|
|||
static inline bool argToStdout(po::variables_map const& _args, const char* _name) |
|||
{ |
|||
return _args.count(_name) && _args[_name].as<OutputType>() != OutputType::FILE; |
|||
} |
|||
|
|||
static bool needStdout(po::variables_map const& _args) |
|||
{ |
|||
return argToStdout(_args, "abi") || argToStdout(_args, "natspec-user") || argToStdout(_args, "natspec-dev") || |
|||
argToStdout(_args, "asm") || argToStdout(_args, "opcodes") || argToStdout(_args, "binary"); |
|||
} |
|||
|
|||
static inline bool outputToFile(OutputType type) |
|||
{ |
|||
return type == OutputType::FILE || type == OutputType::BOTH; |
|||
} |
|||
|
|||
static inline bool outputToStdout(OutputType type) |
|||
{ |
|||
return type == OutputType::STDOUT || type == OutputType::BOTH; |
|||
} |
|||
|
|||
static std::istream& operator>>(std::istream& _in, OutputType& io_output) |
|||
{ |
|||
std::string token; |
|||
_in >> token; |
|||
if (token == "stdout") |
|||
io_output = OutputType::STDOUT; |
|||
else if (token == "file") |
|||
io_output = OutputType::FILE; |
|||
else if (token == "both") |
|||
io_output = OutputType::BOTH; |
|||
else |
|||
throw boost::program_options::invalid_option_value(token); |
|||
return _in; |
|||
} |
|||
|
|||
void CommandLineInterface::handleBinary(string const& _contract) |
|||
{ |
|||
auto choice = m_args["binary"].as<OutputType>(); |
|||
if (outputToStdout(choice)) |
|||
{ |
|||
cout << "Binary: " << endl; |
|||
cout << toHex(m_compiler.getBytecode(_contract)) << endl; |
|||
} |
|||
|
|||
if (outputToFile(choice)) |
|||
{ |
|||
ofstream outFile(_contract + ".binary"); |
|||
outFile << toHex(m_compiler.getBytecode(_contract)); |
|||
outFile.close(); |
|||
} |
|||
} |
|||
|
|||
void CommandLineInterface::handleOpcode(string const& _contract) |
|||
{ |
|||
// TODO: Figure out why the wrong operator << (from boost) is used here
|
|||
auto choice = m_args["opcode"].as<OutputType>(); |
|||
if (outputToStdout(choice)) |
|||
{ |
|||
cout << "Opcodes: " << endl; |
|||
dev::operator<<(cout, m_compiler.getBytecode(_contract)); |
|||
cout << endl; |
|||
} |
|||
|
|||
if (outputToFile(choice)) |
|||
{ |
|||
ofstream outFile(_contract + ".opcode"); |
|||
dev::operator<<(outFile, m_compiler.getBytecode(_contract)); |
|||
outFile.close(); |
|||
} |
|||
} |
|||
|
|||
void CommandLineInterface::handleBytecode(string const& _contract) |
|||
{ |
|||
if (m_args.count("opcodes")) |
|||
handleOpcode(_contract); |
|||
if (m_args.count("binary")) |
|||
handleBinary(_contract); |
|||
} |
|||
|
|||
void CommandLineInterface::handleJson(DocumentationType _type, |
|||
string const& _contract) |
|||
{ |
|||
std::string argName; |
|||
std::string suffix; |
|||
std::string title; |
|||
switch(_type) |
|||
{ |
|||
case DocumentationType::ABI_INTERFACE: |
|||
argName = "abi"; |
|||
suffix = ".abi"; |
|||
title = "Contract ABI"; |
|||
break; |
|||
case DocumentationType::NATSPEC_USER: |
|||
argName = "natspec-user"; |
|||
suffix = ".docuser"; |
|||
title = "User Documentation"; |
|||
break; |
|||
case DocumentationType::NATSPEC_DEV: |
|||
argName = "natspec-dev"; |
|||
suffix = ".docdev"; |
|||
title = "Developer Documentation"; |
|||
break; |
|||
default: |
|||
// should never happen
|
|||
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown documentation _type")); |
|||
} |
|||
|
|||
if (m_args.count(argName)) |
|||
{ |
|||
auto choice = m_args[argName].as<OutputType>(); |
|||
if (outputToStdout(choice)) |
|||
{ |
|||
cout << title << endl; |
|||
cout << m_compiler.getJsonDocumentation(_contract, _type); |
|||
} |
|||
|
|||
if (outputToFile(choice)) |
|||
{ |
|||
ofstream outFile(_contract + suffix); |
|||
outFile << m_compiler.getJsonDocumentation(_contract, _type); |
|||
outFile.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
bool CommandLineInterface::parseArguments(int argc, char** argv) |
|||
{ |
|||
#define OUTPUT_TYPE_STR "Legal values:\n" \ |
|||
"\tstdout: Print it to standard output\n" \ |
|||
"\tfile: Print it to a file with same name\n" \ |
|||
"\tboth: Print both to a file and the stdout\n" |
|||
// Declare the supported options.
|
|||
po::options_description desc("Allowed options"); |
|||
desc.add_options() |
|||
("help", "Show help message and exit") |
|||
("version", "Show version and exit") |
|||
("optimize", po::value<bool>()->default_value(false), "Optimize bytecode for size") |
|||
("input-file", po::value<vector<string>>(), "input file") |
|||
("ast", po::value<OutputType>(), |
|||
"Request to output the AST of the contract. " OUTPUT_TYPE_STR) |
|||
("asm", po::value<OutputType>(), |
|||
"Request to output the EVM assembly of the contract. " OUTPUT_TYPE_STR) |
|||
("opcodes", po::value<OutputType>(), |
|||
"Request to output the Opcodes of the contract. " OUTPUT_TYPE_STR) |
|||
("binary", po::value<OutputType>(), |
|||
"Request to output the contract in binary (hexadecimal). " OUTPUT_TYPE_STR) |
|||
("abi", po::value<OutputType>(), |
|||
"Request to output the contract's ABI interface. " OUTPUT_TYPE_STR) |
|||
("natspec-user", po::value<OutputType>(), |
|||
"Request to output the contract's Natspec user documentation. " OUTPUT_TYPE_STR) |
|||
("natspec-dev", po::value<OutputType>(), |
|||
"Request to output the contract's Natspec developer documentation. " OUTPUT_TYPE_STR); |
|||
#undef OUTPUT_TYPE_STR |
|||
|
|||
// All positional options should be interpreted as input files
|
|||
po::positional_options_description p; |
|||
p.add("input-file", -1); |
|||
|
|||
// parse the compiler arguments
|
|||
try |
|||
{ |
|||
po::store(po::command_line_parser(argc, argv).options(desc).positional(p).allow_unregistered().run(), m_args); |
|||
} |
|||
catch (po::error const& exception) |
|||
{ |
|||
cout << exception.what() << endl; |
|||
return false; |
|||
} |
|||
po::notify(m_args); |
|||
|
|||
if (m_args.count("help")) |
|||
{ |
|||
cout << desc; |
|||
return false; |
|||
} |
|||
|
|||
if (m_args.count("version")) |
|||
{ |
|||
version(); |
|||
return false; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
bool CommandLineInterface::processInput() |
|||
{ |
|||
if (!m_args.count("input-file")) |
|||
{ |
|||
string s; |
|||
while (!cin.eof()) |
|||
{ |
|||
getline(cin, s); |
|||
m_sourceCodes["<stdin>"].append(s); |
|||
} |
|||
} |
|||
else |
|||
for (string const& infile: m_args["input-file"].as<vector<string>>()) |
|||
{ |
|||
auto path = boost::filesystem::path(infile); |
|||
if (!boost::filesystem::exists(path)) |
|||
{ |
|||
cout << "Skipping non existant input file \"" << infile << "\"" << endl; |
|||
continue; |
|||
} |
|||
|
|||
if (!boost::filesystem::is_regular_file(path)) |
|||
{ |
|||
cout << "\"" << infile << "\" is not a valid file. Skipping" << endl; |
|||
continue; |
|||
} |
|||
|
|||
m_sourceCodes[infile] = asString(dev::contents(infile)); |
|||
} |
|||
|
|||
try |
|||
{ |
|||
for (auto const& sourceCode: m_sourceCodes) |
|||
m_compiler.addSource(sourceCode.first, sourceCode.second); |
|||
// TODO: Perhaps we should not compile unless requested
|
|||
m_compiler.compile(m_args["optimize"].as<bool>()); |
|||
} |
|||
catch (ParserError const& exception) |
|||
{ |
|||
SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Parser error", m_compiler); |
|||
return false; |
|||
} |
|||
catch (DeclarationError const& exception) |
|||
{ |
|||
SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Declaration error", m_compiler); |
|||
return false; |
|||
} |
|||
catch (TypeError const& exception) |
|||
{ |
|||
SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Type error", m_compiler); |
|||
return false; |
|||
} |
|||
catch (CompilerError const& exception) |
|||
{ |
|||
SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Compiler error", m_compiler); |
|||
return false; |
|||
} |
|||
catch (InternalCompilerError const& exception) |
|||
{ |
|||
SourceReferenceFormatter::printExceptionInformation(cerr, exception, "Internal compiler error", m_compiler); |
|||
return false; |
|||
} |
|||
catch (Exception const& exception) |
|||
{ |
|||
cerr << "Exception during compilation: " << boost::diagnostic_information(exception) << endl; |
|||
return false; |
|||
} |
|||
catch (...) |
|||
{ |
|||
cerr << "Unknown exception during compilation." << endl; |
|||
return false; |
|||
} |
|||
|
|||
return true; |
|||
} |
|||
|
|||
void CommandLineInterface::actOnInput() |
|||
{ |
|||
// do we need AST output?
|
|||
if (m_args.count("ast")) |
|||
{ |
|||
auto choice = m_args["ast"].as<OutputType>(); |
|||
if (outputToStdout(choice)) |
|||
{ |
|||
cout << "Syntax trees:" << endl << endl; |
|||
for (auto const& sourceCode: m_sourceCodes) |
|||
{ |
|||
cout << endl << "======= " << sourceCode.first << " =======" << endl; |
|||
ASTPrinter printer(m_compiler.getAST(sourceCode.first), sourceCode.second); |
|||
printer.print(cout); |
|||
} |
|||
} |
|||
|
|||
if (outputToFile(choice)) |
|||
{ |
|||
for (auto const& sourceCode: m_sourceCodes) |
|||
{ |
|||
boost::filesystem::path p(sourceCode.first); |
|||
ofstream outFile(p.stem().string() + ".ast"); |
|||
ASTPrinter printer(m_compiler.getAST(sourceCode.first), sourceCode.second); |
|||
printer.print(outFile); |
|||
outFile.close(); |
|||
} |
|||
} |
|||
} |
|||
|
|||
vector<string> contracts = m_compiler.getContractNames(); |
|||
for (string const& contract: contracts) |
|||
{ |
|||
if (needStdout(m_args)) |
|||
cout << endl << "======= " << contract << " =======" << endl; |
|||
|
|||
// do we need EVM assembly?
|
|||
if (m_args.count("asm")) |
|||
{ |
|||
auto choice = m_args["asm"].as<OutputType>(); |
|||
if (outputToStdout(choice)) |
|||
{ |
|||
cout << "EVM assembly:" << endl; |
|||
m_compiler.streamAssembly(cout, contract); |
|||
} |
|||
|
|||
if (outputToFile(choice)) |
|||
{ |
|||
ofstream outFile(contract + ".evm"); |
|||
m_compiler.streamAssembly(outFile, contract); |
|||
outFile.close(); |
|||
} |
|||
} |
|||
|
|||
handleBytecode(contract); |
|||
handleJson(DocumentationType::ABI_INTERFACE, contract); |
|||
handleJson(DocumentationType::NATSPEC_DEV, contract); |
|||
handleJson(DocumentationType::NATSPEC_USER, contract); |
|||
} // end of contracts iteration
|
|||
} |
|||
|
|||
} |
|||
} |
|||
@ -0,0 +1,71 @@ |
|||
/*
|
|||
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/>.
|
|||
*/ |
|||
/**
|
|||
* @author Lefteris <lefteris@ethdev.com> |
|||
* @date 2014 |
|||
* Solidity command line interface. |
|||
*/ |
|||
#pragma once |
|||
|
|||
#include <boost/program_options.hpp> |
|||
|
|||
#include <libsolidity/CompilerStack.h> |
|||
|
|||
namespace dev |
|||
{ |
|||
namespace solidity |
|||
{ |
|||
|
|||
//forward declaration
|
|||
enum class DocumentationType: uint8_t; |
|||
|
|||
enum class OutputType: uint8_t |
|||
{ |
|||
STDOUT, |
|||
FILE, |
|||
BOTH |
|||
}; |
|||
|
|||
class CommandLineInterface |
|||
{ |
|||
public: |
|||
CommandLineInterface() {} |
|||
|
|||
/// Parse command line arguments and return false if we should not continue
|
|||
bool parseArguments(int argc, char** argv); |
|||
/// Parse the files and create source code objects
|
|||
bool processInput(); |
|||
/// Perform actions on the input depending on provided compiler arguments
|
|||
void actOnInput(); |
|||
|
|||
private: |
|||
void handleBinary(std::string const& _contract); |
|||
void handleOpcode(std::string const& _contract); |
|||
void handleBytecode(std::string const& _contract); |
|||
void handleJson(DocumentationType _type, |
|||
std::string const& _contract); |
|||
|
|||
/// Compiler arguments variable map
|
|||
boost::program_options::variables_map m_args; |
|||
/// map of input files to source code strings
|
|||
std::map<std::string, std::string> m_sourceCodes; |
|||
/// Solidity compiler stack
|
|||
dev::solidity::CompilerStack m_compiler; |
|||
}; |
|||
|
|||
} |
|||
} |
|||
Some files were not shown because too many files changed in this diff
Loading…
Reference in new issue