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

EVM Code for simple accessor function is properly generated

Browse Source
This commit is contained in:
Lefteris Karapetsas 2015-01-27 16:55:06 +01:00
parent ff91ab96ea
commit 2947e038d2
4 changed files with 20 additions and 15 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
Compiler.cpp
View File

@ -292,21 +292,19 @@ void Compiler::registerStateVariables(ContractDefinition const& _contract)
m_context.addStateVariable(*variable); m_context.addStateVariable(*variable);
} }
bool Compiler::generateAccessorCode(VariableDeclaration const& _varDecl) void Compiler::generateAccessorCode(VariableDeclaration const& _varDecl)
{ {
m_context.startNewFunction(); m_context.startNewFunction();
m_returnTag = m_context.newTag(); m_returnTag = m_context.newTag();
m_breakTags.clear(); m_breakTags.clear();
m_continueTags.clear(); m_continueTags.clear();
// TODO: Work in progress
m_context << m_context.getFunctionEntryLabel(_varDecl); m_context << m_context.getFunctionEntryLabel(_varDecl);
// CompilerUtils(m_context).moveToStackVariable(firstVariable); ExpressionCompiler::appendStateVariableAccessor(m_context, &_varDecl);
m_context.appendJumpTo(m_returnTag);
m_context << m_returnTag;
// TODO: perhaps return void if there are no checks? uint64_t foo = uint64_t(_varDecl.getType()->getStorageSize());
return true; m_context << eth::dupInstruction(foo + 1);
m_context << eth::Instruction::JUMP;
} }
bool Compiler::visit(FunctionDefinition const& _function) bool Compiler::visit(FunctionDefinition const& _function)

2
Compiler.h
View File

@ -63,7 +63,7 @@ private:
void registerStateVariables(ContractDefinition const& _contract); void registerStateVariables(ContractDefinition const& _contract);
bool generateAccessorCode(VariableDeclaration const& _varDecl); void generateAccessorCode(VariableDeclaration const& _varDecl);
virtual bool visit(FunctionDefinition const& _function) override; virtual bool visit(FunctionDefinition const& _function) override;
virtual bool visit(IfStatement const& _ifStatement) override; virtual bool visit(IfStatement const& _ifStatement) override;

15
ExpressionCompiler.cpp
View File

@ -48,6 +48,12 @@ void ExpressionCompiler::appendTypeConversion(CompilerContext& _context, Type co
compiler.appendTypeConversion(_typeOnStack, _targetType, _cleanupNeeded); compiler.appendTypeConversion(_typeOnStack, _targetType, _cleanupNeeded);
} }
void ExpressionCompiler::appendStateVariableAccessor(CompilerContext& _context, VariableDeclaration const* _varDecl, bool _optimize)
{
ExpressionCompiler compiler(_context, _optimize);
compiler.appendStateVariableAccessor(_varDecl);
}
bool ExpressionCompiler::visit(Assignment const& _assignment) bool ExpressionCompiler::visit(Assignment const& _assignment)
{ {
_assignment.getRightHandSide().accept(*this); _assignment.getRightHandSide().accept(*this);
@ -792,8 +798,7 @@ unsigned ExpressionCompiler::appendArgumentCopyToMemory(TypePointers const& _typ
void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const* _varDecl) void ExpressionCompiler::appendStateVariableAccessor(VariableDeclaration const* _varDecl)
{ {
m_currentLValue.fromStateVariable(*_varDecl, _varDecl->getType()); m_currentLValue.fromStateVariable(*_varDecl, _varDecl->getType());
// TODO m_currentLValue.retrieveValueFromStorage(_varDecl->getType(), true);
// m_currentLValue.retrieveValueFromStorage();
} }
ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType, ExpressionCompiler::LValue::LValue(CompilerContext& _compilerContext, LValueType _type, Type const& _dataType,
@ -823,7 +828,7 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
break; break;
} }
case STORAGE: case STORAGE:
retrieveValueFromStorage(_expression, _remove); retrieveValueFromStorage(_expression.getType(), _remove);
break; break;
case MEMORY: case MEMORY:
if (!_expression.getType()->isValueType()) if (!_expression.getType()->isValueType())
@ -838,9 +843,9 @@ void ExpressionCompiler::LValue::retrieveValue(Expression const& _expression, bo
} }
} }
void ExpressionCompiler::LValue::retrieveValueFromStorage(Expression const& _expression, bool _remove) const void ExpressionCompiler::LValue::retrieveValueFromStorage(std::shared_ptr<Type const> const& _type, bool _remove) const
{ {
if (!_expression.getType()->isValueType()) if (!_type->isValueType())
return; // no distinction between value and reference for non-value types return; // no distinction between value and reference for non-value types
if (!_remove) if (!_remove)
*m_context << eth::Instruction::DUP1; *m_context << eth::Instruction::DUP1;

6
ExpressionCompiler.h
View File

@ -53,6 +53,8 @@ public:
/// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type. /// Appends code to remove dirty higher order bits in case of an implicit promotion to a wider type.
static void appendTypeConversion(CompilerContext& _context, Type const& _typeOnStack, static void appendTypeConversion(CompilerContext& _context, Type const& _typeOnStack,
Type const& _targetType, bool _cleanupNeeded = false); Type const& _targetType, bool _cleanupNeeded = false);
/// Appends code for a State Variable accessor function
static void appendStateVariableAccessor(CompilerContext& _context, VariableDeclaration const* _varDecl, bool _optimize = false);
private: private:
explicit ExpressionCompiler(CompilerContext& _compilerContext, bool _optimize = false): explicit ExpressionCompiler(CompilerContext& _compilerContext, bool _optimize = false):
@ -130,8 +132,8 @@ private:
/// also removes the reference from the stack (note that is does not reset the type to @a NONE). /// also removes the reference from the stack (note that is does not reset the type to @a NONE).
/// @a _expression is the current expression, used for error reporting. /// @a _expression is the current expression, used for error reporting.
void retrieveValue(Expression const& _expression, bool _remove = false) const; void retrieveValue(Expression const& _expression, bool _remove = false) const;
/// Convenience function to retrive Value from Storage. Specific version of @ref retrieveValue /// Convenience function to retrieve Value from Storage. Specific version of @ref retrieveValue
void retrieveValueFromStorage(Expression const& _expression, bool _remove = false) const; void retrieveValueFromStorage(std::shared_ptr<Type const> const& _type, bool _remove = false) const;
/// Stores a value (from the stack directly beneath the reference, which is assumed to /// Stores a value (from the stack directly beneath the reference, which is assumed to
/// be on the top of the stack, if any) in the lvalue and removes the reference. /// be on the top of the stack, if any) in the lvalue and removes the reference.
/// Also removes the stored value from the stack if @a _move is /// Also removes the stored value from the stack if @a _move is