/* This file is part of solidity. solidity 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. solidity 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 solidity. If not, see . */ // SPDX-License-Identifier: GPL-3.0 /** * @author Christian * @author Gav Wood * @date 2014 * Container of the (implicit and explicit) global objects. */ #include #include #include #include #include namespace solidity::frontend { namespace { /// Magic variables get negative ids for easy differentiation int magicVariableToID(std::string const& _name) { if (_name == "abi") return -1; else if (_name == "addmod") return -2; else if (_name == "assert") return -3; else if (_name == "block") return -4; else if (_name == "blockhash") return -5; else if (_name == "ecrecover") return -6; else if (_name == "gasleft") return -7; else if (_name == "keccak256") return -8; else if (_name == "msg") return -15; else if (_name == "mulmod") return -16; else if (_name == "now") return -17; else if (_name == "require") return -18; else if (_name == "revert") return -19; else if (_name == "ripemd160") return -20; else if (_name == "selfdestruct") return -21; else if (_name == "sha256") return -22; else if (_name == "sha3") return -23; else if (_name == "suicide") return -24; else if (_name == "super") return -25; else if (_name == "tx") return -26; else if (_name == "type") return -27; else if (_name == "this") return -28; else solAssert(false, "Unknown magic variable: \"" + _name + "\"."); } inline std::vector> constructMagicVariables() { static auto const magicVarDecl = [](std::string const& _name, Type const* _type) { return std::make_shared(magicVariableToID(_name), _name, _type); }; return { magicVarDecl("abi", TypeProvider::magic(MagicType::Kind::ABI)), magicVarDecl("addmod", TypeProvider::function(strings{"uint256", "uint256", "uint256"}, strings{"uint256"}, FunctionType::Kind::AddMod, StateMutability::Pure)), magicVarDecl("assert", TypeProvider::function(strings{"bool"}, strings{}, FunctionType::Kind::Assert, StateMutability::Pure)), magicVarDecl("block", TypeProvider::magic(MagicType::Kind::Block)), magicVarDecl("blockhash", TypeProvider::function(strings{"uint256"}, strings{"bytes32"}, FunctionType::Kind::BlockHash, StateMutability::View)), magicVarDecl("ecrecover", TypeProvider::function(strings{"bytes32", "uint8", "bytes32", "bytes32"}, strings{"address"}, FunctionType::Kind::ECRecover, StateMutability::Pure)), magicVarDecl("gasleft", TypeProvider::function(strings(), strings{"uint256"}, FunctionType::Kind::GasLeft, StateMutability::View)), magicVarDecl("keccak256", TypeProvider::function(strings{"bytes memory"}, strings{"bytes32"}, FunctionType::Kind::KECCAK256, StateMutability::Pure)), magicVarDecl("msg", TypeProvider::magic(MagicType::Kind::Message)), magicVarDecl("mulmod", TypeProvider::function(strings{"uint256", "uint256", "uint256"}, strings{"uint256"}, FunctionType::Kind::MulMod, StateMutability::Pure)), magicVarDecl("now", TypeProvider::uint256()), magicVarDecl("require", TypeProvider::function(strings{"bool"}, strings{}, FunctionType::Kind::Require, StateMutability::Pure)), magicVarDecl("require", TypeProvider::function(strings{"bool", "string memory"}, strings{}, FunctionType::Kind::Require, StateMutability::Pure)), magicVarDecl("revert", TypeProvider::function(strings(), strings(), FunctionType::Kind::Revert, StateMutability::Pure)), magicVarDecl("revert", TypeProvider::function(strings{"string memory"}, strings(), FunctionType::Kind::Revert, StateMutability::Pure)), magicVarDecl("ripemd160", TypeProvider::function(strings{"bytes memory"}, strings{"bytes20"}, FunctionType::Kind::RIPEMD160, StateMutability::Pure)), magicVarDecl("selfdestruct", TypeProvider::function(strings{"address payable"}, strings{}, FunctionType::Kind::Selfdestruct)), magicVarDecl("sha256", TypeProvider::function(strings{"bytes memory"}, strings{"bytes32"}, FunctionType::Kind::SHA256, StateMutability::Pure)), magicVarDecl("sha3", TypeProvider::function(strings{"bytes memory"}, strings{"bytes32"}, FunctionType::Kind::KECCAK256, StateMutability::Pure)), magicVarDecl("suicide", TypeProvider::function(strings{"address payable"}, strings{}, FunctionType::Kind::Selfdestruct)), magicVarDecl("tx", TypeProvider::magic(MagicType::Kind::Transaction)), // Accepts a MagicType that can be any contract type or an Integer type and returns a // MagicType. The TypeChecker handles the correctness of the input and output types. magicVarDecl("type", TypeProvider::function( strings{}, strings{}, FunctionType::Kind::MetaType, StateMutability::Pure, FunctionType::Options::withArbitraryParameters() )), }; } } GlobalContext::GlobalContext(): m_magicVariables{constructMagicVariables()} { } void GlobalContext::setCurrentContract(ContractDefinition const& _contract) { m_currentContract = &_contract; } std::vector GlobalContext::declarations() const { std::vector declarations; declarations.reserve(m_magicVariables.size()); for (ASTPointer const& variable: m_magicVariables) declarations.push_back(variable.get()); return declarations; } MagicVariableDeclaration const* GlobalContext::currentThis() const { if (!m_thisPointer[m_currentContract]) { Type const* type = TypeProvider::emptyTuple(); if (m_currentContract) type = TypeProvider::contract(*m_currentContract); m_thisPointer[m_currentContract] = std::make_shared(magicVariableToID("this"), "this", type); } return m_thisPointer[m_currentContract].get(); } MagicVariableDeclaration const* GlobalContext::currentSuper() const { if (!m_superPointer[m_currentContract]) { Type const* type = TypeProvider::emptyTuple(); if (m_currentContract) type = TypeProvider::typeType(TypeProvider::contract(*m_currentContract, true)); m_superPointer[m_currentContract] = std::make_shared(magicVariableToID("super"), "super", type); } return m_superPointer[m_currentContract].get(); } }