cerc-io/solidity
16
0
Fork 0
mirror of https://github.com/ethereum/solidity synced 2023-10-03 13:03:40 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #8075 from ethereum/refactor-namespaces

Browse Source 
Refactor namespaces
This commit is contained in:
Daniel Kirchner 2020-01-07 16:52:20 +01:00 committed by GitHub
commit be0775da49
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
544 changed files with 2881 additions and 3548 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
CMakeLists.txt
View File

@ -52,7 +52,7 @@ configure_file("${CMAKE_SOURCE_DIR}/cmake/templates/license.h.in" include/licens
include(EthOptions)
configure_project(TESTS)
add_subdirectory(libdevcore)
add_subdirectory(libsolutil)
add_subdirectory(liblangutil)
add_subdirectory(libevmasm)
add_subdirectory(libyul)

6
CODING_STYLE.md
View File

@ -211,7 +211,7 @@ for (map<ComplexTypeOne, ComplexTypeTwo>::iterator i = l.begin(); i != l.end();
## 12. Include Headers
1. Includes should go in increasing order of generality (`libsolidity` -> `libevmasm` -> `libdevcore` -> `boost` -> `STL`).
1. Includes should go in increasing order of generality (`libsolidity` -> `libevmasm` -> `libsolutil` -> `boost` -> `STL`).
2. The corresponding `.h` file should be the first include in the respective `.cpp` file.
3. Insert empty lines between blocks of include files.
@ -226,8 +226,8 @@ Example:
#include <libevmasm/GasMeter.h>
#include <libdevcore/Common.h>
#include <libdevcore/SHA3.h>
#include <libsolutil/Common.h>
#include <libsolutil/SHA3.h>
#include <boost/range/adaptor/reversed.hpp>
#include <boost/algorithm/string/replace.hpp>

2
Changelog.md
View File

@ -900,7 +900,7 @@ Features:
* ABI JSON: Include new field ``stateMutability`` with values ``pure``, ``view``,
``nonpayable`` and ``payable``.
* Analyzer: Experimental partial support for Z3 SMT checker ("SMTChecker").
* Build System: Shared libraries (``libdevcore``, ``libevmasm``, ``libsolidity``
* Build System: Shared libraries (``libsolutil``, ``libevmasm``, ``libsolidity``
and ``liblll``) are no longer produced during the build process.
* Code generator: Experimental new implementation of ABI encoder that can
encode arbitrarily nested arrays ("ABIEncoderV2")

29
libevmasm/Assembly.cpp
View File

@ -33,9 +33,10 @@
#include <json/json.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
using namespace solidity::util;
void Assembly::append(Assembly const& _a)
{
@ -105,7 +106,7 @@ unsigned Assembly::bytesRequired(unsigned subTagSize) const
for (AssemblyItem const& i: m_items)
ret += i.bytesRequired(tagSize);
if (dev::bytesRequired(ret) <= tagSize)
if (util::bytesRequired(ret) <= tagSize)
return ret;
}
}
@ -290,15 +291,15 @@ Json::Value Assembly::assemblyJSON(StringMap const& _sourceCodes) const
createJsonValue("PUSH [ErrorTag]", i.location().start, i.location().end, ""));
else
collection.append(
createJsonValue("PUSH [tag]", i.location().start, i.location().end, dev::toString(i.data())));
createJsonValue("PUSH [tag]", i.location().start, i.location().end, toString(i.data())));
break;
case PushSub:
collection.append(
createJsonValue("PUSH [$]", i.location().start, i.location().end, dev::toString(h256(i.data()))));
createJsonValue("PUSH [$]", i.location().start, i.location().end, toString(h256(i.data()))));
break;
case PushSubSize:
collection.append(
createJsonValue("PUSH #[$]", i.location().start, i.location().end, dev::toString(h256(i.data()))));
createJsonValue("PUSH #[$]", i.location().start, i.location().end, toString(h256(i.data()))));
break;
case PushProgramSize:
collection.append(
@ -316,7 +317,7 @@ Json::Value Assembly::assemblyJSON(StringMap const& _sourceCodes) const
break;
case Tag:
collection.append(
createJsonValue("tag", i.location().start, i.location().end, dev::toString(i.data())));
createJsonValue("tag", i.location().start, i.location().end, toString(i.data())));
collection.append(
createJsonValue("JUMPDEST", i.location().start, i.location().end));
break;
@ -359,7 +360,7 @@ AssemblyItem Assembly::namedTag(string const& _name)
AssemblyItem Assembly::newPushLibraryAddress(string const& _identifier)
{
h256 h(dev::keccak256(_identifier));
h256 h(util::keccak256(_identifier));
m_libraries[h] = _identifier;
return AssemblyItem{PushLibraryAddress, h};
}
@ -543,14 +544,14 @@ LinkerObject const& Assembly::assemble() const
multimap<h256, unsigned> dataRef;
multimap<size_t, size_t> subRef;
vector<unsigned> sizeRef; ///< Pointers to code locations where the size of the program is inserted
unsigned bytesPerTag = dev::bytesRequired(bytesRequiredForCode);
unsigned bytesPerTag = util::bytesRequired(bytesRequiredForCode);
uint8_t tagPush = (uint8_t)Instruction::PUSH1 - 1 + bytesPerTag;
unsigned bytesRequiredIncludingData = bytesRequiredForCode + 1 + m_auxiliaryData.size();
for (auto const& sub: m_subs)
bytesRequiredIncludingData += sub->assemble().bytecode.size();
unsigned bytesPerDataRef = dev::bytesRequired(bytesRequiredIncludingData);
unsigned bytesPerDataRef = util::bytesRequired(bytesRequiredIncludingData);
uint8_t dataRefPush = (uint8_t)Instruction::PUSH1 - 1 + bytesPerDataRef;
ret.bytecode.reserve(bytesRequiredIncludingData);
@ -580,7 +581,7 @@ LinkerObject const& Assembly::assemble() const
}
case Push:
{
uint8_t b = max<unsigned>(1, dev::bytesRequired(i.data()));
uint8_t b = max<unsigned>(1, util::bytesRequired(i.data()));
ret.bytecode.push_back((uint8_t)Instruction::PUSH1 - 1 + b);
ret.bytecode.resize(ret.bytecode.size() + b);
bytesRef byr(&ret.bytecode.back() + 1 - b, b);
@ -610,7 +611,7 @@ LinkerObject const& Assembly::assemble() const
assertThrow(i.data() <= size_t(-1), AssemblyException, "");
auto s = m_subs.at(size_t(i.data()))->assemble().bytecode.size();
i.setPushedValue(u256(s));
uint8_t b = max<unsigned>(1, dev::bytesRequired(s));
uint8_t b = max<unsigned>(1, util::bytesRequired(s));
ret.bytecode.push_back((uint8_t)Instruction::PUSH1 - 1 + b);
ret.bytecode.resize(ret.bytecode.size() + b);
bytesRef byr(&ret.bytecode.back() + 1 - b, b);
@ -675,7 +676,7 @@ LinkerObject const& Assembly::assemble() const
assertThrow(tagId < tagPositions.size(), AssemblyException, "Reference to non-existing tag.");
size_t pos = tagPositions[tagId];
assertThrow(pos != size_t(-1), AssemblyException, "Reference to tag without position.");
assertThrow(dev::bytesRequired(pos) <= bytesPerTag, AssemblyException, "Tag too large for reserved space.");
assertThrow(util::bytesRequired(pos) <= bytesPerTag, AssemblyException, "Tag too large for reserved space.");
bytesRef r(ret.bytecode.data() + i.first, bytesPerTag);
toBigEndian(pos, r);
}

25
libevmasm/Assembly.h
View File

@ -25,9 +25,9 @@
#include <liblangutil/EVMVersion.h>
#include <libdevcore/Common.h>
#include <libdevcore/Assertions.h>
#include <libdevcore/Keccak256.h>
#include <libsolutil/Common.h>
#include <libsolutil/Assertions.h>
#include <libsolutil/Keccak256.h>
#include <json/json.h>
@ -35,9 +35,7 @@
#include <sstream>
#include <memory>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
using AssemblyPointer = std::shared_ptr<Assembly>;
@ -49,8 +47,8 @@ public:
AssemblyItem newPushTag() { assertThrow(m_usedTags < 0xffffffff, AssemblyException, ""); return AssemblyItem(PushTag, m_usedTags++); }
/// Returns a tag identified by the given name. Creates it if it does not yet exist.
AssemblyItem namedTag(std::string const& _name);
AssemblyItem newData(bytes const& _data) { h256 h(dev::keccak256(asString(_data))); m_data[h] = _data; return AssemblyItem(PushData, h); }
bytes const& data(h256 const& _i) const { return m_data.at(_i); }
AssemblyItem newData(bytes const& _data) { util::h256 h(util::keccak256(util::asString(_data))); m_data[h] = _data; return AssemblyItem(PushData, h); }
bytes const& data(util::h256 const& _i) const { return m_data.at(_i); }
AssemblyItem newSub(AssemblyPointer const& _sub) { m_subs.push_back(_sub); return AssemblyItem(PushSub, m_subs.size() - 1); }
Assembly const& sub(size_t _sub) const { return *m_subs.at(_sub); }
Assembly& sub(size_t _sub) { return *m_subs.at(_sub); }
@ -141,7 +139,7 @@ public:
public:
// These features are only used by LLL
AssemblyItem newPushString(std::string const& _data) { h256 h(dev::keccak256(_data)); m_strings[h] = _data; return AssemblyItem(PushString, h); }
AssemblyItem newPushString(std::string const& _data) { util::h256 h(util::keccak256(_data)); m_strings[h] = _data; return AssemblyItem(PushString, h); }
void append(Assembly const& _a);
void append(Assembly const& _a, int _deposit);
@ -149,7 +147,7 @@ public:
void injectStart(AssemblyItem const& _i);
AssemblyItem const& back() const { return m_items.back(); }
std::string backString() const { return m_items.size() && m_items.back().type() == PushString ? m_strings.at((h256)m_items.back().data()) : std::string(); }
std::string backString() const { return m_items.size() && m_items.back().type() == PushString ? m_strings.at((util::h256)m_items.back().data()) : std::string(); }
protected:
/// Does the same operations as @a optimise, but should only be applied to a sub and
@ -168,12 +166,12 @@ protected:
unsigned m_usedTags = 1;
std::map<std::string, size_t> m_namedTags;
AssemblyItems m_items;
std::map<h256, bytes> m_data;
std::map<util::h256, bytes> m_data;
/// Data that is appended to the very end of the contract.
bytes m_auxiliaryData;
std::vector<std::shared_ptr<Assembly>> m_subs;
std::map<h256, std::string> m_strings;
std::map<h256, std::string> m_libraries; ///< Identifiers of libraries to be linked.
std::map<util::h256, std::string> m_strings;
std::map<util::h256, std::string> m_libraries; ///< Identifiers of libraries to be linked.
mutable LinkerObject m_assembledObject;
mutable std::vector<size_t> m_tagPositionsInBytecode;
@ -192,4 +190,3 @@ inline std::ostream& operator<<(std::ostream& _out, Assembly const& _a)
}
}
}

