/* 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 . */ /** * @author Christian * @date 2014 * Utilities for the solidity compiler. */ #include #include #include #include using namespace std; namespace dev { namespace solidity { void CompilerContext::addMagicGlobal(MagicVariableDeclaration const& _declaration) { m_magicGlobals.insert(&_declaration); } void CompilerContext::addStateVariable(VariableDeclaration const& _declaration) { m_stateVariables[&_declaration] = m_stateVariablesSize; m_stateVariablesSize += _declaration.getType()->getStorageSize(); } void CompilerContext::addVariable(VariableDeclaration const& _declaration, unsigned _offsetToCurrent) { solAssert(m_asm.deposit() >= 0 && unsigned(m_asm.deposit()) >= _offsetToCurrent, ""); m_localVariables[&_declaration] = unsigned(m_asm.deposit()) - _offsetToCurrent; } void CompilerContext::addAndInitializeVariable(VariableDeclaration const& _declaration) { addVariable(_declaration); int const size = _declaration.getType()->getSizeOnStack(); for (int i = 0; i < size; ++i) *this << u256(0); } void CompilerContext::addFunction(Declaration const& _decl) { eth::AssemblyItem tag(m_asm.newTag()); m_functionEntryLabels.insert(make_pair(&_decl, tag)); m_virtualFunctionEntryLabels.insert(make_pair(_decl.getName(), tag)); } void CompilerContext::addModifier(ModifierDefinition const& _modifier) { m_functionModifiers.insert(make_pair(_modifier.getName(), &_modifier)); } bytes const& CompilerContext::getCompiledContract(const ContractDefinition& _contract) const { auto ret = m_compiledContracts.find(&_contract); solAssert(ret != m_compiledContracts.end(), "Compiled contract not found."); return *ret->second; } bool CompilerContext::isLocalVariable(Declaration const* _declaration) const { return m_localVariables.count(_declaration); } eth::AssemblyItem CompilerContext::getFunctionEntryLabel(Declaration const& _declaration) const { auto res = m_functionEntryLabels.find(&_declaration); solAssert(res != m_functionEntryLabels.end(), "Function entry label not found."); return res->second.tag(); } eth::AssemblyItem CompilerContext::getVirtualFunctionEntryLabel(FunctionDefinition const& _function) const { auto res = m_virtualFunctionEntryLabels.find(_function.getName()); solAssert(res != m_virtualFunctionEntryLabels.end(), "Function entry label not found."); return res->second.tag(); } ModifierDefinition const& CompilerContext::getFunctionModifier(string const& _name) const { auto res = m_functionModifiers.find(_name); solAssert(res != m_functionModifiers.end(), "Function modifier override not found."); return *res->second; } unsigned CompilerContext::getBaseStackOffsetOfVariable(Declaration const& _declaration) const { auto res = m_localVariables.find(&_declaration); solAssert(res != m_localVariables.end(), "Variable not found on stack."); return res->second; } unsigned CompilerContext::baseToCurrentStackOffset(unsigned _baseOffset) const { return m_asm.deposit() - _baseOffset - 1; } unsigned CompilerContext::currentToBaseStackOffset(unsigned _offset) const { return m_asm.deposit() - _offset - 1; } u256 CompilerContext::getStorageLocationOfVariable(const Declaration& _declaration) const { auto it = m_stateVariables.find(&_declaration); solAssert(it != m_stateVariables.end(), "Variable not found in storage."); return it->second; } } }