aboutsummaryrefslogtreecommitdiffstats
path: root/libsolidity/analysis/ConstantEvaluator.cpp
blob: 4d546e68d015a9ad23050b4caefba502e26e3746 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
/*
    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 <http://www.gnu.org/licenses/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2015
 * Evaluator for types of constant expressions.
 */

#include <libsolidity/analysis/ConstantEvaluator.h>
#include <libsolidity/ast/AST.h>
#include <libsolidity/interface/ErrorReporter.h>

using namespace std;
using namespace dev;
using namespace dev::solidity;

/// FIXME: this is pretty much a copy of TypeChecker::endVisit(BinaryOperation)
void ConstantEvaluator::endVisit(UnaryOperation const& _operation)
{
    TypePointer const& subType = _operation.subExpression().annotation().type;
    if (!dynamic_cast<RationalNumberType const*>(subType.get()))
        m_errorReporter.fatalTypeError(_operation.subExpression().location(), "Invalid constant expression.");
    TypePointer t = subType->unaryOperatorResult(_operation.getOperator());
    _operation.annotation().type = t;
}

/// FIXME: this is pretty much a copy of TypeChecker::endVisit(BinaryOperation)
void ConstantEvaluator::endVisit(BinaryOperation const& _operation)
{
    TypePointer const& leftType = _operation.leftExpression().annotation().type;
    TypePointer const& rightType = _operation.rightExpression().annotation().type;
    if (!dynamic_cast<RationalNumberType const*>(leftType.get()))
        m_errorReporter.fatalTypeError(_operation.leftExpression().location(), "Invalid constant expression.");
    if (!dynamic_cast<RationalNumberType const*>(rightType.get()))
        m_errorReporter.fatalTypeError(_operation.rightExpression().location(), "Invalid constant expression.");
    TypePointer commonType = leftType->binaryOperatorResult(_operation.getOperator(), rightType);
    if (!commonType)
    {
        m_errorReporter.typeError(
            _operation.location(),
            "Operator " +
            string(Token::toString(_operation.getOperator())) +
            " not compatible with types " +
            leftType->toString() +
            " and " +
            rightType->toString()
        );
        commonType = leftType;
    }
    _operation.annotation().commonType = commonType;
    _operation.annotation().type =
        Token::isCompareOp(_operation.getOperator()) ?
        make_shared<BoolType>() :
        commonType;
}

void ConstantEvaluator::endVisit(Literal const& _literal)
{
    _literal.annotation().type = Type::forLiteral(_literal);
    if (!_literal.annotation().type)
        m_errorReporter.fatalTypeError(_literal.location(), "Invalid literal value.");
}

void ConstantEvaluator::endVisit(Identifier const& _identifier)
{
    VariableDeclaration const* variableDeclaration = dynamic_cast<VariableDeclaration const*>(_identifier.annotation().referencedDeclaration);
    if (!variableDeclaration)
        return;
    if (!variableDeclaration->isConstant())
        m_errorReporter.fatalTypeError(_identifier.location(), "Identifier must be declared constant.");

    ASTPointer<Expression> value = variableDeclaration->value();
    if (!value)
        m_errorReporter.fatalTypeError(_identifier.location(), "Constant identifier declaration must have a constant value.");

    if (!value->annotation().type)
    {
        if (m_depth > 32)
            m_errorReporter.fatalTypeError(_identifier.location(), "Cyclic constant definition (or maximum recursion depth exhausted).");
        ConstantEvaluator e(*value, m_errorReporter, m_depth + 1);
    }

    _identifier.annotation().type = value->annotation().type;
}