30
libevmasm/AssemblyItem.cpp
View File

@ -17,21 +17,21 @@
#include <libevmasm/AssemblyItem.h>
#include <libdevcore/CommonData.h>
#include <libdevcore/FixedHash.h>
#include <libsolutil/CommonData.h>
#include <libsolutil/FixedHash.h>
#include <fstream>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
static_assert(sizeof(size_t) <= 8, "size_t must be at most 64-bits wide");
AssemblyItem AssemblyItem::toSubAssemblyTag(size_t _subId) const
{
assertThrow(data() < (u256(1) << 64), Exception, "Tag already has subassembly set.");
assertThrow(m_type == PushTag || m_type == Tag, Exception, "");
assertThrow(data() < (u256(1) << 64), util::Exception, "Tag already has subassembly set.");
assertThrow(m_type == PushTag || m_type == Tag, util::Exception, "");
size_t tag = size_t(u256(data()) & 0xffffffffffffffffULL);
AssemblyItem r = *this;
r.m_type = PushTag;
@ -41,7 +41,7 @@ AssemblyItem AssemblyItem::toSubAssemblyTag(size_t _subId) const
pair<size_t, size_t> AssemblyItem::splitForeignPushTag() const
{
assertThrow(m_type == PushTag || m_type == Tag, Exception, "");
assertThrow(m_type == PushTag || m_type == Tag, util::Exception, "");
u256 combined = u256(data());
size_t subId = size_t((combined >> 64) - 1);
size_t tag = size_t(combined & 0xffffffffffffffffULL);
@ -50,7 +50,7 @@ pair<size_t, size_t> AssemblyItem::splitForeignPushTag() const
void AssemblyItem::setPushTagSubIdAndTag(size_t _subId, size_t _tag)
{
assertThrow(m_type == PushTag || m_type == Tag, Exception, "");
assertThrow(m_type == PushTag || m_type == Tag, util::Exception, "");
u256 data = _tag;
if (_subId != size_t(-1))
data |= (u256(_subId) + 1) << 64;
@ -67,7 +67,7 @@ unsigned AssemblyItem::bytesRequired(unsigned _addressLength) const
case PushString:
return 1 + 32;
case Push:
return 1 + max<unsigned>(1, dev::bytesRequired(data()));
return 1 + max<unsigned>(1, util::bytesRequired(data()));
case PushSubSize:
case PushProgramSize:
return 1 + 4; // worst case: a 16MB program
@ -170,10 +170,10 @@ string AssemblyItem::toAssemblyText() const
break;
}
case Push:
text = toHex(toCompactBigEndian(data(), 1), HexPrefix::Add);
text = toHex(util::toCompactBigEndian(data(), 1), util::HexPrefix::Add);
break;
case PushString:
text = string("data_") + toHex(data());
text = string("data_") + util::toHex(data());
break;
case PushTag:
{
@ -191,7 +191,7 @@ string AssemblyItem::toAssemblyText() const
text = string("tag_") + to_string(size_t(data())) + ":";
break;
case PushData:
text = string("data_") + toHex(data());
text = string("data_") + util::toHex(data());
break;
case PushSub:
text = string("dataOffset(sub_") + to_string(size_t(data())) + ")";
@ -203,7 +203,7 @@ string AssemblyItem::toAssemblyText() const
text = string("bytecodeSize");
break;
case PushLibraryAddress:
text = string("linkerSymbol(\"") + toHex(data()) + string("\")");
text = string("linkerSymbol(\"") + util::toHex(data()) + string("\")");
break;
case PushDeployTimeAddress:
text = string("deployTimeAddress()");
@ -225,7 +225,7 @@ string AssemblyItem::toAssemblyText() const
return text;
}
ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item)
ostream& solidity::evmasm::operator<<(ostream& _out, AssemblyItem const& _item)
{
switch (_item.type())
{
@ -266,7 +266,7 @@ ostream& dev::eth::operator<<(ostream& _out, AssemblyItem const& _item)
break;
case PushLibraryAddress:
{
string hash(h256((_item.data())).hex());
string hash(util::h256((_item.data())).hex());
_out << " PushLibraryAddress " << hash.substr(0, 8) + "..." + hash.substr(hash.length() - 8);
break;
}

19
libevmasm/AssemblyItem.h
View File

@ -24,14 +24,12 @@
#include <libevmasm/Instruction.h>
#include <libevmasm/Exceptions.h>
#include <liblangutil/SourceLocation.h>
#include <libdevcore/Common.h>
#include <libdevcore/Assertions.h>
#include <libsolutil/Common.h>
#include <libsolutil/Assertions.h>
#include <iostream>
#include <sstream>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
enum AssemblyItemType {
@ -77,8 +75,8 @@ public:
AssemblyItem& operator=(AssemblyItem const&) = default;
AssemblyItem& operator=(AssemblyItem&&) = default;
AssemblyItem tag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(Tag, data()); }
AssemblyItem pushTag() const { assertThrow(m_type == PushTag || m_type == Tag, Exception, ""); return AssemblyItem(PushTag, data()); }
AssemblyItem tag() const { assertThrow(m_type == PushTag || m_type == Tag, util::Exception, ""); return AssemblyItem(Tag, data()); }
AssemblyItem pushTag() const { assertThrow(m_type == PushTag || m_type == Tag, util::Exception, ""); return AssemblyItem(PushTag, data()); }
/// Converts the tag to a subassembly tag. This has to be called in order to move a tag across assemblies.
/// @param _subId the identifier of the subassembly the tag is taken from.
AssemblyItem toSubAssemblyTag(size_t _subId) const;
@ -89,11 +87,11 @@ public:
void setPushTagSubIdAndTag(size_t _subId, size_t _tag);
AssemblyItemType type() const { return m_type; }
u256 const& data() const { assertThrow(m_type != Operation, Exception, ""); return *m_data; }
void setData(u256 const& _data) { assertThrow(m_type != Operation, Exception, ""); m_data = std::make_shared<u256>(_data); }
u256 const& data() const { assertThrow(m_type != Operation, util::Exception, ""); return *m_data; }
void setData(u256 const& _data) { assertThrow(m_type != Operation, util::Exception, ""); m_data = std::make_shared<u256>(_data); }
/// @returns the instruction of this item (only valid if type() == Operation)
Instruction instruction() const { assertThrow(m_type == Operation, Exception, ""); return m_instruction; }
Instruction instruction() const { assertThrow(m_type == Operation, util::Exception, ""); return m_instruction; }
/// @returns true if the type and data of the items are equal.
bool operator==(AssemblyItem const& _other) const
@ -178,4 +176,3 @@ inline std::ostream& operator<<(std::ostream& _out, AssemblyItems const& _items)
}
}
}

4
libevmasm/BlockDeduplicator.cpp
View File

@ -30,8 +30,8 @@
#include <set>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
bool BlockDeduplicator::deduplicate()

7
libevmasm/BlockDeduplicator.h
View File

@ -23,16 +23,14 @@
#pragma once
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
#include <cstddef>
#include <vector>
#include <functional>
#include <map>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
@ -90,4 +88,3 @@ private:
};
}
}

8
libevmasm/CommonSubexpressionEliminator.cpp
View File

@ -23,14 +23,14 @@
#include <functional>
#include <boost/range/adaptor/reversed.hpp>
#include <libdevcore/Keccak256.h>
#include <libsolutil/Keccak256.h>
#include <libevmasm/CommonSubexpressionEliminator.h>
#include <libevmasm/AssemblyItem.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
vector<AssemblyItem> CommonSubexpressionEliminator::getOptimizedItems()
{

9
libevmasm/CommonSubexpressionEliminator.h
View File

@ -28,8 +28,8 @@
#include <set>
#include <tuple>
#include <ostream>
#include <libdevcore/CommonIO.h>
#include <libdevcore/Exceptions.h>
#include <libsolutil/CommonIO.h>
#include <libsolutil/Exceptions.h>
#include <libevmasm/ExpressionClasses.h>
#include <libevmasm/SemanticInformation.h>
#include <libevmasm/KnownState.h>
@ -39,9 +39,7 @@ namespace langutil
struct SourceLocation;
}
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
@ -187,4 +185,3 @@ _AssemblyItemIterator CommonSubexpressionEliminator::feedItems(
}
}
}

