cerc-io/solidity
10
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

Accessors for multiple mappings implemented

Browse Source
This commit is contained in:
Lefteris Karapetsas 2015-02-02 17:52:50 +01:00
parent 5a374afe62
commit 8cd3d4b4b7
2 changed files with 33 additions and 34 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

45
ExpressionCompiler.cpp
View File

@ -22,6 +22,7 @@
#include <utility> #include <utility>
#include <numeric> #include <numeric>
#include <boost/range/adaptor/reversed.hpp>
#include <libdevcore/Common.h> #include <libdevcore/Common.h>
#include <libdevcrypto/SHA3.h> #include <libdevcrypto/SHA3.h>
#include <libsolidity/AST.h> #include <libsolidity/AST.h>
@ -847,36 +848,34 @@ unsigned ExpressionCompiler::appendExpressionCopyToMemory(Type const& _expectedT
void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& _varDecl) void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const& _varDecl)
{ {
TypePointer resultType = _varDecl.getType(); FunctionType thisType(_varDecl);
auto mappingType = dynamic_cast<const MappingType*>(resultType.get()); solAssert(thisType.getReturnParameterTypes().size() == 1, "");
TypePointer const& resultType = thisType.getReturnParameterTypes().front();
unsigned sizeOnStack; unsigned sizeOnStack;
if (mappingType != nullptr) unsigned length = 0;
{ TypePointers const& params = thisType.getParameterTypes();
// this copies from ExpressionCompiler::visit(IndexAccess .. ) for mapping access // move arguments to memory
TypePointer const& keyType = mappingType->getKeyType(); for (TypePointer const& param: boost::adaptors::reverse(params))
unsigned length = appendTypeConversionAndMoveToMemory(*keyType, *keyType, Location()); length += appendTypeConversionAndMoveToMemory(*param, *param, Location(), length);
solAssert(length == 32, "Mapping key has to take 32 bytes in memory (for now).");
// @todo move this once we actually use memory
m_context << m_context.getStorageLocationOfVariable(_varDecl);
length += CompilerUtils(m_context).storeInMemory(length);
m_context << u256(length) << u256(0) << eth::Instruction::SHA3;
m_currentLValue = LValue(m_context, LValue::STORAGE, *mappingType->getValueType());
m_currentLValue.retrieveValue(mappingType->getValueType(), Location(), true);
m_currentLValue.reset();
resultType = mappingType->getValueType(); // retrieve the position of the mapping
} m_context << m_context.getStorageLocationOfVariable(_varDecl);
else
for (TypePointer const& param: params)
{ {
m_currentLValue.fromStateVariable(_varDecl, _varDecl.getType()); // move offset to memory
solAssert(m_currentLValue.isInStorage(), ""); CompilerUtils(m_context).storeInMemory(length);
m_currentLValue.retrieveValue(_varDecl.getType(), Location(), true); unsigned argLen = CompilerUtils::getPaddedSize(param->getCalldataEncodedSize());
length -= argLen;
m_context << u256(argLen + 32) << u256(length) << eth::Instruction::SHA3;
} }
sizeOnStack = _varDecl.getType()->getSizeOnStack();
m_currentLValue = LValue(m_context, LValue::STORAGE, *resultType);
m_currentLValue.retrieveValue(resultType, Location(), true);
sizeOnStack = resultType->getSizeOnStack();
solAssert(sizeOnStack <= 15, "Stack too deep."); solAssert(sizeOnStack <= 15, "Stack too deep.");
m_context << eth::dupInstruction(sizeOnStack + 1) << eth::Instruction::JUMP; m_context << eth::dupInstruction(sizeOnStack + 1) << eth::Instruction::JUMP;
} }
ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType, ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType,

22
Types.cpp
View File

@ -626,20 +626,20 @@ FunctionType::FunctionType(VariableDeclaration const& _varDecl):
TypePointers retParams; TypePointers retParams;
vector<string> retParamNames; vector<string> retParamNames;
TypePointer varDeclType = _varDecl.getType(); TypePointer varDeclType = _varDecl.getType();
auto mappingType = dynamic_cast<const MappingType*>(varDeclType.get()); auto mappingType = dynamic_cast<MappingType const*>(varDeclType.get());
if (mappingType!= nullptr) auto returnType = varDeclType;
while (mappingType!= nullptr)
{ {
params.push_back(mappingType->getKeyType()); params.push_back(mappingType->getKeyType());
paramNames.push_back(mappingType->getKeyType()->toString()); paramNames.push_back("");
returnType = mappingType->getValueType();
mappingType = dynamic_cast<MappingType const*>(mappingType->getValueType().get());
}
retParams.push_back(returnType);
retParamNames.push_back("");
retParams.push_back(mappingType->getValueType());
retParamNames.push_back(mappingType->getValueType()->toString());
}
else // elelemntary type
{
retParams.push_back(varDeclType);
retParamNames.push_back(_varDecl.getName());
}
swap(params, m_parameterTypes); swap(params, m_parameterTypes);
swap(paramNames, m_parameterNames); swap(paramNames, m_parameterNames);
swap(retParams, m_returnParameterTypes); swap(retParams, m_returnParameterTypes);