16
libevmasm/ConstantOptimiser.cpp
View File

@ -22,9 +22,11 @@
#include <libevmasm/ConstantOptimiser.h>
#include <libevmasm/Assembly.h>
#include <libevmasm/GasMeter.h>
#include <libsolutil/CommonData.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
unsigned ConstantOptimisationMethod::optimiseConstants(
bool _isCreation,
@ -101,7 +103,7 @@ bigint ConstantOptimisationMethod::dataGas(bytes const& _data) const
size_t ConstantOptimisationMethod::bytesRequired(AssemblyItems const& _items)
{
return eth::bytesRequired(_items, 3); // assume 3 byte addresses
return evmasm::bytesRequired(_items, 3); // assume 3 byte addresses
}
void ConstantOptimisationMethod::replaceConstants(
@ -131,7 +133,7 @@ bigint LiteralMethod::gasNeeded() const
return combineGas(
simpleRunGas({Instruction::PUSH1}),
// PUSHX plus data
(m_params.isCreation ? GasCosts::txDataNonZeroGas(m_params.evmVersion) : GasCosts::createDataGas) + dataGas(toCompactBigEndian(m_value, 1)),
(m_params.isCreation ? GasCosts::txDataNonZeroGas(m_params.evmVersion) : GasCosts::createDataGas) + dataGas(util::toCompactBigEndian(m_value, 1)),
0
);
}
@ -144,13 +146,13 @@ bigint CodeCopyMethod::gasNeeded() const
// Data gas for copy routines: Some bytes are zero, but we ignore them.
bytesRequired(copyRoutine()) * (m_params.isCreation ? GasCosts::txDataNonZeroGas(m_params.evmVersion) : GasCosts::createDataGas),
// Data gas for data itself
dataGas(toBigEndian(m_value))
dataGas(util::toBigEndian(m_value))
);
}
AssemblyItems CodeCopyMethod::execute(Assembly& _assembly) const
{
bytes data = toBigEndian(m_value);
bytes data = util::toBigEndian(m_value);
assertThrow(data.size() == 32, OptimizerException, "Invalid number encoding.");
AssemblyItems actualCopyRoutine = copyRoutine();
actualCopyRoutine[4] = _assembly.newData(data);
@ -190,7 +192,7 @@ AssemblyItems ComputeMethod::findRepresentation(u256 const& _value)
if (_value < 0x10000)
// Very small value, not worth computing
return AssemblyItems{_value};
else if (dev::bytesRequired(~_value) < dev::bytesRequired(_value))
else if (util::bytesRequired(~_value) < util::bytesRequired(_value))
// Negated is shorter to represent
return findRepresentation(~_value) + AssemblyItems{Instruction::NOT};
else

11
libevmasm/ConstantOptimiser.h
View File

@ -25,15 +25,13 @@
#include <liblangutil/EVMVersion.h>
#include <libdevcore/Assertions.h>
#include <libdevcore/CommonData.h>
#include <libdevcore/CommonIO.h>
#include <libsolutil/Assertions.h>
#include <libsolutil/CommonData.h>
#include <libsolutil/CommonIO.h>
#include <vector>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
@ -164,4 +162,3 @@ protected:
};
}
}

4
libevmasm/ControlFlowGraph.cpp
View File

@ -31,8 +31,8 @@
#include <libevmasm/KnownState.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
BlockId::BlockId(u256 const& _id):
m_id(unsigned(_id))

9
libevmasm/ControlFlowGraph.h
View File

@ -25,13 +25,11 @@
#include <vector>
#include <memory>
#include <libdevcore/Common.h>
#include <libdevcore/Assertions.h>
#include <libsolutil/Common.h>
#include <libsolutil/Assertions.h>
#include <libevmasm/ExpressionClasses.h>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class KnownState;
@ -127,4 +125,3 @@ private:
}
}

9
libevmasm/Exceptions.h
View File

@ -21,14 +21,12 @@
#pragma once
#include <libdevcore/Exceptions.h>
#include <libsolutil/Exceptions.h>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
struct AssemblyException: virtual Exception {};
struct AssemblyException: virtual util::Exception {};
struct OptimizerException: virtual AssemblyException {};
struct StackTooDeepException: virtual OptimizerException {};
struct ItemNotAvailableException: virtual OptimizerException {};
@ -37,4 +35,3 @@ DEV_SIMPLE_EXCEPTION(InvalidDeposit);
DEV_SIMPLE_EXCEPTION(InvalidOpcode);
}
}

6
libevmasm/ExpressionClasses.cpp
View File

@ -32,9 +32,9 @@
#include <libevmasm/SimplificationRules.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
bool ExpressionClasses::Expression::operator<(ExpressionClasses::Expression const& _other) const
{

9
libevmasm/ExpressionClasses.h
View File

@ -23,7 +23,7 @@
#pragma once
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
#include <libevmasm/AssemblyItem.h>
#include <vector>
@ -31,14 +31,12 @@
#include <memory>
#include <set>
namespace langutil
namespace solidity::langutil
{
struct SourceLocation;
}
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class Pattern;
@ -128,4 +126,3 @@ private:
};
}
}

7
libevmasm/GasMeter.cpp
View File

@ -19,11 +19,12 @@
#include <libevmasm/KnownState.h>
#include <libdevcore/FixedHash.h>
#include <libsolutil/FixedHash.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::evmasm;
GasMeter::GasConsumption& GasMeter::GasConsumption::operator+=(GasConsumption const& _other)
{

5
libevmasm/GasMeter.h
View File

@ -29,9 +29,7 @@
#include <ostream>
#include <tuple>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class KnownState;
@ -180,4 +178,3 @@ inline std::ostream& operator<<(std::ostream& _str, GasMeter::GasConsumption con
}
}

19
libevmasm/Instruction.cpp
View File

@ -21,16 +21,17 @@
#include <libevmasm/Instruction.h>
#include <libdevcore/Common.h>
#include <libdevcore/CommonIO.h>
#include <libsolutil/Common.h>
#include <libsolutil/CommonIO.h>
#include <algorithm>
#include <functional>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::evmasm;
std::map<std::string, Instruction> const dev::eth::c_instructions =
std::map<std::string, Instruction> const solidity::evmasm::c_instructions =
{
{ "STOP", Instruction::STOP },
{ "ADD", Instruction::ADD },
@ -322,7 +323,7 @@ static std::map<Instruction, InstructionInfo> const c_instructionInfo =
{ Instruction::SELFDESTRUCT, { "SELFDESTRUCT", 0, 1, 0, true, Tier::Special } }
};
void dev::eth::eachInstruction(
void solidity::evmasm::eachInstruction(
bytes const& _mem,
function<void(Instruction,u256 const&)> const& _onInstruction
)
@ -351,7 +352,7 @@ void dev::eth::eachInstruction(
}
}
string dev::eth::disassemble(bytes const& _mem)
string solidity::evmasm::disassemble(bytes const& _mem)
{
stringstream ret;
eachInstruction(_mem, [&](Instruction _instr, u256 const& _data) {
@ -368,7 +369,7 @@ string dev::eth::disassemble(bytes const& _mem)
return ret.str();
}
InstructionInfo dev::eth::instructionInfo(Instruction _inst)
InstructionInfo solidity::evmasm::instructionInfo(Instruction _inst)
{
try
{
@ -380,7 +381,7 @@ InstructionInfo dev::eth::instructionInfo(Instruction _inst)
}
}
bool dev::eth::isValidInstruction(Instruction _inst)
bool solidity::evmasm::isValidInstruction(Instruction _inst)
{
return !!c_instructionInfo.count(_inst);
}

9
libevmasm/Instruction.h
View File

@ -22,13 +22,11 @@
#pragma once
#include <libevmasm/Exceptions.h>
#include <libdevcore/Common.h>
#include <libdevcore/Assertions.h>
#include <libsolutil/Common.h>
#include <libsolutil/Assertions.h>
#include <functional>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
/// Virtual machine bytecode instruction.
@ -318,4 +316,3 @@ void eachInstruction(bytes const& _mem, std::function<void(Instruction,u256 cons
std::string disassemble(bytes const& _mem);
}
}

6
libevmasm/JumpdestRemover.cpp
View File

@ -24,9 +24,9 @@
#include <libevmasm/AssemblyItem.h>
using namespace std;
using namespace dev::eth;
using namespace dev;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::evmasm;
bool JumpdestRemover::optimise(set<size_t> const& _tagsReferencedFromOutside)
{

5
libevmasm/JumpdestRemover.h
View File

@ -24,9 +24,7 @@
#include <cstddef>
#include <set>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
using AssemblyItems = std::vector<AssemblyItem>;
@ -47,4 +45,3 @@ private:
};
}
}

12
libevmasm/KnownState.cpp
View File

@ -23,14 +23,14 @@
#include <libevmasm/KnownState.h>
#include <libevmasm/AssemblyItem.h>
#include <libdevcore/Keccak256.h>
#include <libsolutil/Keccak256.h>
#include <functional>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
ostream& KnownState::stream(ostream& _out) const
{
@ -383,9 +383,9 @@ KnownState::Id KnownState::applyKeccak256(
{
bytes data;
for (Id a: arguments)
data += toBigEndian(*m_expressionClasses->knownConstant(a));
data += util::toBigEndian(*m_expressionClasses->knownConstant(a));
data.resize(size_t(*l));
v = m_expressionClasses->find(AssemblyItem(u256(dev::keccak256(data)), _location));
v = m_expressionClasses->find(AssemblyItem(u256(util::keccak256(data)), _location));
}
else
v = m_expressionClasses->find(keccak256Item, {_start, _length}, true, m_sequenceNumber);

11
libevmasm/KnownState.h
View File

@ -41,19 +41,17 @@
#pragma clang diagnostic pop
#endif // defined(__clang__)
#include <libdevcore/CommonIO.h>
#include <libdevcore/Exceptions.h>
#include <libsolutil/CommonIO.h>
#include <libsolutil/Exceptions.h>
#include <libevmasm/ExpressionClasses.h>
#include <libevmasm/SemanticInformation.h>
namespace langutil
namespace solidity::langutil
{
struct SourceLocation;
}
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
@ -182,4 +180,3 @@ private:
};
}
}

11
libevmasm/LinkerObject.cpp
View File

@ -20,12 +20,13 @@
*/
#include <libevmasm/LinkerObject.h>
#include <libdevcore/CommonData.h>
#include <libdevcore/Keccak256.h>
#include <libsolutil/CommonData.h>
#include <libsolutil/Keccak256.h>
using namespace dev;
using namespace dev::eth;
using namespace std;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::evmasm;
void LinkerObject::append(LinkerObject const& _other)
{
@ -47,7 +48,7 @@ void LinkerObject::link(map<string, h160> const& _libraryAddresses)
string LinkerObject::toHex() const
{
string hex = dev::toHex(bytecode);
string hex = solidity::util::toHex(bytecode);
for (auto const& ref: linkReferences)
{
size_t pos = ref.first * 2;

15
libevmasm/LinkerObject.h
View File

@ -21,12 +21,10 @@
#pragma once
#include <libdevcore/Common.h>
#include <libdevcore/FixedHash.h>
#include <libsolutil/Common.h>
#include <libsolutil/FixedHash.h>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
/**
@ -46,7 +44,7 @@ struct LinkerObject
void append(LinkerObject const& _other);
/// Links the given libraries by replacing their uses in the code and removes them from the references.
void link(std::map<std::string, h160> const& _libraryAddresses);
void link(std::map<std::string, util::h160> const& _libraryAddresses);
/// @returns a hex representation of the bytecode of the given object, replacing unlinked
/// addresses by placeholders. This output is lowercase.
@ -58,11 +56,10 @@ struct LinkerObject
static std::string libraryPlaceholder(std::string const& _libraryName);
private:
static h160 const* matchLibrary(
static util::h160 const* matchLibrary(
std::string const& _linkRefName,
std::map<std::string, h160> const& _libraryAddresses
std::map<std::string, util::h160> const& _libraryAddresses
);
};
}
}

4
libevmasm/PathGasMeter.cpp
View File

@ -24,8 +24,8 @@
#include <libevmasm/SemanticInformation.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
PathGasMeter::PathGasMeter(AssemblyItems const& _items, langutil::EVMVersion _evmVersion):
m_items(_items), m_evmVersion(_evmVersion)

5
libevmasm/PathGasMeter.h
View File

@ -29,9 +29,7 @@
#include <vector>
#include <memory>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class KnownState;
@ -85,4 +83,3 @@ private:
};
}
}

6
libevmasm/PeepholeOptimiser.cpp
View File

@ -25,8 +25,8 @@
#include <libevmasm/SemanticInformation.h>
using namespace std;
using namespace dev::eth;
using namespace dev;
using namespace solidity;
using namespace solidity::evmasm;
// TODO: Extend this to use the tools from ExpressionClasses.cpp
@ -362,7 +362,7 @@ bool PeepholeOptimiser::optimise()
);
if (m_optimisedItems.size() < m_items.size() || (
m_optimisedItems.size() == m_items.size() && (
eth::bytesRequired(m_optimisedItems, 3) < eth::bytesRequired(m_items, 3) ||
evmasm::bytesRequired(m_optimisedItems, 3) < evmasm::bytesRequired(m_items, 3) ||
numberOfPops(m_optimisedItems) > numberOfPops(m_items)
)
))

5
libevmasm/PeepholeOptimiser.h
View File

@ -24,9 +24,7 @@
#include <cstddef>
#include <iterator>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
using AssemblyItems = std::vector<AssemblyItem>;
@ -53,4 +51,3 @@ private:
};
}
}

7
libevmasm/RuleList.h
View File

@ -25,16 +25,14 @@
#include <libevmasm/Instruction.h>
#include <libevmasm/SimplificationRule.h>
#include <libdevcore/CommonData.h>
#include <libsolutil/CommonData.h>
#include <boost/multiprecision/detail/min_max.hpp>
#include <vector>
#include <functional>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
template <class S> S divWorkaround(S const& _a, S const& _b)
@ -674,4 +672,3 @@ std::vector<SimplificationRule<Pattern>> simplificationRuleList(
}
}
}

8
libevmasm/SemanticInformation.cpp
View File

@ -25,8 +25,8 @@
#include <libevmasm/AssemblyItem.h>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
bool SemanticInformation::breaksCSEAnalysisBlock(AssemblyItem const& _item, bool _msizeImportant)
{
@ -96,14 +96,14 @@ bool SemanticInformation::isDupInstruction(AssemblyItem const& _item)
{
if (_item.type() != Operation)
return false;
return dev::eth::isDupInstruction(_item.instruction());
return evmasm::isDupInstruction(_item.instruction());
}
bool SemanticInformation::isSwapInstruction(AssemblyItem const& _item)
{
if (_item.type() != Operation)
return false;
return dev::eth::isSwapInstruction(_item.instruction());
return evmasm::isSwapInstruction(_item.instruction());
}
bool SemanticInformation::isJumpInstruction(AssemblyItem const& _item)

5
libevmasm/SemanticInformation.h
View File

@ -25,9 +25,7 @@
#include <libevmasm/Instruction.h>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class AssemblyItem;
@ -75,4 +73,3 @@ struct SemanticInformation
};
}
}

7
libevmasm/SimplificationRule.h
View File

@ -21,12 +21,10 @@
#pragma once
#include <libevmasm/Instruction.h>
#include <libdevcore/CommonData.h>
#include <libsolutil/CommonData.h>
#include <functional>
namespace dev
{
namespace eth
namespace solidity::evmasm
{
/**
@ -158,4 +156,3 @@ struct EVMBuiltins
};
}
}

8
libevmasm/SimplificationRules.cpp
View File

@ -27,7 +27,7 @@
#include <libevmasm/Assembly.h>
#include <libevmasm/CommonSubexpressionEliminator.h>
#include <libevmasm/RuleList.h>
#include <libdevcore/Assertions.h>
#include <libsolutil/Assertions.h>
#include <boost/range/adaptor/reversed.hpp>
#include <boost/noncopyable.hpp>
@ -36,9 +36,9 @@
#include <functional>
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace langutil;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
SimplificationRule<Pattern> const* Rules::findFirstMatch(
Expression const& _expr,

11
libevmasm/SimplificationRules.h
View File

@ -26,21 +26,19 @@
#include <libevmasm/ExpressionClasses.h>
#include <libevmasm/SimplificationRule.h>
#include <libdevcore/CommonData.h>
#include <libsolutil/CommonData.h>
#include <boost/noncopyable.hpp>
#include <functional>
#include <vector>
namespace langutil
namespace solidity::langutil
{
struct SourceLocation;
}
namespace dev
{
namespace eth
namespace solidity::evmasm
{
class Pattern;
@ -89,7 +87,7 @@ public:
using Expression = ExpressionClasses::Expression;
using Id = ExpressionClasses::Id;
using Builtins = dev::eth::EVMBuiltins<Pattern>;
using Builtins = evmasm::EVMBuiltins<Pattern>;
static constexpr size_t WordSize = 256;
using Word = u256;
@ -159,4 +157,3 @@ struct ExpressionTemplate
};
}
}

3
liblangutil/CharStream.cpp
View File

@ -54,7 +54,8 @@
#include <liblangutil/Exceptions.h>
using namespace std;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
char CharStream::advanceAndGet(size_t _chars)
{

2
liblangutil/CharStream.h
View File

@ -56,7 +56,7 @@
#include <string>
#include <tuple>
namespace langutil
namespace solidity::langutil
{
/**

2
liblangutil/Common.h
View File

@ -14,7 +14,7 @@
#pragma once
namespace langutil
namespace solidity::langutil
{
inline bool isDecimalDigit(char c)

5
liblangutil/EVMVersion.cpp
View File

@ -20,8 +20,9 @@
#include <liblangutil/EVMVersion.h>
using namespace langutil;
using namespace dev::eth;
using namespace solidity;
using namespace solidity::evmasm;
using namespace solidity::langutil;
bool EVMVersion::hasOpcode(Instruction _opcode) const
{

4
liblangutil/EVMVersion.h
View File

@ -28,7 +28,7 @@
#include <boost/operators.hpp>
namespace langutil
namespace solidity::langutil
{
/**
@ -87,7 +87,7 @@ public:
bool hasChainID() const { return *this >= istanbul(); }
bool hasSelfBalance() const { return *this >= istanbul(); }
bool hasOpcode(dev::eth::Instruction _opcode) const;
bool hasOpcode(evmasm::Instruction _opcode) const;
/// Whether we have to retain the costs for the call opcode itself (false),
/// or whether we can just forward easily all remaining gas (true).

12
liblangutil/ErrorReporter.cpp
View File

@ -25,8 +25,8 @@
#include <memory>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
ErrorReporter& ErrorReporter::operator=(ErrorReporter const& _errorReporter)
{
@ -67,7 +67,7 @@ void ErrorReporter::error(Error::Type _type, SourceLocation const& _location, st
auto err = make_shared<Error>(_type);
*err <<
errinfo_sourceLocation(_location) <<
errinfo_comment(_description);
util::errinfo_comment(_description);
m_errorList.push_back(err);
}
@ -81,7 +81,7 @@ void ErrorReporter::error(Error::Type _type, SourceLocation const& _location, Se
*err <<
errinfo_sourceLocation(_location) <<
errinfo_secondarySourceLocation(_secondaryLocation) <<
errinfo_comment(_description);
util::errinfo_comment(_description);
m_errorList.push_back(err);
}
@ -100,7 +100,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
if (m_warningCount == c_maxWarningsAllowed)
{
auto err = make_shared<Error>(Error::Type::Warning);
*err << errinfo_comment("There are more than 256 warnings. Ignoring the rest.");
*err << util::errinfo_comment("There are more than 256 warnings. Ignoring the rest.");
m_errorList.push_back(err);
}
@ -114,7 +114,7 @@ bool ErrorReporter::checkForExcessiveErrors(Error::Type _type)
if (m_errorCount > c_maxErrorsAllowed)
{
auto err = make_shared<Error>(Error::Type::Warning);
*err << errinfo_comment("There are more than 256 errors. Aborting.");
*err << util::errinfo_comment("There are more than 256 errors. Aborting.");
m_errorList.push_back(err);
BOOST_THROW_EXCEPTION(FatalError());
}

8
liblangutil/ErrorReporter.h
View File

@ -22,15 +22,15 @@
#pragma once
#include <libdevcore/CommonData.h>
#include <libsolutil/CommonData.h>
#include <liblangutil/Exceptions.h>
#include <liblangutil/SourceLocation.h>
#include <libdevcore/StringUtils.h>
#include <libsolutil/StringUtils.h>
#include <boost/range/adaptor/filtered.hpp>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter
@ -98,7 +98,7 @@ public:
auto filterEmpty = boost::adaptors::filtered([](std::string const& _s) { return !_s.empty(); });
std::string errorStr = dev::joinHumanReadable(descs | filterEmpty, " ");
std::string errorStr = util::joinHumanReadable(descs | filterEmpty, " ");
error(Error::Type::TypeError, _location, errorStr);
}

8
liblangutil/Exceptions.cpp
View File

@ -23,8 +23,8 @@
#include <liblangutil/Exceptions.h>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
Error::Error(Type _type, SourceLocation const& _location, string const& _description):
m_type(_type)
@ -54,7 +54,7 @@ Error::Error(Type _type, SourceLocation const& _location, string const& _descrip
if (!_location.isEmpty())
*this << errinfo_sourceLocation(_location);
if (!_description.empty())
*this << errinfo_comment(_description);
*this << util::errinfo_comment(_description);
}
Error::Error(Error::Type _type, std::string const& _description, SourceLocation const& _location):
@ -62,5 +62,5 @@ Error::Error(Error::Type _type, std::string const& _description, SourceLocation
{
if (!_location.isEmpty())
*this << errinfo_sourceLocation(_location);
*this << errinfo_comment(_description);
*this << util::errinfo_comment(_description);
}

22
liblangutil/Exceptions.h
View File

@ -26,32 +26,32 @@
#include <utility>
#include <vector>
#include <memory>
#include <libdevcore/Exceptions.h>
#include <libdevcore/Assertions.h>
#include <libdevcore/CommonData.h>
#include <libsolutil/Exceptions.h>
#include <libsolutil/Assertions.h>
#include <libsolutil/CommonData.h>
#include <liblangutil/SourceLocation.h>
namespace langutil
namespace solidity::langutil
{
class Error;
using ErrorList = std::vector<std::shared_ptr<Error const>>;
struct CompilerError: virtual dev::Exception {};
struct InternalCompilerError: virtual dev::Exception {};
struct FatalError: virtual dev::Exception {};
struct UnimplementedFeatureError: virtual dev::Exception {};
struct CompilerError: virtual util::Exception {};
struct InternalCompilerError: virtual util::Exception {};
struct FatalError: virtual util::Exception {};
struct UnimplementedFeatureError: virtual util::Exception {};
/// Assertion that throws an InternalCompilerError containing the given description if it is not met.
#define solAssert(CONDITION, DESCRIPTION) \
assertThrow(CONDITION, ::langutil::InternalCompilerError, DESCRIPTION)
assertThrow(CONDITION, ::solidity::langutil::InternalCompilerError, DESCRIPTION)
#define solUnimplementedAssert(CONDITION, DESCRIPTION) \
assertThrow(CONDITION, ::langutil::UnimplementedFeatureError, DESCRIPTION)
assertThrow(CONDITION, ::solidity::langutil::UnimplementedFeatureError, DESCRIPTION)
#define solUnimplemented(DESCRIPTION) \
solUnimplementedAssert(false, DESCRIPTION)
class Error: virtual public dev::Exception
class Error: virtual public util::Exception
{
public:
enum class Type

3
liblangutil/ParserBase.cpp
View File

@ -25,7 +25,8 @@
#include <liblangutil/ErrorReporter.h>
using namespace std;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
int ParserBase::position() const
{

2
liblangutil/ParserBase.h
View File

@ -27,7 +27,7 @@
#include <memory>
#include <string>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;

14
liblangutil/Scanner.cpp
View File

@ -60,9 +60,10 @@
#include <tuple>
using namespace std;
using namespace langutil;
string langutil::to_string(ScannerError _errorCode)
namespace solidity::langutil {
string to_string(ScannerError _errorCode)
{
switch (_errorCode)
{
@ -84,14 +85,11 @@ string langutil::to_string(ScannerError _errorCode)
}
ostream& langutil::operator<<(ostream& os, ScannerError _errorCode)
ostream& operator<<(ostream& os, ScannerError _errorCode)
{
return os << to_string(_errorCode);
}
namespace langutil
{
/// Scoped helper for literal recording. Automatically drops the literal
/// if aborting the scanning before it's complete.
enum LiteralType
@ -132,8 +130,6 @@ private:
bool m_complete;
};
}
void Scanner::reset(CharStream _source)
{
m_source = make_shared<CharStream>(std::move(_source));
@ -933,3 +929,5 @@ tuple<Token, unsigned, unsigned> Scanner::scanIdentifierOrKeyword()
literal.complete();
return TokenTraits::fromIdentifierOrKeyword(m_nextToken.literal);
}
} // namespace solidity::langutil

6
liblangutil/Scanner.h
View File

@ -55,13 +55,13 @@
#include <liblangutil/Token.h>
#include <liblangutil/CharStream.h>
#include <liblangutil/SourceLocation.h>
#include <libdevcore/Common.h>
#include <libdevcore/CommonData.h>
#include <libsolutil/Common.h>
#include <libsolutil/CommonData.h>
#include <optional>
#include <iosfwd>
namespace langutil
namespace solidity::langutil
{
class AstRawString;

4
liblangutil/SemVerHandler.cpp
View File

@ -25,8 +25,8 @@
#include <functional>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
SemVerVersion::SemVerVersion(string const& _versionString)
{

4
liblangutil/SemVerHandler.h
View File

@ -26,10 +26,10 @@
#include <string>
#include <vector>
namespace langutil
namespace solidity::langutil
{
class SemVerError: dev::Exception
class SemVerError: util::Exception
{
};

10
liblangutil/SourceLocation.h
View File

@ -22,18 +22,18 @@
#pragma once
#include <libdevcore/Assertions.h>
#include <libdevcore/Common.h> // defines noexcept macro for MSVC
#include <libdevcore/Exceptions.h>
#include <libsolutil/Assertions.h>
#include <libsolutil/Common.h> // defines noexcept macro for MSVC
#include <libsolutil/Exceptions.h>
#include <liblangutil/CharStream.h>
#include <memory>
#include <string>
#include <ostream>
#include <tuple>
namespace langutil
namespace solidity::langutil
{
struct SourceLocationError: virtual dev::Exception {};
struct SourceLocationError: virtual util::Exception {};
/**
* Representation of an interval of source positions.

8
liblangutil/SourceReferenceExtractor.cpp
View File

@ -22,14 +22,14 @@
#include <iomanip>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
SourceReferenceExtractor::Message SourceReferenceExtractor::extract(Exception const& _exception, string _category)
SourceReferenceExtractor::Message SourceReferenceExtractor::extract(util::Exception const& _exception, string _category)
{
SourceLocation const* location = boost::get_error_info<errinfo_sourceLocation>(_exception);
string const* message = boost::get_error_info<errinfo_comment>(_exception);
string const* message = boost::get_error_info<util::errinfo_comment>(_exception);
SourceReference primary = extract(location, message ? *message : "");
std::vector<SourceReference> secondary;

6
liblangutil/SourceReferenceExtractor.h
View File

@ -21,12 +21,12 @@
#include <tuple>
#include <vector>
namespace dev
namespace solidity::util
{
struct Exception;
}
namespace langutil
namespace solidity::langutil
{
struct LineColumn
@ -68,7 +68,7 @@ namespace SourceReferenceExtractor
std::vector<SourceReference> secondary;
};
Message extract(dev::Exception const& _exception, std::string _category);
Message extract(util::Exception const& _exception, std::string _category);
SourceReference extract(SourceLocation const* _location, std::string message = "");
}

7
liblangutil/SourceReferenceFormatter.cpp
View File

@ -25,8 +25,9 @@
#include <liblangutil/Exceptions.h>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::langutil;
void SourceReferenceFormatter::printSourceLocation(SourceLocation const* _location)
{
@ -70,7 +71,7 @@ void SourceReferenceFormatter::printSourceName(SourceReference const& _ref)
m_stream << _ref.sourceName << ":" << (_ref.position.line + 1) << ":" << (_ref.position.column + 1) << ": ";
}
void SourceReferenceFormatter::printExceptionInformation(dev::Exception const& _exception, std::string const& _category)
void SourceReferenceFormatter::printExceptionInformation(util::Exception const& _exception, std::string const& _category)
{
printExceptionInformation(SourceReferenceExtractor::extract(_exception, _category));
}

8
liblangutil/SourceReferenceFormatter.h
View File

@ -28,12 +28,12 @@
#include <liblangutil/Exceptions.h>
#include <liblangutil/SourceReferenceExtractor.h>
namespace dev
namespace solidity::util
{
struct Exception; // forward
}
namespace langutil
namespace solidity::langutil
{
struct SourceLocation;
class Scanner;
@ -52,7 +52,7 @@ public:
virtual void printExceptionInformation(SourceReferenceExtractor::Message const& _msg);
virtual void printSourceLocation(SourceLocation const* _location);
virtual void printExceptionInformation(dev::Exception const& _exception, std::string const& _category);
virtual void printExceptionInformation(util::Exception const& _exception, std::string const& _category);
virtual void printErrorInformation(Error const& _error);
static std::string formatErrorInformation(Error const& _error)
@ -64,7 +64,7 @@ public:
}
static std::string formatExceptionInformation(
dev::Exception const& _exception,
util::Exception const& _exception,
std::string const& _name
)
{

7
liblangutil/SourceReferenceFormatterHuman.cpp
View File

@ -25,9 +25,10 @@
#include <iomanip>
using namespace std;
using namespace dev;
using namespace dev::formatting;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::util;
using namespace solidity::util::formatting;
AnsiColorized SourceReferenceFormatterHuman::normalColored() const
{

22
liblangutil/SourceReferenceFormatterHuman.h
View File

@ -23,18 +23,18 @@
#include <liblangutil/SourceReferenceExtractor.h>
#include <liblangutil/SourceReferenceFormatter.h> // SourceReferenceFormatterBase
#include <libdevcore/AnsiColorized.h>
#include <libsolutil/AnsiColorized.h>
#include <ostream>
#include <sstream>
#include <functional>
namespace dev
namespace solidity::util
{
struct Exception; // forward
}
namespace langutil
namespace solidity::langutil
{
struct SourceLocation;
@ -52,7 +52,7 @@ public:
using SourceReferenceFormatter::printExceptionInformation;
static std::string formatExceptionInformation(
dev::Exception const& _exception,
util::Exception const& _exception,
std::string const& _name,
bool colored = false
)
@ -65,13 +65,13 @@ public:
}
private:
dev::AnsiColorized normalColored() const;
dev::AnsiColorized frameColored() const;
dev::AnsiColorized errorColored() const;
dev::AnsiColorized messageColored() const;
dev::AnsiColorized secondaryColored() const;
dev::AnsiColorized highlightColored() const;
dev::AnsiColorized diagColored() const;
util::AnsiColorized normalColored() const;
util::AnsiColorized frameColored() const;
util::AnsiColorized errorColored() const;
util::AnsiColorized messageColored() const;
util::AnsiColorized secondaryColored() const;
util::AnsiColorized highlightColored() const;
util::AnsiColorized diagColored() const;
private:
bool m_colored;

3
liblangutil/Token.cpp
View File

@ -46,7 +46,7 @@
using namespace std;
namespace langutil
namespace solidity::langutil
{
void ElementaryTypeNameToken::assertDetails(Token _baseType, unsigned const& _first, unsigned const& _second)
@ -82,7 +82,6 @@ void ElementaryTypeNameToken::assertDetails(Token _baseType, unsigned const& _fi
namespace TokenTraits
{
char const* toString(Token tok)
{
switch (tok)

4
liblangutil/Token.h
View File

@ -42,7 +42,7 @@
#pragma once
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
#include <liblangutil/Exceptions.h>
#include <liblangutil/UndefMacros.h>
@ -50,7 +50,7 @@
#include <string>
#include <tuple>
namespace langutil
namespace solidity::langutil
{
// TOKEN_LIST takes a list of 3 macros M, all of which satisfy the

13
liblll/CodeFragment.cpp
View File

@ -23,7 +23,7 @@
#include <liblll/CompilerState.h>
#include <liblll/Parser.h>
#include <libevmasm/Instruction.h>
#include <libdevcore/CommonIO.h>
#include <libsolutil/CommonIO.h>
#include <boost/algorithm/string.hpp>
@ -40,9 +40,10 @@
using namespace std;
using namespace dev;
using namespace dev::eth;
using namespace dev::lll;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::evmasm;
using namespace solidity::lll;
void CodeFragment::finalise(CompilerState const& _cs)
{
@ -608,7 +609,7 @@ void CodeFragment::constructOperation(sp::utree const& _t, CompilerState& _s)
int targetDeposit = hasDefault ? code[code.size() - 1].m_asm.deposit() : 0;
// The conditions
eth::AssemblyItems jumpTags;
evmasm::AssemblyItems jumpTags;
for (unsigned i = 0; i < code.size() - 1; i += 2)
{
requireDeposit(i, 1);
@ -675,7 +676,7 @@ void CodeFragment::constructOperation(sp::utree const& _t, CompilerState& _s)
requireMaxSize(3);
requireDeposit(1, 1);
auto subPush = m_asm.appendSubroutine(make_shared<eth::Assembly>(code[0].assembly(ns)));
auto subPush = m_asm.appendSubroutine(make_shared<evmasm::Assembly>(code[0].assembly(ns)));
m_asm.append(Instruction::DUP1);
if (code.size() == 3)
{

13
liblll/CodeFragment.h
View File

@ -24,14 +24,12 @@
#include <liblll/Exceptions.h>
#include <libevmasm/Instruction.h>
#include <libevmasm/Assembly.h>
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
namespace boost { namespace spirit { class utree; } }
namespace sp = boost::spirit;
namespace dev
{
namespace lll
namespace solidity::lll
{
struct CompilerState;
@ -47,7 +45,7 @@ public:
static CodeFragment compile(std::string _src, CompilerState& _s, ReadCallback const& _readFile);
/// Consolidates data and compiles code.
eth::Assembly& assembly(CompilerState const& _cs) { finalise(_cs); return m_asm; }
evmasm::Assembly& assembly(CompilerState const& _cs) { finalise(_cs); return m_asm; }
private:
void finalise(CompilerState const& _cs);
@ -55,17 +53,16 @@ private:
template <class T> static void error() { BOOST_THROW_EXCEPTION(T() ); }
template <class T> static void error(std::string const& reason) {
auto err = T();
err << errinfo_comment(reason);
err << util::errinfo_comment(reason);
BOOST_THROW_EXCEPTION(err);
}
void constructOperation(sp::utree const& _t, CompilerState& _s);
bool m_finalised = false;
eth::Assembly m_asm;
evmasm::Assembly m_asm;
ReadCallback m_readFile;
};
static CodeFragment const NullCodeFragment;
}
}

11
liblll/Compiler.cpp
View File

@ -25,10 +25,11 @@
#include <liblll/CodeFragment.h>
using namespace std;
using namespace dev;
using namespace dev::lll;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::lll;
bytes dev::lll::compileLLL(string _src, langutil::EVMVersion _evmVersion, bool _opt, std::vector<std::string>* _errors, ReadCallback const& _readFile)
bytes solidity::lll::compileLLL(string _src, langutil::EVMVersion _evmVersion, bool _opt, std::vector<std::string>* _errors, ReadCallback const& _readFile)
{
try
{
@ -66,7 +67,7 @@ bytes dev::lll::compileLLL(string _src, langutil::EVMVersion _evmVersion, bool _
return bytes();
}
std::string dev::lll::compileLLLToAsm(std::string _src, langutil::EVMVersion _evmVersion, bool _opt, std::vector<std::string>* _errors, ReadCallback const& _readFile)
std::string solidity::lll::compileLLLToAsm(std::string _src, langutil::EVMVersion _evmVersion, bool _opt, std::vector<std::string>* _errors, ReadCallback const& _readFile)
{
try
{
@ -104,7 +105,7 @@ std::string dev::lll::compileLLLToAsm(std::string _src, langutil::EVMVersion _ev
return string();
}
string dev::lll::parseLLL(string _src)
string solidity::lll::parseLLL(string _src)
{
sp::utree o;

7
liblll/Compiler.h
View File

@ -21,16 +21,14 @@
#pragma once
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
#include <liblangutil/EVMVersion.h>
#include <string>
#include <vector>
namespace dev
{
namespace lll
namespace solidity::lll
{
using ReadCallback = std::function<std::string(std::string const&)>;
@ -40,4 +38,3 @@ std::string compileLLLToAsm(std::string _src, langutil::EVMVersion _evmVersion,
bytes compileLLL(std::string _src, langutil::EVMVersion _evmVersion, bool _opt = true, std::vector<std::string>* _errors = nullptr, ReadCallback const& _readFile = ReadCallback());
}
}

4
liblll/CompilerState.cpp
View File

@ -23,8 +23,8 @@
#include <liblll/CodeFragment.h>
using namespace std;
using namespace dev;
using namespace dev::lll;
using namespace solidity;
using namespace solidity::lll;
CompilerState::CompilerState()
{

5
liblll/CompilerState.h
View File

@ -24,9 +24,7 @@
#include <liblll/CodeFragment.h>
#include <boost/spirit/include/support_utree.hpp>
namespace dev
{
namespace lll
namespace solidity::lll
{
struct Macro
@ -54,4 +52,3 @@ struct CompilerState
};
}
}

9
liblll/Exceptions.h
View File

@ -21,15 +21,13 @@
#pragma once
#include <libdevcore/Exceptions.h>
#include <libsolutil/Exceptions.h>
namespace dev
{
namespace lll
namespace solidity::lll
{
/// Compile a Low-level Lisp-like Language program into EVM-code.
class CompilerException: public dev::Exception {};
class CompilerException: public util::Exception {};
class InvalidOperation: public CompilerException {};
class IntegerOutOfRange: public CompilerException {};
class EmptyList: public CompilerException {};
@ -42,4 +40,3 @@ class BareSymbol: public CompilerException {};
class ParserException: public CompilerException {};
}
}

15
liblll/Parser.cpp
View File

@ -32,13 +32,14 @@
#include <boost/spirit/include/support_utree.hpp>
using namespace std;
using namespace dev;
using namespace dev::lll;
using namespace solidity;
using namespace solidity::util;
using namespace solidity::lll;
namespace qi = boost::spirit::qi;
namespace px = boost::phoenix;
namespace sp = boost::spirit;
void dev::lll::killBigints(sp::utree const& _this)
void solidity::lll::killBigints(sp::utree const& _this)
{
switch (_this.which())
{
@ -48,7 +49,7 @@ void dev::lll::killBigints(sp::utree const& _this)
}
}
void dev::lll::debugOutAST(ostream& _out, sp::utree const& _this)
void solidity::lll::debugOutAST(ostream& _out, sp::utree const& _this)
{
switch (_this.which())
{
@ -74,7 +75,7 @@ void dev::lll::debugOutAST(ostream& _out, sp::utree const& _this)
}
}
namespace dev {
namespace solidity {
namespace lll {
namespace parseTreeLLL_ {
@ -89,11 +90,11 @@ struct tagNode
}}}
void dev::lll::parseTreeLLL(string const& _s, sp::utree& o_out)
void solidity::lll::parseTreeLLL(string const& _s, sp::utree& o_out)
{
using qi::standard::space;
using qi::standard::space_type;
using dev::lll::parseTreeLLL_::tagNode;
using solidity::lll::parseTreeLLL_::tagNode;
using symbol_type = sp::basic_string<std::string, sp::utree_type::symbol_type>;
using it = string::const_iterator;

7
liblll/Parser.h
View File

@ -22,16 +22,14 @@
#pragma once
#include <liblll/Exceptions.h>
#include <libdevcore/Common.h>
#include <libsolutil/Common.h>
#include <string>
#include <vector>
namespace boost { namespace spirit { class utree; } }
namespace sp = boost::spirit;
namespace dev
{
namespace lll
namespace solidity::lll
{
void killBigints(sp::utree const& _this);
@ -39,4 +37,3 @@ void parseTreeLLL(std::string const& _s, sp::utree& o_out);
void debugOutAST(std::ostream& _out, sp::utree const& _this);
}
}

11
libsolc/libsolc.cpp
View File

@ -24,8 +24,8 @@
#include <libsolidity/interface/StandardCompiler.h>
#include <libsolidity/interface/Version.h>
#include <libyul/YulString.h>
#include <libdevcore/Common.h>
#include <libdevcore/JSON.h>
#include <libsolutil/Common.h>
#include <libsolutil/JSON.h>
#include <cstdlib>
#include <list>
@ -34,8 +34,11 @@
#include "license.h"
using namespace std;
using namespace dev;
using namespace solidity;
using namespace solidity::util;
using solidity::frontend::ReadCallback;
using solidity::frontend::StandardCompiler;
namespace
{
@ -122,7 +125,7 @@ extern char const* solidity_license() noexcept
extern char const* solidity_version() noexcept
{
return VersionString.c_str();
return frontend::VersionString.c_str();
}
extern char* solidity_compile(char const* _input, CStyleReadFileCallback _readCallback, void* _readContext) noexcept

4
libsolidity/analysis/ConstantEvaluator.cpp
View File

@ -27,8 +27,8 @@
#include <liblangutil/ErrorReporter.h>
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::frontend;
void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
{

7
libsolidity/analysis/ConstantEvaluator.h
View File

@ -24,14 +24,12 @@
#include <libsolidity/ast/ASTVisitor.h>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class TypeChecker;
@ -72,4 +70,3 @@ private:
};
}
}

10
libsolidity/analysis/ContractLevelChecker.cpp
View File

@ -30,9 +30,9 @@
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
namespace
{
@ -361,10 +361,10 @@ void ContractLevelChecker::checkExternalTypeClashes(ContractDefinition const& _c
void ContractLevelChecker::checkHashCollisions(ContractDefinition const& _contract)
{
set<FixedHash<4>> hashes;
set<util::FixedHash<4>> hashes;
for (auto const& it: _contract.interfaceFunctionList())
{
FixedHash<4> const& hash = it.first;
util::FixedHash<4> const& hash = it.first;
if (hashes.count(hash))
m_errorReporter.typeError(
_contract.location(),

7
libsolidity/analysis/ContractLevelChecker.h
View File

@ -28,14 +28,12 @@
#include <functional>
#include <set>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -90,4 +88,3 @@ private:
};
}
}

10
libsolidity/analysis/ControlFlowAnalyzer.cpp
View File

@ -18,12 +18,12 @@
#include <libsolidity/analysis/ControlFlowAnalyzer.h>
#include <liblangutil/SourceLocation.h>
#include <libdevcore/Algorithms.h>
#include <libsolutil/Algorithms.h>
#include <boost/range/algorithm/sort.hpp>
using namespace std;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
bool ControlFlowAnalyzer::analyze(ASTNode const& _astRoot)
{
@ -151,7 +151,7 @@ void ControlFlowAnalyzer::checkUninitializedAccess(CFGNode const* _entry, CFGNod
void ControlFlowAnalyzer::checkUnreachable(CFGNode const* _entry, CFGNode const* _exit, CFGNode const* _revert) const
{
// collect all nodes reachable from the entry point
std::set<CFGNode const*> reachable = BreadthFirstSearch<CFGNode const*>{{_entry}}.run(
std::set<CFGNode const*> reachable = util::BreadthFirstSearch<CFGNode const*>{{_entry}}.run(
[](CFGNode const* _node, auto&& _addChild) {
for (CFGNode const* exit: _node->exits)
_addChild(exit);
@ -161,7 +161,7 @@ void ControlFlowAnalyzer::checkUnreachable(CFGNode const* _entry, CFGNode const*
// traverse all paths backwards from exit and revert
// and extract (valid) source locations of unreachable nodes into sorted set
std::set<SourceLocation> unreachable;
BreadthFirstSearch<CFGNode const*>{{_exit, _revert}}.run(
util::BreadthFirstSearch<CFGNode const*>{{_exit, _revert}}.run(
[&](CFGNode const* _node, auto&& _addChild) {
if (!reachable.count(_node) && !_node->location.isEmpty())
unreachable.insert(_node->location);

5
libsolidity/analysis/ControlFlowAnalyzer.h
View File

@ -20,9 +20,7 @@
#include <libsolidity/analysis/ControlFlowGraph.h>
#include <set>
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class ControlFlowAnalyzer: private ASTConstVisitor
@ -47,4 +45,3 @@ private:
};
}
}

4
libsolidity/analysis/ControlFlowBuilder.cpp
View File

@ -17,9 +17,9 @@
#include <libsolidity/analysis/ControlFlowBuilder.h>
using namespace dev;
using namespace langutil;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
using namespace std;
ControlFlowBuilder::ControlFlowBuilder(CFG::NodeContainer& _nodeContainer, FunctionFlow const& _functionFlow):

4
libsolidity/analysis/ControlFlowBuilder.h
View File

@ -24,8 +24,7 @@
#include <array>
#include <memory>
namespace dev {
namespace solidity {
namespace solidity::frontend {
/** Helper class that builds the control flow of a function or modifier.
* Modifiers are not yet applied to the functions. This is done in a second
@ -161,4 +160,3 @@ private:
};
}
}

4
libsolidity/analysis/ControlFlowGraph.cpp
View File

@ -22,8 +22,8 @@
#include <algorithm>
using namespace std;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
bool CFG::constructFlow(ASTNode const& _astRoot)
{

5
libsolidity/analysis/ControlFlowGraph.h
View File

@ -27,9 +27,7 @@
#include <stack>
#include <vector>
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -154,4 +152,3 @@ private:
};
}
}

12
libsolidity/analysis/DeclarationContainer.cpp
View File

@ -24,11 +24,11 @@
#include <libsolidity/ast/AST.h>
#include <libsolidity/ast/Types.h>
#include <libdevcore/StringUtils.h>
#include <libsolutil/StringUtils.h>
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::frontend;
Declaration const* DeclarationContainer::conflictingDeclaration(
Declaration const& _declaration,
@ -118,7 +118,7 @@ bool DeclarationContainer::registerDeclaration(
return false;
vector<Declaration const*>& decls = _invisible ? m_invisibleDeclarations[*_name] : m_declarations[*_name];
if (!contains(decls, &_declaration))
if (!util::contains(decls, &_declaration))
decls.push_back(&_declaration);
return true;
}
@ -148,13 +148,13 @@ vector<ASTString> DeclarationContainer::similarNames(ASTString const& _name) con
for (auto const& declaration: m_declarations)
{
string const& declarationName = declaration.first;
if (stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
if (util::stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
similar.push_back(declarationName);
}
for (auto const& declaration: m_invisibleDeclarations)
{
string const& declarationName = declaration.first;
if (stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
if (util::stringWithinDistance(_name, declarationName, maximumEditDistance, MAXIMUM_LENGTH_THRESHOLD))
similar.push_back(declarationName);
}

5
libsolidity/analysis/DeclarationContainer.h
View File

@ -27,9 +27,7 @@
#include <map>
#include <set>
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -76,4 +74,3 @@ private:
};
}
}

6
libsolidity/analysis/DocStringAnalyser.cpp
View File

@ -28,9 +28,9 @@
#include <liblangutil/ErrorReporter.h>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
bool DocStringAnalyser::analyseDocStrings(SourceUnit const& _sourceUnit)
{

7
libsolidity/analysis/DocStringAnalyser.h
View File

@ -25,14 +25,12 @@
#include <libsolidity/ast/ASTVisitor.h>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -82,4 +80,3 @@ private:
};
}
}

5
libsolidity/analysis/GlobalContext.cpp
View File

@ -30,9 +30,7 @@
using namespace std;
namespace dev
{
namespace solidity
namespace solidity::frontend
{
inline vector<shared_ptr<MagicVariableDeclaration const>> constructMagicVariables()
@ -112,4 +110,3 @@ MagicVariableDeclaration const* GlobalContext::currentSuper() const
}
}
}

5
libsolidity/analysis/GlobalContext.h
View File

@ -29,9 +29,7 @@
#include <string>
#include <vector>
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class Type; // forward
@ -61,4 +59,3 @@ private:
};
}
}

13
libsolidity/analysis/NameAndTypeResolver.cpp
View File

@ -25,15 +25,13 @@
#include <libsolidity/analysis/TypeChecker.h>
#include <libsolidity/ast/AST.h>
#include <liblangutil/ErrorReporter.h>
#include <libdevcore/StringUtils.h>
#include <libsolutil/StringUtils.h>
#include <boost/algorithm/string.hpp>
using namespace std;
using namespace langutil;
using namespace solidity::langutil;
namespace dev
{
namespace solidity
namespace solidity::frontend
{
NameAndTypeResolver::NameAndTypeResolver(
@ -244,7 +242,7 @@ vector<Declaration const*> NameAndTypeResolver::cleanedDeclarations(
void NameAndTypeResolver::warnVariablesNamedLikeInstructions()
{
for (auto const& instruction: dev::eth::c_instructions)
for (auto const& instruction: evmasm::c_instructions)
{
string const instructionName{boost::algorithm::to_lower_copy(instruction.first)};
auto declarations = nameFromCurrentScope(instructionName, true);
@ -460,7 +458,7 @@ vector<_T const*> NameAndTypeResolver::cThreeMerge(list<list<_T const*>>& _toMer
string NameAndTypeResolver::similarNameSuggestions(ASTString const& _name) const
{
return quotedAlternativesList(m_currentScope->similarNames(_name));
return util::quotedAlternativesList(m_currentScope->similarNames(_name));
}
DeclarationRegistrationHelper::DeclarationRegistrationHelper(
@ -786,4 +784,3 @@ string DeclarationRegistrationHelper::currentCanonicalName() const
}
}
}

7
libsolidity/analysis/NameAndTypeResolver.h
View File

@ -35,14 +35,12 @@
#include <list>
#include <map>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -214,4 +212,3 @@ private:
};
}
}

12
libsolidity/analysis/OverrideChecker.cpp
View File

@ -25,16 +25,20 @@
#include <libsolidity/ast/TypeProvider.h>
#include <libsolidity/analysis/TypeChecker.h>
#include <liblangutil/ErrorReporter.h>
#include <libdevcore/Visitor.h>
#include <libsolutil/Visitor.h>
#include <boost/range/adaptor/reversed.hpp>
#include <boost/algorithm/string/predicate.hpp>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::frontend;
using namespace solidity::langutil;
using solidity::util::GenericVisitor;
using solidity::util::contains_if;
using solidity::util::joinHumanReadable;
namespace
{

7
libsolidity/analysis/OverrideChecker.h
View File

@ -29,15 +29,13 @@
#include <variant>
#include <optional>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
struct SourceLocation;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class FunctionType;
class ModifierType;
@ -193,4 +191,3 @@ private:
};
}
}

12
libsolidity/analysis/PostTypeChecker.cpp
View File

@ -21,15 +21,15 @@
#include <libsolidity/interface/Version.h>
#include <liblangutil/ErrorReporter.h>
#include <liblangutil/SemVerHandler.h>
#include <libdevcore/Algorithms.h>
#include <libsolutil/Algorithms.h>
#include <boost/range/adaptor/map.hpp>
#include <memory>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
bool PostTypeChecker::check(ASTNode const& _astRoot)
{
@ -128,7 +128,7 @@ struct ConstStateVarCircularReferenceChecker: public PostTypeChecker::Checker
VariableDeclaration const* findCycle(VariableDeclaration const& _startingFrom)
{
auto visitor = [&](VariableDeclaration const& _variable, CycleDetector<VariableDeclaration>& _cycleDetector, size_t _depth)
auto visitor = [&](VariableDeclaration const& _variable, util::CycleDetector<VariableDeclaration>& _cycleDetector, size_t _depth)
{
if (_depth >= 256)
m_errorReporter.fatalDeclarationError(_variable.location(), "Variable definition exhausting cyclic dependency validator.");
@ -148,7 +148,7 @@ struct ConstStateVarCircularReferenceChecker: public PostTypeChecker::Checker
if (_cycleDetector.run(*v))
return;
};
return CycleDetector<VariableDeclaration>(visitor).run(_startingFrom);
return util::CycleDetector<VariableDeclaration>(visitor).run(_startingFrom);
}
private:

7
libsolidity/analysis/PostTypeChecker.h
View File

@ -23,15 +23,13 @@
#include <libsolidity/ast/ASTForward.h>
#include <libsolidity/ast/ASTVisitor.h>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
struct SourceLocation;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -93,4 +91,3 @@ private:
};
}
}

11
libsolidity/analysis/ReferencesResolver.cpp
View File

@ -34,17 +34,15 @@
#include <liblangutil/ErrorReporter.h>
#include <liblangutil/Exceptions.h>
#include <libdevcore/StringUtils.h>
#include <libsolutil/StringUtils.h>
#include <boost/algorithm/string.hpp>
#include <boost/range/adaptor/transformed.hpp>
using namespace std;
using namespace langutil;
using namespace solidity::langutil;
namespace dev
{
namespace solidity
namespace solidity::frontend
{
bool ReferencesResolver::resolve(ASTNode const& _root)
@ -405,7 +403,7 @@ void ReferencesResolver::endVisit(VariableDeclaration const& _variable)
else
{
errorString = "Data location must be " +
joinHumanReadable(
util::joinHumanReadable(
allowedDataLocations | boost::adaptors::transformed(locationToString),
", ",
" or "
@ -501,4 +499,3 @@ void ReferencesResolver::fatalDeclarationError(SourceLocation const& _location,
}
}
}

7
libsolidity/analysis/ReferencesResolver.h
View File

@ -30,15 +30,13 @@
#include <list>
#include <map>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
struct SourceLocation;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class NameAndTypeResolver;
@ -110,4 +108,3 @@ private:
};
}
}

8
libsolidity/analysis/StaticAnalyzer.cpp
View File

@ -28,14 +28,14 @@
#include <memory>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
/**
* Helper class that determines whether a contract's constructor uses inline assembly.
*/
class dev::solidity::ConstructorUsesAssembly
class solidity::frontend::ConstructorUsesAssembly
{
public:
/// @returns true if and only if the contract's or any of its bases' constructors

7
libsolidity/analysis/StaticAnalyzer.h
View File

@ -28,14 +28,12 @@
#include <libsolidity/ast/ASTForward.h>
#include <libsolidity/ast/ASTVisitor.h>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
class ConstructorUsesAssembly;
@ -102,4 +100,3 @@ private:
};
}
}

6
libsolidity/analysis/SyntaxChecker.cpp
View File

@ -34,9 +34,9 @@
#include <string>
using namespace std;
using namespace dev;
using namespace langutil;
using namespace dev::solidity;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::frontend;
bool SyntaxChecker::checkSyntax(ASTNode const& _astRoot)

7
libsolidity/analysis/SyntaxChecker.h
View File

@ -23,14 +23,12 @@
#include <libsolidity/ast/ASTForward.h>
#include <libsolidity/ast/ASTVisitor.h>
namespace langutil
namespace solidity::langutil
{
class ErrorReporter;
}
namespace dev
{
namespace solidity
namespace solidity::frontend
{
/**
@ -109,4 +107,3 @@ private:
};
}
}

Some files were not shown because too many files have changed in this diff Show More