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

Changing Solidity Code to use CamelCase enum values

Browse Source
This commit is contained in:
Lefteris Karapetsas 2015-02-09 14:00:12 +01:00
parent 75a5c20f54
commit 6f621f8486
10 changed files with 544 additions and 547 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

20
AST.cpp
View File

@ -247,7 +247,7 @@ void StructDefinition::checkRecursion() const
<< errinfo_comment("Recursive struct definition.")); << errinfo_comment("Recursive struct definition."));
definitionsSeen.insert(def); definitionsSeen.insert(def);
for (ASTPointer<VariableDeclaration> const& member: def->getMembers()) for (ASTPointer<VariableDeclaration> const& member: def->getMembers())
if (member->getType()->getCategory() == Type::Category::STRUCT) if (member->getType()->getCategory() == Type::Category::Struct)
{ {
UserDefinedTypeName const& typeName = dynamic_cast<UserDefinedTypeName const&>(*member->getTypeName()); UserDefinedTypeName const& typeName = dynamic_cast<UserDefinedTypeName const&>(*member->getTypeName());
queue.push_back(&dynamic_cast<StructDefinition const&>(*typeName.getReferencedDeclaration())); queue.push_back(&dynamic_cast<StructDefinition const&>(*typeName.getReferencedDeclaration()));
@ -384,14 +384,14 @@ void VariableDefinition::checkTypeRequirements()
// no type declared and no previous assignment, infer the type // no type declared and no previous assignment, infer the type
m_value->checkTypeRequirements(); m_value->checkTypeRequirements();
TypePointer type = m_value->getType(); TypePointer type = m_value->getType();
if (type->getCategory() == Type::Category::INTEGER_CONSTANT) if (type->getCategory() == Type::Category::IntegerConstant)
{ {
auto intType = dynamic_pointer_cast<IntegerConstantType const>(type)->getIntegerType(); auto intType = dynamic_pointer_cast<IntegerConstantType const>(type)->getIntegerType();
if (!intType) if (!intType)
BOOST_THROW_EXCEPTION(m_value->createTypeError("Invalid integer constant " + type->toString())); BOOST_THROW_EXCEPTION(m_value->createTypeError("Invalid integer constant " + type->toString()));
type = intType; type = intType;
} }
else if (type->getCategory() == Type::Category::VOID) else if (type->getCategory() == Type::Category::Void)
BOOST_THROW_EXCEPTION(m_variable->createTypeError("var cannot be void type")); BOOST_THROW_EXCEPTION(m_variable->createTypeError("var cannot be void type"));
m_variable->setType(type); m_variable->setType(type);
} }
@ -406,7 +406,7 @@ void Assignment::checkTypeRequirements()
if (!m_leftHandSide->getType()->isValueType() && !m_leftHandSide->isLocalLValue()) if (!m_leftHandSide->getType()->isValueType() && !m_leftHandSide->isLocalLValue())
BOOST_THROW_EXCEPTION(createTypeError("Assignment to non-local non-value lvalue.")); BOOST_THROW_EXCEPTION(createTypeError("Assignment to non-local non-value lvalue."));
m_type = m_leftHandSide->getType(); m_type = m_leftHandSide->getType();
if (m_assigmentOperator == Token::ASSIGN) if (m_assigmentOperator == Token::Assign)
m_rightHandSide->expectType(*m_type); m_rightHandSide->expectType(*m_type);
else else
{ {
@ -425,7 +425,7 @@ void Assignment::checkTypeRequirements()
void ExpressionStatement::checkTypeRequirements() void ExpressionStatement::checkTypeRequirements()
{ {
m_expression->checkTypeRequirements(); m_expression->checkTypeRequirements();
if (m_expression->getType()->getCategory() == Type::Category::INTEGER_CONSTANT) if (m_expression->getType()->getCategory() == Type::Category::IntegerConstant)
if (!dynamic_pointer_cast<IntegerConstantType const>(m_expression->getType())->getIntegerType()) if (!dynamic_pointer_cast<IntegerConstantType const>(m_expression->getType())->getIntegerType())
BOOST_THROW_EXCEPTION(m_expression->createTypeError("Invalid integer constant.")); BOOST_THROW_EXCEPTION(m_expression->createTypeError("Invalid integer constant."));
} }
@ -449,9 +449,9 @@ void Expression::requireLValue()
void UnaryOperation::checkTypeRequirements() void UnaryOperation::checkTypeRequirements()
{ {
// INC, DEC, ADD, SUB, NOT, BIT_NOT, DELETE // INC, DEC, ADD, SUB, NOT, BitNot, DELETE
m_subExpression->checkTypeRequirements(); m_subExpression->checkTypeRequirements();
if (m_operator == Token::Value::INC || m_operator == Token::Value::DEC || m_operator == Token::Value::DELETE) if (m_operator == Token::Value::Inc || m_operator == Token::Value::Dec || m_operator == Token::Value::Delete)
m_subExpression->requireLValue(); m_subExpression->requireLValue();
m_type = m_subExpression->getType()->unaryOperatorResult(m_operator); m_type = m_subExpression->getType()->unaryOperatorResult(m_operator);
if (!m_type) if (!m_type)
@ -553,7 +553,7 @@ void FunctionCall::checkTypeRequirements()
bool FunctionCall::isTypeConversion() const bool FunctionCall::isTypeConversion() const
{ {
return m_expression->getType()->getCategory() == Type::Category::TYPE; return m_expression->getType()->getCategory() == Type::Category::Type;
} }
void NewExpression::checkTypeRequirements() void NewExpression::checkTypeRequirements()
@ -577,13 +577,13 @@ void MemberAccess::checkTypeRequirements()
BOOST_THROW_EXCEPTION(createTypeError("Member \"" + *m_memberName + "\" not found or not " BOOST_THROW_EXCEPTION(createTypeError("Member \"" + *m_memberName + "\" not found or not "
"visible in " + type.toString())); "visible in " + type.toString()));
//@todo later, this will not always be STORAGE //@todo later, this will not always be STORAGE
m_lvalue = type.getCategory() == Type::Category::STRUCT ? Declaration::LValueType::STORAGE : Declaration::LValueType::NONE; m_lvalue = type.getCategory() == Type::Category::Struct ? Declaration::LValueType::STORAGE : Declaration::LValueType::NONE;
} }
void IndexAccess::checkTypeRequirements() void IndexAccess::checkTypeRequirements()
{ {
m_base->checkTypeRequirements(); m_base->checkTypeRequirements();
if (m_base->getType()->getCategory() != Type::Category::MAPPING) if (m_base->getType()->getCategory() != Type::Category::Mapping)
BOOST_THROW_EXCEPTION(m_base->createTypeError("Indexed expression has to be a mapping (is " + BOOST_THROW_EXCEPTION(m_base->createTypeError("Indexed expression has to be a mapping (is " +
m_base->getType()->toString() + ")")); m_base->getType()->toString() + ")"));
MappingType const& type = dynamic_cast<MappingType const&>(*m_base->getType()); MappingType const& type = dynamic_cast<MappingType const&>(*m_base->getType());

2
AST.h
View File

@ -1119,7 +1119,7 @@ class Literal: public PrimaryExpression
public: public:
enum class SubDenomination enum class SubDenomination
{ {
None = Token::ILLEGAL, None = Token::Illegal,
Wei = Token::SubWei, Wei = Token::SubWei,
Szabo = Token::SubSzabo, Szabo = Token::SubSzabo,
Finney = Token::SubFinney, Finney = Token::SubFinney,

4
Compiler.cpp
View File

@ -189,7 +189,7 @@ unsigned Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, b
if (c_numBytes > 32) if (c_numBytes > 32)
BOOST_THROW_EXCEPTION(CompilerError() BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_comment("Type " + type->toString() + " not yet supported.")); << errinfo_comment("Type " + type->toString() + " not yet supported."));
bool const c_leftAligned = type->getCategory() == Type::Category::STRING; bool const c_leftAligned = type->getCategory() == Type::Category::String;
bool const c_padToWords = true; bool const c_padToWords = true;
dataOffset += CompilerUtils(m_context).loadFromMemory(dataOffset, c_numBytes, c_leftAligned, dataOffset += CompilerUtils(m_context).loadFromMemory(dataOffset, c_numBytes, c_leftAligned,
!_fromMemory, c_padToWords); !_fromMemory, c_padToWords);
@ -213,7 +213,7 @@ void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters)
<< errinfo_comment("Type " + type->toString() + " not yet supported.")); << errinfo_comment("Type " + type->toString() + " not yet supported."));
CompilerUtils(m_context).copyToStackTop(stackDepth, *type); CompilerUtils(m_context).copyToStackTop(stackDepth, *type);
ExpressionCompiler::appendTypeConversion(m_context, *type, *type, true); ExpressionCompiler::appendTypeConversion(m_context, *type, *type, true);
bool const c_leftAligned = type->getCategory() == Type::Category::STRING; bool const c_leftAligned = type->getCategory() == Type::Category::String;
bool const c_padToWords = true; bool const c_padToWords = true;
dataOffset += CompilerUtils(m_context).storeInMemory(dataOffset, numBytes, c_leftAligned, c_padToWords); dataOffset += CompilerUtils(m_context).storeInMemory(dataOffset, numBytes, c_leftAligned, c_padToWords);
stackDepth -= type->getSizeOnStack(); stackDepth -= type->getSizeOnStack();

114
ExpressionCompiler.cpp
View File

@ -64,7 +64,7 @@ bool ExpressionCompiler::visit(Assignment const& _assignment)
solAssert(m_currentLValue.isValid(), "LValue not retrieved."); solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
Token::Value op = _assignment.getAssignmentOperator(); Token::Value op = _assignment.getAssignmentOperator();
if (op != Token::ASSIGN) // compound assignment if (op != Token::Assign) // compound assignment
{ {
if (m_currentLValue.storesReferenceOnStack()) if (m_currentLValue.storesReferenceOnStack())
m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2; m_context << eth::Instruction::SWAP1 << eth::Instruction::DUP2;
@ -85,7 +85,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
// the operator should know how to convert itself and to which types it applies, so // the operator should know how to convert itself and to which types it applies, so
// put this code together with "Type::acceptsBinary/UnaryOperator" into a class that // put this code together with "Type::acceptsBinary/UnaryOperator" into a class that
// represents the operator // represents the operator
if (_unaryOperation.getType()->getCategory() == Type::Category::INTEGER_CONSTANT) if (_unaryOperation.getType()->getCategory() == Type::Category::IntegerConstant)
{ {
m_context << _unaryOperation.getType()->literalValue(nullptr); m_context << _unaryOperation.getType()->literalValue(nullptr);
return false; return false;
@ -95,19 +95,19 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
switch (_unaryOperation.getOperator()) switch (_unaryOperation.getOperator())
{ {
case Token::NOT: // ! case Token::Not: // !
m_context << eth::Instruction::ISZERO; m_context << eth::Instruction::ISZERO;
break; break;
case Token::BIT_NOT: // ~ case Token::BitNot: // ~
m_context << eth::Instruction::NOT; m_context << eth::Instruction::NOT;
break; break;
case Token::DELETE: // delete case Token::Delete: // delete
solAssert(m_currentLValue.isValid(), "LValue not retrieved."); solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
m_currentLValue.setToZero(_unaryOperation); m_currentLValue.setToZero(_unaryOperation);
m_currentLValue.reset(); m_currentLValue.reset();
break; break;
case Token::INC: // ++ (pre- or postfix) case Token::Inc: // ++ (pre- or postfix)
case Token::DEC: // -- (pre- or postfix) case Token::Dec: // -- (pre- or postfix)
solAssert(m_currentLValue.isValid(), "LValue not retrieved."); solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
m_currentLValue.retrieveValue(_unaryOperation.getType(), _unaryOperation.getLocation()); m_currentLValue.retrieveValue(_unaryOperation.getType(), _unaryOperation.getLocation());
if (!_unaryOperation.isPrefixOperation()) if (!_unaryOperation.isPrefixOperation())
@ -118,7 +118,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
m_context << eth::Instruction::DUP1; m_context << eth::Instruction::DUP1;
} }
m_context << u256(1); m_context << u256(1);
if (_unaryOperation.getOperator() == Token::INC) if (_unaryOperation.getOperator() == Token::Inc)
m_context << eth::Instruction::ADD; m_context << eth::Instruction::ADD;
else else
m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; // @todo avoid the swap m_context << eth::Instruction::SWAP1 << eth::Instruction::SUB; // @todo avoid the swap
@ -129,10 +129,10 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
m_currentLValue.storeValue(_unaryOperation, !_unaryOperation.isPrefixOperation()); m_currentLValue.storeValue(_unaryOperation, !_unaryOperation.isPrefixOperation());
m_currentLValue.reset(); m_currentLValue.reset();
break; break;
case Token::ADD: // + case Token::Add: // +
// unary add, so basically no-op // unary add, so basically no-op
break; break;
case Token::SUB: // - case Token::Sub: // -
m_context << u256(0) << eth::Instruction::SUB; m_context << u256(0) << eth::Instruction::SUB;
break; break;
default: default:
@ -149,19 +149,19 @@ bool ExpressionCompiler::visit(BinaryOperation const& _binaryOperation)
Type const& commonType = _binaryOperation.getCommonType(); Type const& commonType = _binaryOperation.getCommonType();
Token::Value const c_op = _binaryOperation.getOperator(); Token::Value const c_op = _binaryOperation.getOperator();
if (c_op == Token::AND || c_op == Token::OR) // special case: short-circuiting if (c_op == Token::And || c_op == Token::Or) // special case: short-circuiting
appendAndOrOperatorCode(_binaryOperation); appendAndOrOperatorCode(_binaryOperation);
else if (commonType.getCategory() == Type::Category::INTEGER_CONSTANT) else if (commonType.getCategory() == Type::Category::IntegerConstant)
m_context << commonType.literalValue(nullptr); m_context << commonType.literalValue(nullptr);
else else
{ {
bool cleanupNeeded = commonType.getCategory() == Type::Category::INTEGER && bool cleanupNeeded = commonType.getCategory() == Type::Category::Integer &&
(Token::isCompareOp(c_op) || c_op == Token::DIV || c_op == Token::MOD); (Token::isCompareOp(c_op) || c_op == Token::Div || c_op == Token::Mod);
// for commutative operators, push the literal as late as possible to allow improved optimization // for commutative operators, push the literal as late as possible to allow improved optimization
auto isLiteral = [](Expression const& _e) auto isLiteral = [](Expression const& _e)
{ {
return dynamic_cast<Literal const*>(&_e) || _e.getType()->getCategory() == Type::Category::INTEGER_CONSTANT; return dynamic_cast<Literal const*>(&_e) || _e.getType()->getCategory() == Type::Category::IntegerConstant;
}; };
bool swap = m_optimize && Token::isCommutativeOp(c_op) && isLiteral(rightExpression) && !isLiteral(leftExpression); bool swap = m_optimize && Token::isCommutativeOp(c_op) && isLiteral(rightExpression) && !isLiteral(leftExpression);
if (swap) if (swap)
@ -411,7 +411,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
ASTString const& member = _memberAccess.getMemberName(); ASTString const& member = _memberAccess.getMemberName();
switch (_memberAccess.getExpression().getType()->getCategory()) switch (_memberAccess.getExpression().getType()->getCategory())
{ {
case Type::Category::CONTRACT: case Type::Category::Contract:
{ {
bool alsoSearchInteger = false; bool alsoSearchInteger = false;
ContractType const& type = dynamic_cast<ContractType const&>(*_memberAccess.getExpression().getType()); ContractType const& type = dynamic_cast<ContractType const&>(*_memberAccess.getExpression().getType());
@ -423,7 +423,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
u256 identifier = type.getFunctionIdentifier(member); u256 identifier = type.getFunctionIdentifier(member);
if (identifier != Invalid256) if (identifier != Invalid256)
{ {
appendTypeConversion(type, IntegerType(0, IntegerType::Modifier::ADDRESS), true); appendTypeConversion(type, IntegerType(0, IntegerType::Modifier::Address), true);
m_context << identifier; m_context << identifier;
} }
else else
@ -433,24 +433,24 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
if (!alsoSearchInteger) if (!alsoSearchInteger)
break; break;
} }
case Type::Category::INTEGER: case Type::Category::Integer:
if (member == "balance") if (member == "balance")
{ {
appendTypeConversion(*_memberAccess.getExpression().getType(), appendTypeConversion(*_memberAccess.getExpression().getType(),
IntegerType(0, IntegerType::Modifier::ADDRESS), true); IntegerType(0, IntegerType::Modifier::Address), true);
m_context << eth::Instruction::BALANCE; m_context << eth::Instruction::BALANCE;
} }
else if (member == "send" || member.substr(0, min<size_t>(member.size(), 4)) == "call") else if (member == "send" || member.substr(0, min<size_t>(member.size(), 4)) == "call")
appendTypeConversion(*_memberAccess.getExpression().getType(), appendTypeConversion(*_memberAccess.getExpression().getType(),
IntegerType(0, IntegerType::Modifier::ADDRESS), true); IntegerType(0, IntegerType::Modifier::Address), true);
else else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid member access to integer.")); BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid member access to integer."));
break; break;
case Type::Category::FUNCTION: case Type::Category::Function:
solAssert(!!_memberAccess.getExpression().getType()->getMemberType(member), solAssert(!!_memberAccess.getExpression().getType()->getMemberType(member),
"Invalid member access to function."); "Invalid member access to function.");
break; break;
case Type::Category::MAGIC: case Type::Category::Magic:
// we can ignore the kind of magic and only look at the name of the member // we can ignore the kind of magic and only look at the name of the member
if (member == "coinbase") if (member == "coinbase")
m_context << eth::Instruction::COINBASE; m_context << eth::Instruction::COINBASE;
@ -475,7 +475,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
else else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member.")); BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member."));
break; break;
case Type::Category::STRUCT: case Type::Category::Struct:
{ {
StructType const& type = dynamic_cast<StructType const&>(*_memberAccess.getExpression().getType()); StructType const& type = dynamic_cast<StructType const&>(*_memberAccess.getExpression().getType());
m_context << type.getStorageOffsetOfMember(member) << eth::Instruction::ADD; m_context << type.getStorageOffsetOfMember(member) << eth::Instruction::ADD;
@ -483,7 +483,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess); m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess);
break; break;
} }
case Type::Category::TYPE: case Type::Category::Type:
{ {
TypeType const& type = dynamic_cast<TypeType const&>(*_memberAccess.getExpression().getType()); TypeType const& type = dynamic_cast<TypeType const&>(*_memberAccess.getExpression().getType());
if (type.getMembers().getMemberType(member)) if (type.getMembers().getMemberType(member))
@ -526,7 +526,7 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier)
Declaration const* declaration = _identifier.getReferencedDeclaration(); Declaration const* declaration = _identifier.getReferencedDeclaration();
if (MagicVariableDeclaration const* magicVar = dynamic_cast<MagicVariableDeclaration const*>(declaration)) if (MagicVariableDeclaration const* magicVar = dynamic_cast<MagicVariableDeclaration const*>(declaration))
{ {
if (magicVar->getType()->getCategory() == Type::Category::CONTRACT) if (magicVar->getType()->getCategory() == Type::Category::Contract)
// "this" or "super" // "this" or "super"
if (!dynamic_cast<ContractType const&>(*magicVar->getType()).isSuper()) if (!dynamic_cast<ContractType const&>(*magicVar->getType()).isSuper())
m_context << eth::Instruction::ADDRESS; m_context << eth::Instruction::ADDRESS;
@ -556,9 +556,9 @@ void ExpressionCompiler::endVisit(Literal const& _literal)
{ {
switch (_literal.getType()->getCategory()) switch (_literal.getType()->getCategory())
{ {
case Type::Category::INTEGER_CONSTANT: case Type::Category::IntegerConstant:
case Type::Category::BOOL: case Type::Category::Bool:
case Type::Category::STRING: case Type::Category::String:
m_context << _literal.getType()->literalValue(&_literal); m_context << _literal.getType()->literalValue(&_literal);
break; break;
default: default:
@ -569,11 +569,11 @@ void ExpressionCompiler::endVisit(Literal const& _literal)
void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryOperation) void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryOperation)
{ {
Token::Value const c_op = _binaryOperation.getOperator(); Token::Value const c_op = _binaryOperation.getOperator();
solAssert(c_op == Token::OR || c_op == Token::AND, ""); solAssert(c_op == Token::Or || c_op == Token::And, "");
_binaryOperation.getLeftExpression().accept(*this); _binaryOperation.getLeftExpression().accept(*this);
m_context << eth::Instruction::DUP1; m_context << eth::Instruction::DUP1;
if (c_op == Token::AND) if (c_op == Token::And)
m_context << eth::Instruction::ISZERO; m_context << eth::Instruction::ISZERO;
eth::AssemblyItem endLabel = m_context.appendConditionalJump(); eth::AssemblyItem endLabel = m_context.appendConditionalJump();
m_context << eth::Instruction::POP; m_context << eth::Instruction::POP;
@ -583,10 +583,10 @@ void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryO
void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type) void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type const& _type)
{ {
if (_operator == Token::EQ || _operator == Token::NE) if (_operator == Token::Equals || _operator == Token::NotEquals)
{ {
m_context << eth::Instruction::EQ; m_context << eth::Instruction::EQ;
if (_operator == Token::NE) if (_operator == Token::NotEquals)
m_context << eth::Instruction::ISZERO; m_context << eth::Instruction::ISZERO;
} }
else else
@ -596,18 +596,18 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type
switch (_operator) switch (_operator)
{ {
case Token::GTE: case Token::GreaterThanOrEquals:
m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT) m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT)
<< eth::Instruction::ISZERO; << eth::Instruction::ISZERO;
break; break;
case Token::LTE: case Token::LessThanOrEquals:
m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT) m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT)
<< eth::Instruction::ISZERO; << eth::Instruction::ISZERO;
break; break;
case Token::GT: case Token::GreaterThan:
m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT); m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT);
break; break;
case Token::LT: case Token::LessThan:
m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT); m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT);
break; break;
default: default:
@ -635,19 +635,19 @@ void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Ty
switch (_operator) switch (_operator)
{ {
case Token::ADD: case Token::Add:
m_context << eth::Instruction::ADD; m_context << eth::Instruction::ADD;
break; break;
case Token::SUB: case Token::Sub:
m_context << eth::Instruction::SUB; m_context << eth::Instruction::SUB;
break; break;
case Token::MUL: case Token::Mul:
m_context << eth::Instruction::MUL; m_context << eth::Instruction::MUL;
break; break;
case Token::DIV: case Token::Div:
m_context << (c_isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV); m_context << (c_isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV);
break; break;
case Token::MOD: case Token::Mod:
m_context << (c_isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD); m_context << (c_isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD);
break; break;
default: default:
@ -659,13 +659,13 @@ void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator)
{ {
switch (_operator) switch (_operator)
{ {
case Token::BIT_OR: case Token::BitOr:
m_context << eth::Instruction::OR; m_context << eth::Instruction::OR;
break; break;
case Token::BIT_AND: case Token::BitAnd:
m_context << eth::Instruction::AND; m_context << eth::Instruction::AND;
break; break;
case Token::BIT_XOR: case Token::BitXor:
m_context << eth::Instruction::XOR; m_context << eth::Instruction::XOR;
break; break;
default: default:
@ -698,9 +698,9 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
Type::Category stackTypeCategory = _typeOnStack.getCategory(); Type::Category stackTypeCategory = _typeOnStack.getCategory();
Type::Category targetTypeCategory = _targetType.getCategory(); Type::Category targetTypeCategory = _targetType.getCategory();
if (stackTypeCategory == Type::Category::STRING) if (stackTypeCategory == Type::Category::String)
{ {
if (targetTypeCategory == Type::Category::INTEGER) if (targetTypeCategory == Type::Category::Integer)
{ {
// conversion from string to hash. no need to clean the high bit // conversion from string to hash. no need to clean the high bit
// only to shift right because of opposite alignment // only to shift right because of opposite alignment
@ -712,15 +712,15 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
} }
else else
{ {
solAssert(targetTypeCategory == Type::Category::STRING, "Invalid type conversion requested."); solAssert(targetTypeCategory == Type::Category::String, "Invalid type conversion requested.");
// nothing to do, strings are high-order-bit-aligned // nothing to do, strings are high-order-bit-aligned
//@todo clear lower-order bytes if we allow explicit conversion to shorter strings //@todo clear lower-order bytes if we allow explicit conversion to shorter strings
} }
} }
else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT || else if (stackTypeCategory == Type::Category::Integer || stackTypeCategory == Type::Category::Contract ||
stackTypeCategory == Type::Category::INTEGER_CONSTANT) stackTypeCategory == Type::Category::IntegerConstant)
{ {
if (targetTypeCategory == Type::Category::STRING && stackTypeCategory == Type::Category::INTEGER) if (targetTypeCategory == Type::Category::String && stackTypeCategory == Type::Category::Integer)
{ {
// conversion from hash to string. no need to clean the high bit // conversion from hash to string. no need to clean the high bit
// only to shift left because of opposite alignment // only to shift left because of opposite alignment
@ -732,11 +732,11 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
} }
else else
{ {
solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, ""); solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Contract, "");
IntegerType addressType(0, IntegerType::Modifier::ADDRESS); IntegerType addressType(0, IntegerType::Modifier::Address);
IntegerType const& targetType = targetTypeCategory == Type::Category::INTEGER IntegerType const& targetType = targetTypeCategory == Type::Category::Integer
? dynamic_cast<IntegerType const&>(_targetType) : addressType; ? dynamic_cast<IntegerType const&>(_targetType) : addressType;
if (stackTypeCategory == Type::Category::INTEGER_CONSTANT) if (stackTypeCategory == Type::Category::IntegerConstant)
{ {
IntegerConstantType const& constType = dynamic_cast<IntegerConstantType const&>(_typeOnStack); IntegerConstantType const& constType = dynamic_cast<IntegerConstantType const&>(_typeOnStack);
// We know that the stack is clean, we only have to clean for a narrowing conversion // We know that the stack is clean, we only have to clean for a narrowing conversion
@ -746,7 +746,7 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
} }
else else
{ {
IntegerType const& typeOnStack = stackTypeCategory == Type::Category::INTEGER IntegerType const& typeOnStack = stackTypeCategory == Type::Category::Integer
? dynamic_cast<IntegerType const&>(_typeOnStack) : addressType; ? dynamic_cast<IntegerType const&>(_typeOnStack) : addressType;
// Widening: clean up according to source type width // Widening: clean up according to source type width
// Non-widening and force: clean up according to target type bits // Non-widening and force: clean up according to target type bits
@ -831,7 +831,7 @@ void ExpressionCompiler::appendExternalFunctionCall(FunctionType const& _functio
if (retSize > 0) if (retSize > 0)
{ {
bool const c_leftAligned = firstType->getCategory() == Type::Category::STRING; bool const c_leftAligned = firstType->getCategory() == Type::Category::String;
CompilerUtils(m_context).loadFromMemory(0, retSize, c_leftAligned, false, true); CompilerUtils(m_context).loadFromMemory(0, retSize, c_leftAligned, false, true);
} }
} }
@ -866,7 +866,7 @@ unsigned ExpressionCompiler::moveTypeToMemory(Type const& _type, Location const&
BOOST_THROW_EXCEPTION(CompilerError() BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_sourceLocation(_location) << errinfo_sourceLocation(_location)
<< errinfo_comment("Type " + _type.toString() + " not yet supported.")); << errinfo_comment("Type " + _type.toString() + " not yet supported."));
bool const c_leftAligned = _type.getCategory() == Type::Category::STRING; bool const c_leftAligned = _type.getCategory() == Type::Category::String;
return CompilerUtils(m_context).storeInMemory(_memoryOffset, c_numBytes, c_leftAligned, _padToWordBoundaries); return CompilerUtils(m_context).storeInMemory(_memoryOffset, c_numBytes, c_leftAligned, _padToWordBoundaries);
} }

222
Parser.cpp
View File

@ -69,10 +69,10 @@ ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
{ {
switch (m_scanner->getCurrentToken()) switch (m_scanner->getCurrentToken())
{ {
case Token::IMPORT: case Token::Import:
nodes.push_back(parseImportDirective()); nodes.push_back(parseImportDirective());
break; break;
case Token::CONTRACT: case Token::Contract:
nodes.push_back(parseContractDefinition()); nodes.push_back(parseContractDefinition());
break; break;
default: default:
@ -100,12 +100,12 @@ int Parser::getEndPosition() const
ASTPointer<ImportDirective> Parser::parseImportDirective() ASTPointer<ImportDirective> Parser::parseImportDirective()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::IMPORT); expectToken(Token::Import);
if (m_scanner->getCurrentToken() != Token::STRING_LITERAL) if (m_scanner->getCurrentToken() != Token::StringLiteral)
BOOST_THROW_EXCEPTION(createParserError("Expected string literal (URL).")); BOOST_THROW_EXCEPTION(createParserError("Expected string literal (URL)."));
ASTPointer<ASTString> url = getLiteralAndAdvance(); ASTPointer<ASTString> url = getLiteralAndAdvance();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
return nodeFactory.createNode<ImportDirective>(url); return nodeFactory.createNode<ImportDirective>(url);
} }
@ -115,7 +115,7 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
ASTPointer<ASTString> docString; ASTPointer<ASTString> docString;
if (m_scanner->getCurrentCommentLiteral() != "") if (m_scanner->getCurrentCommentLiteral() != "")
docString = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral()); docString = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::CONTRACT); expectToken(Token::Contract);
ASTPointer<ASTString> name = expectIdentifierToken(); ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<InheritanceSpecifier>> baseContracts; vector<ASTPointer<InheritanceSpecifier>> baseContracts;
vector<ASTPointer<StructDefinition>> structs; vector<ASTPointer<StructDefinition>> structs;
@ -123,40 +123,40 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
vector<ASTPointer<FunctionDefinition>> functions; vector<ASTPointer<FunctionDefinition>> functions;
vector<ASTPointer<ModifierDefinition>> modifiers; vector<ASTPointer<ModifierDefinition>> modifiers;
vector<ASTPointer<EventDefinition>> events; vector<ASTPointer<EventDefinition>> events;
if (m_scanner->getCurrentToken() == Token::IS) if (m_scanner->getCurrentToken() == Token::Is)
do do
{ {
m_scanner->next(); m_scanner->next();
baseContracts.push_back(parseInheritanceSpecifier()); baseContracts.push_back(parseInheritanceSpecifier());
} }
while (m_scanner->getCurrentToken() == Token::COMMA); while (m_scanner->getCurrentToken() == Token::Comma);
expectToken(Token::LBRACE); expectToken(Token::LBrace);
while (true) while (true)
{ {
Token::Value currentToken = m_scanner->getCurrentToken(); Token::Value currentToken = m_scanner->getCurrentToken();
if (currentToken == Token::RBRACE) if (currentToken == Token::RBrace)
break; break;
else if (currentToken == Token::FUNCTION) else if (currentToken == Token::Function)
functions.push_back(parseFunctionDefinition(name.get())); functions.push_back(parseFunctionDefinition(name.get()));
else if (currentToken == Token::STRUCT) else if (currentToken == Token::Struct)
structs.push_back(parseStructDefinition()); structs.push_back(parseStructDefinition());
else if (currentToken == Token::IDENTIFIER || currentToken == Token::MAPPING || else if (currentToken == Token::Identifier || currentToken == Token::Mapping ||
Token::isElementaryTypeName(currentToken)) Token::isElementaryTypeName(currentToken))
{ {
VarDeclParserOptions options; VarDeclParserOptions options;
options.isStateVariable = true; options.isStateVariable = true;
stateVariables.push_back(parseVariableDeclaration(options)); stateVariables.push_back(parseVariableDeclaration(options));
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
} }
else if (currentToken == Token::MODIFIER) else if (currentToken == Token::Modifier)
modifiers.push_back(parseModifierDefinition()); modifiers.push_back(parseModifierDefinition());
else if (currentToken == Token::EVENT) else if (currentToken == Token::Event)
events.push_back(parseEventDefinition()); events.push_back(parseEventDefinition());
else else
BOOST_THROW_EXCEPTION(createParserError("Function, variable, struct or modifier declaration expected.")); BOOST_THROW_EXCEPTION(createParserError("Function, variable, struct or modifier declaration expected."));
} }
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RBRACE); expectToken(Token::RBrace);
return nodeFactory.createNode<ContractDefinition>(name, docString, baseContracts, structs, return nodeFactory.createNode<ContractDefinition>(name, docString, baseContracts, structs,
stateVariables, functions, modifiers, events); stateVariables, functions, modifiers, events);
} }
@ -166,12 +166,12 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
ASTPointer<Identifier> name(parseIdentifier()); ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments; vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() == Token::LPAREN) if (m_scanner->getCurrentToken() == Token::LParen)
{ {
m_scanner->next(); m_scanner->next();
arguments = parseFunctionCallListArguments(); arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RPAREN); expectToken(Token::RParen);
} }
else else
nodeFactory.setEndPositionFromNode(name); nodeFactory.setEndPositionFromNode(name);
@ -181,11 +181,11 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token) Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token)
{ {
Declaration::Visibility visibility(Declaration::Visibility::DEFAULT); Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
if (_token == Token::PUBLIC) if (_token == Token::Public)
visibility = Declaration::Visibility::PUBLIC; visibility = Declaration::Visibility::PUBLIC;
else if (_token == Token::PROTECTED) else if (_token == Token::Protected)
visibility = Declaration::Visibility::PROTECTED; visibility = Declaration::Visibility::PROTECTED;
else if (_token == Token::PRIVATE) else if (_token == Token::Private)
visibility = Declaration::Visibility::PRIVATE; visibility = Declaration::Visibility::PRIVATE;
else else
solAssert(false, "Invalid visibility specifier."); solAssert(false, "Invalid visibility specifier.");
@ -200,9 +200,9 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
if (m_scanner->getCurrentCommentLiteral() != "") if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral()); docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::FUNCTION); expectToken(Token::Function);
ASTPointer<ASTString> name; ASTPointer<ASTString> name;
if (m_scanner->getCurrentToken() == Token::LPAREN) if (m_scanner->getCurrentToken() == Token::LParen)
name = make_shared<ASTString>(); // anonymous function name = make_shared<ASTString>(); // anonymous function
else else
name = expectIdentifierToken(); name = expectIdentifierToken();
@ -213,12 +213,12 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
while (true) while (true)
{ {
Token::Value token = m_scanner->getCurrentToken(); Token::Value token = m_scanner->getCurrentToken();
if (token == Token::CONST) if (token == Token::Const)
{ {
isDeclaredConst = true; isDeclaredConst = true;
m_scanner->next(); m_scanner->next();
} }
else if (token == Token::IDENTIFIER) else if (token == Token::Identifier)
modifiers.push_back(parseModifierInvocation()); modifiers.push_back(parseModifierInvocation());
else if (Token::isVisibilitySpecifier(token)) else if (Token::isVisibilitySpecifier(token))
{ {
@ -230,7 +230,7 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
break; break;
} }
ASTPointer<ParameterList> returnParameters; ASTPointer<ParameterList> returnParameters;
if (m_scanner->getCurrentToken() == Token::RETURNS) if (m_scanner->getCurrentToken() == Token::Returns)
{ {
bool const permitEmptyParameterList = false; bool const permitEmptyParameterList = false;
m_scanner->next(); m_scanner->next();
@ -249,17 +249,17 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
ASTPointer<StructDefinition> Parser::parseStructDefinition() ASTPointer<StructDefinition> Parser::parseStructDefinition()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::STRUCT); expectToken(Token::Struct);
ASTPointer<ASTString> name = expectIdentifierToken(); ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<VariableDeclaration>> members; vector<ASTPointer<VariableDeclaration>> members;
expectToken(Token::LBRACE); expectToken(Token::LBrace);
while (m_scanner->getCurrentToken() != Token::RBRACE) while (m_scanner->getCurrentToken() != Token::RBrace)
{ {
members.push_back(parseVariableDeclaration()); members.push_back(parseVariableDeclaration());
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
} }
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RBRACE); expectToken(Token::RBrace);
return nodeFactory.createNode<StructDefinition>(name, members); return nodeFactory.createNode<StructDefinition>(name, members);
} }
@ -275,13 +275,13 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(VarDeclParserOp
Declaration::Visibility visibility(Declaration::Visibility::DEFAULT); Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
if (_options.isStateVariable && Token::isVisibilitySpecifier(token)) if (_options.isStateVariable && Token::isVisibilitySpecifier(token))
visibility = parseVisibilitySpecifier(token); visibility = parseVisibilitySpecifier(token);
if (_options.allowIndexed && token == Token::INDEXED) if (_options.allowIndexed && token == Token::Indexed)
{ {
isIndexed = true; isIndexed = true;
m_scanner->next(); m_scanner->next();
} }
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
if (_options.allowEmptyName && m_scanner->getCurrentToken() != Token::IDENTIFIER) if (_options.allowEmptyName && m_scanner->getCurrentToken() != Token::Identifier)
{ {
identifier = make_shared<ASTString>(""); identifier = make_shared<ASTString>("");
solAssert(type != nullptr, ""); solAssert(type != nullptr, "");
@ -304,10 +304,10 @@ ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
if (m_scanner->getCurrentCommentLiteral() != "") if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral()); docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::MODIFIER); expectToken(Token::Modifier);
ASTPointer<ASTString> name(expectIdentifierToken()); ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters; ASTPointer<ParameterList> parameters;
if (m_scanner->getCurrentToken() == Token::LPAREN) if (m_scanner->getCurrentToken() == Token::LParen)
parameters = parseParameterList(); parameters = parseParameterList();
else else
parameters = createEmptyParameterList(); parameters = createEmptyParameterList();
@ -323,15 +323,15 @@ ASTPointer<EventDefinition> Parser::parseEventDefinition()
if (m_scanner->getCurrentCommentLiteral() != "") if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral()); docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
expectToken(Token::EVENT); expectToken(Token::Event);
ASTPointer<ASTString> name(expectIdentifierToken()); ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters; ASTPointer<ParameterList> parameters;
if (m_scanner->getCurrentToken() == Token::LPAREN) if (m_scanner->getCurrentToken() == Token::LParen)
parameters = parseParameterList(true, true); parameters = parseParameterList(true, true);
else else
parameters = createEmptyParameterList(); parameters = createEmptyParameterList();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
return nodeFactory.createNode<EventDefinition>(name, docstring, parameters); return nodeFactory.createNode<EventDefinition>(name, docstring, parameters);
} }
@ -340,12 +340,12 @@ ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
ASTPointer<Identifier> name(parseIdentifier()); ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments; vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() == Token::LPAREN) if (m_scanner->getCurrentToken() == Token::LParen)
{ {
m_scanner->next(); m_scanner->next();
arguments = parseFunctionCallListArguments(); arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RPAREN); expectToken(Token::RParen);
} }
else else
nodeFactory.setEndPositionFromNode(name); nodeFactory.setEndPositionFromNode(name);
@ -368,17 +368,17 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
type = ASTNodeFactory(*this).createNode<ElementaryTypeName>(token); type = ASTNodeFactory(*this).createNode<ElementaryTypeName>(token);
m_scanner->next(); m_scanner->next();
} }
else if (token == Token::VAR) else if (token == Token::Var)
{ {
if (!_allowVar) if (!_allowVar)
BOOST_THROW_EXCEPTION(createParserError("Expected explicit type name.")); BOOST_THROW_EXCEPTION(createParserError("Expected explicit type name."));
m_scanner->next(); m_scanner->next();
} }
else if (token == Token::MAPPING) else if (token == Token::Mapping)
{ {
type = parseMapping(); type = parseMapping();
} }
else if (token == Token::IDENTIFIER) else if (token == Token::Identifier)
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
@ -392,18 +392,18 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
ASTPointer<Mapping> Parser::parseMapping() ASTPointer<Mapping> Parser::parseMapping()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::MAPPING); expectToken(Token::Mapping);
expectToken(Token::LPAREN); expectToken(Token::LParen);
if (!Token::isElementaryTypeName(m_scanner->getCurrentToken())) if (!Token::isElementaryTypeName(m_scanner->getCurrentToken()))
BOOST_THROW_EXCEPTION(createParserError("Expected elementary type name for mapping key type")); BOOST_THROW_EXCEPTION(createParserError("Expected elementary type name for mapping key type"));
ASTPointer<ElementaryTypeName> keyType; ASTPointer<ElementaryTypeName> keyType;
keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(m_scanner->getCurrentToken()); keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(m_scanner->getCurrentToken());
m_scanner->next(); m_scanner->next();
expectToken(Token::ARROW); expectToken(Token::Arrow);
bool const allowVar = false; bool const allowVar = false;
ASTPointer<TypeName> valueType = parseTypeName(allowVar); ASTPointer<TypeName> valueType = parseTypeName(allowVar);
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RPAREN); expectToken(Token::RParen);
return nodeFactory.createNode<Mapping>(keyType, valueType); return nodeFactory.createNode<Mapping>(keyType, valueType);
} }
@ -414,13 +414,13 @@ ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty, bool _all
VarDeclParserOptions options; VarDeclParserOptions options;
options.allowIndexed = _allowIndexed; options.allowIndexed = _allowIndexed;
options.allowEmptyName = true; options.allowEmptyName = true;
expectToken(Token::LPAREN); expectToken(Token::LParen);
if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN) if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RParen)
{ {
parameters.push_back(parseVariableDeclaration(options)); parameters.push_back(parseVariableDeclaration(options));
while (m_scanner->getCurrentToken() != Token::RPAREN) while (m_scanner->getCurrentToken() != Token::RParen)
{ {
expectToken(Token::COMMA); expectToken(Token::Comma);
parameters.push_back(parseVariableDeclaration(options)); parameters.push_back(parseVariableDeclaration(options));
} }
} }
@ -432,12 +432,12 @@ ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty, bool _all
ASTPointer<Block> Parser::parseBlock() ASTPointer<Block> Parser::parseBlock()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::LBRACE); expectToken(Token::LBrace);
vector<ASTPointer<Statement>> statements; vector<ASTPointer<Statement>> statements;
while (m_scanner->getCurrentToken() != Token::RBRACE) while (m_scanner->getCurrentToken() != Token::RBrace)
statements.push_back(parseStatement()); statements.push_back(parseStatement());
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RBRACE); expectToken(Token::RBrace);
return nodeFactory.createNode<Block>(statements); return nodeFactory.createNode<Block>(statements);
} }
@ -446,28 +446,28 @@ ASTPointer<Statement> Parser::parseStatement()
ASTPointer<Statement> statement; ASTPointer<Statement> statement;
switch (m_scanner->getCurrentToken()) switch (m_scanner->getCurrentToken())
{ {
case Token::IF: case Token::If:
return parseIfStatement(); return parseIfStatement();
case Token::WHILE: case Token::While:
return parseWhileStatement(); return parseWhileStatement();
case Token::FOR: case Token::For:
return parseForStatement(); return parseForStatement();
case Token::LBRACE: case Token::LBrace:
return parseBlock(); return parseBlock();
// starting from here, all statements must be terminated by a semicolon // starting from here, all statements must be terminated by a semicolon
case Token::CONTINUE: case Token::Continue:
statement = ASTNodeFactory(*this).createNode<Continue>(); statement = ASTNodeFactory(*this).createNode<Continue>();
m_scanner->next(); m_scanner->next();
break; break;
case Token::BREAK: case Token::Break:
statement = ASTNodeFactory(*this).createNode<Break>(); statement = ASTNodeFactory(*this).createNode<Break>();
m_scanner->next(); m_scanner->next();
break; break;
case Token::RETURN: case Token::Return:
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression; ASTPointer<Expression> expression;
if (m_scanner->next() != Token::SEMICOLON) if (m_scanner->next() != Token::Semicolon)
{ {
expression = parseExpression(); expression = parseExpression();
nodeFactory.setEndPositionFromNode(expression); nodeFactory.setEndPositionFromNode(expression);
@ -475,7 +475,7 @@ ASTPointer<Statement> Parser::parseStatement()
statement = nodeFactory.createNode<Return>(expression); statement = nodeFactory.createNode<Return>(expression);
break; break;
} }
case Token::IDENTIFIER: case Token::Identifier:
if (m_insideModifier && m_scanner->getCurrentLiteral() == "_") if (m_insideModifier && m_scanner->getCurrentLiteral() == "_")
{ {
statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>(); statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>();
@ -486,20 +486,20 @@ ASTPointer<Statement> Parser::parseStatement()
default: default:
statement = parseVarDefOrExprStmt(); statement = parseVarDefOrExprStmt();
} }
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
return statement; return statement;
} }
ASTPointer<IfStatement> Parser::parseIfStatement() ASTPointer<IfStatement> Parser::parseIfStatement()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::IF); expectToken(Token::If);
expectToken(Token::LPAREN); expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression(); ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RPAREN); expectToken(Token::RParen);
ASTPointer<Statement> trueBody = parseStatement(); ASTPointer<Statement> trueBody = parseStatement();
ASTPointer<Statement> falseBody; ASTPointer<Statement> falseBody;
if (m_scanner->getCurrentToken() == Token::ELSE) if (m_scanner->getCurrentToken() == Token::Else)
{ {
m_scanner->next(); m_scanner->next();
falseBody = parseStatement(); falseBody = parseStatement();
@ -513,10 +513,10 @@ ASTPointer<IfStatement> Parser::parseIfStatement()
ASTPointer<WhileStatement> Parser::parseWhileStatement() ASTPointer<WhileStatement> Parser::parseWhileStatement()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
expectToken(Token::WHILE); expectToken(Token::While);
expectToken(Token::LPAREN); expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression(); ASTPointer<Expression> condition = parseExpression();
expectToken(Token::RPAREN); expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement(); ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body); nodeFactory.setEndPositionFromNode(body);
return nodeFactory.createNode<WhileStatement>(condition, body); return nodeFactory.createNode<WhileStatement>(condition, body);
@ -528,21 +528,21 @@ ASTPointer<ForStatement> Parser::parseForStatement()
ASTPointer<Statement> initExpression; ASTPointer<Statement> initExpression;
ASTPointer<Expression> conditionExpression; ASTPointer<Expression> conditionExpression;
ASTPointer<ExpressionStatement> loopExpression; ASTPointer<ExpressionStatement> loopExpression;
expectToken(Token::FOR); expectToken(Token::For);
expectToken(Token::LPAREN); expectToken(Token::LParen);
// LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RPAREN? // LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RParen?
if (m_scanner->getCurrentToken() != Token::SEMICOLON) if (m_scanner->getCurrentToken() != Token::Semicolon)
initExpression = parseVarDefOrExprStmt(); initExpression = parseVarDefOrExprStmt();
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
if (m_scanner->getCurrentToken() != Token::SEMICOLON) if (m_scanner->getCurrentToken() != Token::Semicolon)
conditionExpression = parseExpression(); conditionExpression = parseExpression();
expectToken(Token::SEMICOLON); expectToken(Token::Semicolon);
if (m_scanner->getCurrentToken() != Token::RPAREN) if (m_scanner->getCurrentToken() != Token::RParen)
loopExpression = parseExpressionStatement(); loopExpression = parseExpressionStatement();
expectToken(Token::RPAREN); expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement(); ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body); nodeFactory.setEndPositionFromNode(body);
@ -567,7 +567,7 @@ ASTPointer<VariableDefinition> Parser::parseVariableDefinition()
options.allowVar = true; options.allowVar = true;
ASTPointer<VariableDeclaration> variable = parseVariableDeclaration(options); ASTPointer<VariableDeclaration> variable = parseVariableDeclaration(options);
ASTPointer<Expression> value; ASTPointer<Expression> value;
if (m_scanner->getCurrentToken() == Token::ASSIGN) if (m_scanner->getCurrentToken() == Token::Assign)
{ {
m_scanner->next(); m_scanner->next();
value = parseExpression(); value = parseExpression();
@ -644,9 +644,9 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
{ {
ASTNodeFactory nodeFactory(*this); ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression; ASTPointer<Expression> expression;
if (m_scanner->getCurrentToken() == Token::NEW) if (m_scanner->getCurrentToken() == Token::New)
{ {
expectToken(Token::NEW); expectToken(Token::New);
ASTPointer<Identifier> contractName(parseIdentifier()); ASTPointer<Identifier> contractName(parseIdentifier());
nodeFactory.setEndPositionFromNode(contractName); nodeFactory.setEndPositionFromNode(contractName);
expression = nodeFactory.createNode<NewExpression>(contractName); expression = nodeFactory.createNode<NewExpression>(contractName);
@ -658,30 +658,30 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
{ {
switch (m_scanner->getCurrentToken()) switch (m_scanner->getCurrentToken())
{ {
case Token::LBRACK: case Token::LBrack:
{ {
m_scanner->next(); m_scanner->next();
ASTPointer<Expression> index = parseExpression(); ASTPointer<Expression> index = parseExpression();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RBRACK); expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexAccess>(expression, index); expression = nodeFactory.createNode<IndexAccess>(expression, index);
} }
break; break;
case Token::PERIOD: case Token::Period:
{ {
m_scanner->next(); m_scanner->next();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken()); expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
} }
break; break;
case Token::LPAREN: case Token::LParen:
{ {
m_scanner->next(); m_scanner->next();
vector<ASTPointer<Expression>> arguments; vector<ASTPointer<Expression>> arguments;
vector<ASTPointer<ASTString>> names; vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments(); std::tie(arguments, names) = parseFunctionCallArguments();
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expectToken(Token::RPAREN); expectToken(Token::RParen);
expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names); expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names);
} }
break; break;
@ -698,11 +698,11 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
ASTPointer<Expression> expression; ASTPointer<Expression> expression;
switch (token) switch (token)
{ {
case Token::TRUE_LITERAL: case Token::TrueLiteral:
case Token::FALSE_LITERAL: case Token::FalseLiteral:
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance()); expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break; break;
case Token::NUMBER: case Token::Number:
if (Token::isEtherSubdenomination(m_scanner->peekNextToken())) if (Token::isEtherSubdenomination(m_scanner->peekNextToken()))
{ {
ASTPointer<ASTString> literal = getLiteralAndAdvance(); ASTPointer<ASTString> literal = getLiteralAndAdvance();
@ -713,19 +713,19 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
break; break;
} }
// fall-through // fall-through
case Token::STRING_LITERAL: case Token::StringLiteral:
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance()); expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break; break;
case Token::IDENTIFIER: case Token::Identifier:
nodeFactory.markEndPosition(); nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance()); expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
break; break;
case Token::LPAREN: case Token::LParen:
{ {
m_scanner->next(); m_scanner->next();
ASTPointer<Expression> expression = parseExpression(); ASTPointer<Expression> expression = parseExpression();
expectToken(Token::RPAREN); expectToken(Token::RParen);
return expression; return expression;
} }
default: default:
@ -748,12 +748,12 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments() vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments()
{ {
vector<ASTPointer<Expression>> arguments; vector<ASTPointer<Expression>> arguments;
if (m_scanner->getCurrentToken() != Token::RPAREN) if (m_scanner->getCurrentToken() != Token::RParen)
{ {
arguments.push_back(parseExpression()); arguments.push_back(parseExpression());
while (m_scanner->getCurrentToken() != Token::RPAREN) while (m_scanner->getCurrentToken() != Token::RParen)
{ {
expectToken(Token::COMMA); expectToken(Token::Comma);
arguments.push_back(parseExpression()); arguments.push_back(parseExpression());
} }
} }
@ -764,22 +764,22 @@ pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::pars
{ {
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret; pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
Token::Value token = m_scanner->getCurrentToken(); Token::Value token = m_scanner->getCurrentToken();
if (token == Token::LBRACE) if (token == Token::LBrace)
{ {
// call({arg1 : 1, arg2 : 2 }) // call({arg1 : 1, arg2 : 2 })
expectToken(Token::LBRACE); expectToken(Token::LBrace);
while (m_scanner->getCurrentToken() != Token::RBRACE) while (m_scanner->getCurrentToken() != Token::RBrace)
{ {
ret.second.push_back(expectIdentifierToken()); ret.second.push_back(expectIdentifierToken());
expectToken(Token::COLON); expectToken(Token::Colon);
ret.first.push_back(parseExpression()); ret.first.push_back(parseExpression());
if (m_scanner->getCurrentToken() == Token::COMMA) if (m_scanner->getCurrentToken() == Token::Comma)
expectToken(Token::COMMA); expectToken(Token::Comma);
else else
break; break;
} }
expectToken(Token::RBRACE); expectToken(Token::RBrace);
} }
else else
ret.first = parseFunctionCallListArguments(); ret.first = parseFunctionCallListArguments();
@ -793,11 +793,11 @@ bool Parser::peekVariableDefinition()
// (which include assignments to other expressions and pre-declared variables) // (which include assignments to other expressions and pre-declared variables)
// We have a variable definition if we get a keyword that specifies a type name, or // We have a variable definition if we get a keyword that specifies a type name, or
// in the case of a user-defined type, we have two identifiers following each other. // in the case of a user-defined type, we have two identifiers following each other.
return (m_scanner->getCurrentToken() == Token::MAPPING || return (m_scanner->getCurrentToken() == Token::Mapping ||
m_scanner->getCurrentToken() == Token::VAR || m_scanner->getCurrentToken() == Token::Var ||
((Token::isElementaryTypeName(m_scanner->getCurrentToken()) || ((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
m_scanner->getCurrentToken() == Token::IDENTIFIER) && m_scanner->getCurrentToken() == Token::Identifier) &&
m_scanner->peekNextToken() == Token::IDENTIFIER)); m_scanner->peekNextToken() == Token::Identifier));
} }
void Parser::expectToken(Token::Value _value) void Parser::expectToken(Token::Value _value)
@ -818,7 +818,7 @@ Token::Value Parser::expectAssignmentOperator()
ASTPointer<ASTString> Parser::expectIdentifierToken() ASTPointer<ASTString> Parser::expectIdentifierToken()
{ {
if (m_scanner->getCurrentToken() != Token::IDENTIFIER) if (m_scanner->getCurrentToken() != Token::Identifier)
BOOST_THROW_EXCEPTION(createParserError("Expected identifier")); BOOST_THROW_EXCEPTION(createParserError("Expected identifier"));
return getLiteralAndAdvance(); return getLiteralAndAdvance();
} }

126
Scanner.cpp
View File

@ -225,7 +225,7 @@ Token::Value Scanner::skipSingleLineComment()
// separately by the lexical grammar and becomes part of the // separately by the lexical grammar and becomes part of the
// stream of input elements for the syntactic grammar // stream of input elements for the syntactic grammar
while (advance() && !isLineTerminator(m_char)) { }; while (advance() && !isLineTerminator(m_char)) { };
return Token::WHITESPACE; return Token::Whitespace;
} }
Token::Value Scanner::scanSingleLineDocComment() Token::Value Scanner::scanSingleLineDocComment()
@ -255,7 +255,7 @@ Token::Value Scanner::scanSingleLineDocComment()
advance(); advance();
} }
literal.complete(); literal.complete();
return Token::COMMENT_LITERAL; return Token::CommentLiteral;
} }
Token::Value Scanner::skipMultiLineComment() Token::Value Scanner::skipMultiLineComment()
@ -272,11 +272,11 @@ Token::Value Scanner::skipMultiLineComment()
if (ch == '*' && m_char == '/') if (ch == '*' && m_char == '/')
{ {
m_char = ' '; m_char = ' ';
return Token::WHITESPACE; return Token::Whitespace;
} }
} }
// Unterminated multi-line comment. // Unterminated multi-line comment.
return Token::ILLEGAL; return Token::Illegal;
} }
Token::Value Scanner::scanMultiLineDocComment() Token::Value Scanner::scanMultiLineDocComment()
@ -319,9 +319,9 @@ Token::Value Scanner::scanMultiLineDocComment()
} }
literal.complete(); literal.complete();
if (!endFound) if (!endFound)
return Token::ILLEGAL; return Token::Illegal;
else else
return Token::COMMENT_LITERAL; return Token::CommentLiteral;
} }
Token::Value Scanner::scanSlash() Token::Value Scanner::scanSlash()
@ -331,7 +331,7 @@ Token::Value Scanner::scanSlash()
if (m_char == '/') if (m_char == '/')
{ {
if (!advance()) /* double slash comment directly before EOS */ if (!advance()) /* double slash comment directly before EOS */
return Token::WHITESPACE; return Token::Whitespace;
else if (m_char == '/') else if (m_char == '/')
{ {
// doxygen style /// comment // doxygen style /// comment
@ -340,7 +340,7 @@ Token::Value Scanner::scanSlash()
comment = scanSingleLineDocComment(); comment = scanSingleLineDocComment();
m_nextSkippedComment.location.end = getSourcePos(); m_nextSkippedComment.location.end = getSourcePos();
m_nextSkippedComment.token = comment; m_nextSkippedComment.token = comment;
return Token::WHITESPACE; return Token::Whitespace;
} }
else else
return skipSingleLineComment(); return skipSingleLineComment();
@ -349,7 +349,7 @@ Token::Value Scanner::scanSlash()
{ {
// doxygen style /** natspec comment // doxygen style /** natspec comment
if (!advance()) /* slash star comment before EOS */ if (!advance()) /* slash star comment before EOS */
return Token::WHITESPACE; return Token::Whitespace;
else if (m_char == '*') else if (m_char == '*')
{ {
advance(); //consume the last '*' at /** advance(); //consume the last '*' at /**
@ -366,15 +366,15 @@ Token::Value Scanner::scanSlash()
m_nextSkippedComment.location.end = getSourcePos(); m_nextSkippedComment.location.end = getSourcePos();
m_nextSkippedComment.token = comment; m_nextSkippedComment.token = comment;
} }
return Token::WHITESPACE; return Token::Whitespace;
} }
else else
return skipMultiLineComment(); return skipMultiLineComment();
} }
else if (m_char == '=') else if (m_char == '=')
return selectToken(Token::ASSIGN_DIV); return selectToken(Token::AssignDiv);
else else
return Token::DIV; return Token::Div;
} }
void Scanner::scanToken() void Scanner::scanToken()
@ -391,7 +391,7 @@ void Scanner::scanToken()
case '\n': // fall-through case '\n': // fall-through
case ' ': case ' ':
case '\t': case '\t':
token = selectToken(Token::WHITESPACE); token = selectToken(Token::Whitespace);
break; break;
case '"': case '"':
case '\'': case '\'':
@ -401,76 +401,76 @@ void Scanner::scanToken()
// < <= << <<= // < <= << <<=
advance(); advance();
if (m_char == '=') if (m_char == '=')
token = selectToken(Token::LTE); token = selectToken(Token::LessThanOrEquals);
else if (m_char == '<') else if (m_char == '<')
token = selectToken('=', Token::ASSIGN_SHL, Token::SHL); token = selectToken('=', Token::AssignShl, Token::SHL);
else else
token = Token::LT; token = Token::LessThan;
break; break;
case '>': case '>':
// > >= >> >>= >>> >>>= // > >= >> >>= >>> >>>=
advance(); advance();
if (m_char == '=') if (m_char == '=')
token = selectToken(Token::GTE); token = selectToken(Token::GreaterThanOrEquals);
else if (m_char == '>') else if (m_char == '>')
{ {
// >> >>= >>> >>>= // >> >>= >>> >>>=
advance(); advance();
if (m_char == '=') if (m_char == '=')
token = selectToken(Token::ASSIGN_SAR); token = selectToken(Token::AssignSar);
else if (m_char == '>') else if (m_char == '>')
token = selectToken('=', Token::ASSIGN_SHR, Token::SHR); token = selectToken('=', Token::AssignShr, Token::SHR);
else else
token = Token::SAR; token = Token::SAR;
} }
else else
token = Token::GT; token = Token::GreaterThan;
break; break;
case '=': case '=':
// = == => // = == =>
advance(); advance();
if (m_char == '=') if (m_char == '=')
token = selectToken(Token::EQ); token = selectToken(Token::Equals);
else if (m_char == '>') else if (m_char == '>')
token = selectToken(Token::ARROW); token = selectToken(Token::Arrow);
else else
token = Token::ASSIGN; token = Token::Assign;
break; break;
case '!': case '!':
// ! != // ! !=
advance(); advance();
if (m_char == '=') if (m_char == '=')
token = selectToken(Token::NE); token = selectToken(Token::NotEquals);
else else
token = Token::NOT; token = Token::Not;
break; break;
case '+': case '+':
// + ++ += // + ++ +=
advance(); advance();
if (m_char == '+') if (m_char == '+')
token = selectToken(Token::INC); token = selectToken(Token::Inc);
else if (m_char == '=') else if (m_char == '=')
token = selectToken(Token::ASSIGN_ADD); token = selectToken(Token::AssignAdd);
else else
token = Token::ADD; token = Token::Add;
break; break;
case '-': case '-':
// - -- -= // - -- -=
advance(); advance();
if (m_char == '-') if (m_char == '-')
token = selectToken(Token::DEC); token = selectToken(Token::Dec);
else if (m_char == '=') else if (m_char == '=')
token = selectToken(Token::ASSIGN_SUB); token = selectToken(Token::AssignSub);
else else
token = Token::SUB; token = Token::Sub;
break; break;
case '*': case '*':
// * *= // * *=
token = selectToken('=', Token::ASSIGN_MUL, Token::MUL); token = selectToken('=', Token::AssignMul, Token::Mul);
break; break;
case '%': case '%':
// % %= // % %=
token = selectToken('=', Token::ASSIGN_MOD, Token::MOD); token = selectToken('=', Token::AssignMod, Token::Mod);
break; break;
case '/': case '/':
// / // /* /= // / // /* /=
@ -480,25 +480,25 @@ void Scanner::scanToken()
// & && &= // & && &=
advance(); advance();
if (m_char == '&') if (m_char == '&')
token = selectToken(Token::AND); token = selectToken(Token::And);
else if (m_char == '=') else if (m_char == '=')
token = selectToken(Token::ASSIGN_BIT_AND); token = selectToken(Token::AssignBitAnd);
else else
token = Token::BIT_AND; token = Token::BitAnd;
break; break;
case '|': case '|':
// | || |= // | || |=
advance(); advance();
if (m_char == '|') if (m_char == '|')
token = selectToken(Token::OR); token = selectToken(Token::Or);
else if (m_char == '=') else if (m_char == '=')
token = selectToken(Token::ASSIGN_BIT_OR); token = selectToken(Token::AssignBitOr);
else else
token = Token::BIT_OR; token = Token::BitOr;
break; break;
case '^': case '^':
// ^ ^= // ^ ^=
token = selectToken('=', Token::ASSIGN_BIT_XOR, Token::BIT_XOR); token = selectToken('=', Token::AssignBitXor, Token::BitXor);
break; break;
case '.': case '.':
// . Number // . Number
@ -506,40 +506,40 @@ void Scanner::scanToken()
if (isDecimalDigit(m_char)) if (isDecimalDigit(m_char))
token = scanNumber('.'); token = scanNumber('.');
else else
token = Token::PERIOD; token = Token::Period;
break; break;
case ':': case ':':
token = selectToken(Token::COLON); token = selectToken(Token::Colon);
break; break;
case ';': case ';':
token = selectToken(Token::SEMICOLON); token = selectToken(Token::Semicolon);
break; break;
case ',': case ',':
token = selectToken(Token::COMMA); token = selectToken(Token::Comma);
break; break;
case '(': case '(':
token = selectToken(Token::LPAREN); token = selectToken(Token::LParen);
break; break;
case ')': case ')':
token = selectToken(Token::RPAREN); token = selectToken(Token::RParen);
break; break;
case '[': case '[':
token = selectToken(Token::LBRACK); token = selectToken(Token::LBrack);
break; break;
case ']': case ']':
token = selectToken(Token::RBRACK); token = selectToken(Token::RBrack);
break; break;
case '{': case '{':
token = selectToken(Token::LBRACE); token = selectToken(Token::LBrace);
break; break;
case '}': case '}':
token = selectToken(Token::RBRACE); token = selectToken(Token::RBrace);
break; break;
case '?': case '?':
token = selectToken(Token::CONDITIONAL); token = selectToken(Token::Conditional);
break; break;
case '~': case '~':
token = selectToken(Token::BIT_NOT); token = selectToken(Token::BitNot);
break; break;
default: default:
if (isIdentifierStart(m_char)) if (isIdentifierStart(m_char))
@ -547,17 +547,17 @@ void Scanner::scanToken()
else if (isDecimalDigit(m_char)) else if (isDecimalDigit(m_char))
token = scanNumber(); token = scanNumber();
else if (skipWhitespace()) else if (skipWhitespace())
token = Token::WHITESPACE; token = Token::Whitespace;
else if (isSourcePastEndOfInput()) else if (isSourcePastEndOfInput())
token = Token::EOS; token = Token::EOS;
else else
token = selectToken(Token::ILLEGAL); token = selectToken(Token::Illegal);
break; break;
} }
// Continue scanning for tokens as long as we're just skipping // Continue scanning for tokens as long as we're just skipping
// whitespace. // whitespace.
} }
while (token == Token::WHITESPACE); while (token == Token::Whitespace);
m_nextToken.location.end = getSourcePos(); m_nextToken.location.end = getSourcePos();
m_nextToken.token = token; m_nextToken.token = token;
} }
@ -615,16 +615,16 @@ Token::Value Scanner::scanString()
if (c == '\\') if (c == '\\')
{ {
if (isSourcePastEndOfInput() || !scanEscape()) if (isSourcePastEndOfInput() || !scanEscape())
return Token::ILLEGAL; return Token::Illegal;
} }
else else
addLiteralChar(c); addLiteralChar(c);
} }
if (m_char != quote) if (m_char != quote)
return Token::ILLEGAL; return Token::Illegal;
literal.complete(); literal.complete();
advance(); // consume quote advance(); // consume quote
return Token::STRING_LITERAL; return Token::StringLiteral;
} }
void Scanner::scanDecimalDigits() void Scanner::scanDecimalDigits()
@ -657,7 +657,7 @@ Token::Value Scanner::scanNumber(char _charSeen)
kind = HEX; kind = HEX;
addLiteralCharAndAdvance(); addLiteralCharAndAdvance();
if (!isHexDigit(m_char)) if (!isHexDigit(m_char))
return Token::ILLEGAL; // we must have at least one hex digit after 'x'/'X' return Token::Illegal; // we must have at least one hex digit after 'x'/'X'
while (isHexDigit(m_char)) while (isHexDigit(m_char))
addLiteralCharAndAdvance(); addLiteralCharAndAdvance();
} }
@ -678,13 +678,13 @@ Token::Value Scanner::scanNumber(char _charSeen)
{ {
solAssert(kind != HEX, "'e'/'E' must be scanned as part of the hex number"); solAssert(kind != HEX, "'e'/'E' must be scanned as part of the hex number");
if (kind != DECIMAL) if (kind != DECIMAL)
return Token::ILLEGAL; return Token::Illegal;
// scan exponent // scan exponent
addLiteralCharAndAdvance(); addLiteralCharAndAdvance();
if (m_char == '+' || m_char == '-') if (m_char == '+' || m_char == '-')
addLiteralCharAndAdvance(); addLiteralCharAndAdvance();
if (!isDecimalDigit(m_char)) if (!isDecimalDigit(m_char))
return Token::ILLEGAL; // we must have at least one decimal digit after 'e'/'E' return Token::Illegal; // we must have at least one decimal digit after 'e'/'E'
scanDecimalDigits(); scanDecimalDigits();
} }
// The source character immediately following a numeric literal must // The source character immediately following a numeric literal must
@ -692,9 +692,9 @@ Token::Value Scanner::scanNumber(char _charSeen)
// section 7.8.3, page 17 (note that we read only one decimal digit // section 7.8.3, page 17 (note that we read only one decimal digit
// if the value is 0). // if the value is 0).
if (isDecimalDigit(m_char) || isIdentifierStart(m_char)) if (isDecimalDigit(m_char) || isIdentifierStart(m_char))
return Token::ILLEGAL; return Token::Illegal;
literal.complete(); literal.complete();
return Token::NUMBER; return Token::Number;
} }
Token::Value Scanner::scanIdentifierOrKeyword() Token::Value Scanner::scanIdentifierOrKeyword()

4
Token.cpp
View File

@ -79,8 +79,8 @@ int8_t const Token::m_precedence[NUM_TOKENS] =
char const Token::m_tokenType[] = char const Token::m_tokenType[] =
{ {
TOKEN_LIST(KT, KK) TOKEN_LIST(KT, KK)
};
};
Token::Value Token::fromIdentifierOrKeyword(const std::string& _name) Token::Value Token::fromIdentifierOrKeyword(const std::string& _name)
{ {
// The following macros are used inside TOKEN_LIST and cause non-keyword tokens to be ignored // The following macros are used inside TOKEN_LIST and cause non-keyword tokens to be ignored
@ -91,7 +91,7 @@ Token::Value Token::fromIdentifierOrKeyword(const std::string& _name)
#undef KEYWORD #undef KEYWORD
#undef TOKEN #undef TOKEN
auto it = keywords.find(_name); auto it = keywords.find(_name);
return it == keywords.end() ? Token::IDENTIFIER : it->second; return it == keywords.end() ? Token::Identifier : it->second;
} }
#undef KT #undef KT

471
Token.h
View File

@ -47,11 +47,6 @@
#include <libsolidity/Utils.h> #include <libsolidity/Utils.h>
#include <libsolidity/Exceptions.h> #include <libsolidity/Exceptions.h>
#if defined(DELETE)
#undef DELETE
//#error The macro "DELETE" from windows.h conflicts with this file. Please change the order of includes.
#endif
namespace dev namespace dev
{ {
namespace solidity namespace solidity
@ -77,101 +72,101 @@ namespace solidity
T(EOS, "EOS", 0) \ T(EOS, "EOS", 0) \
\ \
/* Punctuators (ECMA-262, section 7.7, page 15). */ \ /* Punctuators (ECMA-262, section 7.7, page 15). */ \
T(LPAREN, "(", 0) \ T(LParen, "(", 0) \
T(RPAREN, ")", 0) \ T(RParen, ")", 0) \
T(LBRACK, "[", 0) \ T(LBrack, "[", 0) \
T(RBRACK, "]", 0) \ T(RBrack, "]", 0) \
T(LBRACE, "{", 0) \ T(LBrace, "{", 0) \
T(RBRACE, "}", 0) \ T(RBrace, "}", 0) \
T(COLON, ":", 0) \ T(Colon, ":", 0) \
T(SEMICOLON, ";", 0) \ T(Semicolon, ";", 0) \
T(PERIOD, ".", 0) \ T(Period, ".", 0) \
T(CONDITIONAL, "?", 3) \ T(Conditional, "?", 3) \
T(ARROW, "=>", 0) \ T(Arrow, "=>", 0) \
\ \
/* Assignment operators. */ \ /* Assignment operators. */ \
/* IsAssignmentOp() relies on this block of enum values being */ \ /* IsAssignmentOp() relies on this block of enum values being */ \
/* contiguous and sorted in the same order!*/ \ /* contiguous and sorted in the same order!*/ \
T(ASSIGN, "=", 2) \ T(Assign, "=", 2) \
/* The following have to be in exactly the same order as the simple binary operators*/ \ /* The following have to be in exactly the same order as the simple binary operators*/ \
T(ASSIGN_BIT_OR, "|=", 2) \ T(AssignBitOr, "|=", 2) \
T(ASSIGN_BIT_XOR, "^=", 2) \ T(AssignBitXor, "^=", 2) \
T(ASSIGN_BIT_AND, "&=", 2) \ T(AssignBitAnd, "&=", 2) \
T(ASSIGN_SHL, "<<=", 2) \ T(AssignShl, "<<=", 2) \
T(ASSIGN_SAR, ">>=", 2) \ T(AssignSar, ">>=", 2) \
T(ASSIGN_SHR, ">>>=", 2) \ T(AssignShr, ">>>=", 2) \
T(ASSIGN_ADD, "+=", 2) \ T(AssignAdd, "+=", 2) \
T(ASSIGN_SUB, "-=", 2) \ T(AssignSub, "-=", 2) \
T(ASSIGN_MUL, "*=", 2) \ T(AssignMul, "*=", 2) \
T(ASSIGN_DIV, "/=", 2) \ T(AssignDiv, "/=", 2) \
T(ASSIGN_MOD, "%=", 2) \ T(AssignMod, "%=", 2) \
\ \
/* Binary operators sorted by precedence. */ \ /* Binary operators sorted by precedence. */ \
/* IsBinaryOp() relies on this block of enum values */ \ /* IsBinaryOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \ /* being contiguous and sorted in the same order! */ \
T(COMMA, ",", 1) \ T(Comma, ",", 1) \
T(OR, "||", 4) \ T(Or, "||", 4) \
T(AND, "&&", 5) \ T(And, "&&", 5) \
T(BIT_OR, "|", 8) \ T(BitOr, "|", 8) \
T(BIT_XOR, "^", 9) \ T(BitXor, "^", 9) \
T(BIT_AND, "&", 10) \ T(BitAnd, "&", 10) \
T(SHL, "<<", 11) \ T(SHL, "<<", 11) \
T(SAR, ">>", 11) \ T(SAR, ">>", 11) \
T(SHR, ">>>", 11) \ T(SHR, ">>>", 11) \
T(ADD, "+", 12) \ T(Add, "+", 12) \
T(SUB, "-", 12) \ T(Sub, "-", 12) \
T(MUL, "*", 13) \ T(Mul, "*", 13) \
T(DIV, "/", 13) \ T(Div, "/", 13) \
T(MOD, "%", 13) \ T(Mod, "%", 13) \
\ \
/* Compare operators sorted by precedence. */ \ /* Compare operators sorted by precedence. */ \
/* IsCompareOp() relies on this block of enum values */ \ /* IsCompareOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \ /* being contiguous and sorted in the same order! */ \
T(EQ, "==", 6) \ T(Equals, "==", 6) \
T(NE, "!=", 6) \ T(NotEquals, "!=", 6) \
T(LT, "<", 7) \ T(LessThan, "<", 7) \
T(GT, ">", 7) \ T(GreaterThan, ">", 7) \
T(LTE, "<=", 7) \ T(LessThanOrEquals, "<=", 7) \
T(GTE, ">=", 7) \ T(GreaterThanOrEquals, ">=", 7) \
K(IN, "in", 7) \ K(In, "in", 7) \
\ \
/* Unary operators. */ \ /* Unary operators. */ \
/* IsUnaryOp() relies on this block of enum values */ \ /* IsUnaryOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \ /* being contiguous and sorted in the same order! */ \
T(NOT, "!", 0) \ T(Not, "!", 0) \
T(BIT_NOT, "~", 0) \ T(BitNot, "~", 0) \
T(INC, "++", 0) \ T(Inc, "++", 0) \
T(DEC, "--", 0) \ T(Dec, "--", 0) \
K(DELETE, "delete", 0) \ K(Delete, "delete", 0) \
\ \
/* Keywords */ \ /* Keywords */ \
K(BREAK, "break", 0) \ K(Break, "break", 0) \
K(CASE, "case", 0) \ K(Case, "case", 0) \
K(CONST, "constant", 0) \ K(Const, "constant", 0) \
K(CONTINUE, "continue", 0) \ K(Continue, "continue", 0) \
K(CONTRACT, "contract", 0) \ K(Contract, "contract", 0) \
K(DEFAULT, "default", 0) \ K(Default, "default", 0) \
K(DO, "do", 0) \ K(Do, "do", 0) \
K(ELSE, "else", 0) \ K(Else, "else", 0) \
K(EVENT, "event", 0) \ K(Event, "event", 0) \
K(IS, "is", 0) \ K(Is, "is", 0) \
K(INDEXED, "indexed", 0) \ K(Indexed, "indexed", 0) \
K(FOR, "for", 0) \ K(For, "for", 0) \
K(FUNCTION, "function", 0) \ K(Function, "function", 0) \
K(IF, "if", 0) \ K(If, "if", 0) \
K(IMPORT, "import", 0) \ K(Import, "import", 0) \
K(MAPPING, "mapping", 0) \ K(Mapping, "mapping", 0) \
K(MODIFIER, "modifier", 0) \ K(Modifier, "modifier", 0) \
K(NEW, "new", 0) \ K(New, "new", 0) \
K(PUBLIC, "public", 0) \ K(Public, "public", 0) \
K(PRIVATE, "private", 0) \ K(Private, "private", 0) \
K(PROTECTED, "protected", 0) \ K(Protected, "protected", 0) \
K(RETURN, "return", 0) \ K(Return, "return", 0) \
K(RETURNS, "returns", 0) \ K(Returns, "returns", 0) \
K(STRUCT, "struct", 0) \ K(Struct, "struct", 0) \
K(SWITCH, "switch", 0) \ K(Switch, "switch", 0) \
K(VAR, "var", 0) \ K(Var, "var", 0) \
K(WHILE, "while", 0) \ K(While, "while", 0) \
\ \
\ \
/* Ether subdenominations */ \ /* Ether subdenominations */ \
@ -182,162 +177,162 @@ namespace solidity
/* type keywords, keep them in this order, keep int as first keyword /* type keywords, keep them in this order, keep int as first keyword
* the implementation in Types.cpp has to be synced to this here * the implementation in Types.cpp has to be synced to this here
* TODO more to be added */ \ * TODO more to be added */ \
K(INT, "int", 0) \ K(Int, "int", 0) \
K(INT8, "int8", 0) \ K(Int8, "int8", 0) \
K(INT16, "int16", 0) \ K(Int16, "int16", 0) \
K(INT24, "int24", 0) \ K(Int24, "int24", 0) \
K(INT32, "int32", 0) \ K(Int32, "int32", 0) \
K(INT40, "int40", 0) \ K(Int40, "int40", 0) \
K(INT48, "int48", 0) \ K(INT48, "int48", 0) \
K(INT56, "int56", 0) \ K(Int56, "int56", 0) \
K(INT64, "int64", 0) \ K(Int64, "int64", 0) \
K(INT72, "int72", 0) \ K(Int72, "int72", 0) \
K(INT80, "int80", 0) \ K(Int80, "int80", 0) \
K(INT88, "int88", 0) \ K(Int88, "int88", 0) \
K(INT96, "int96", 0) \ K(Int96, "int96", 0) \
K(INT104, "int104", 0) \ K(Int104, "int104", 0) \
K(INT112, "int112", 0) \ K(Int112, "int112", 0) \
K(INT120, "int120", 0) \ K(Int120, "int120", 0) \
K(INT128, "int128", 0) \ K(Int128, "int128", 0) \
K(INT136, "int136", 0) \ K(Int136, "int136", 0) \
K(INT144, "int144", 0) \ K(Int144, "int144", 0) \
K(INT152, "int152", 0) \ K(Int152, "int152", 0) \
K(INT160, "int160", 0) \ K(Int160, "int160", 0) \
K(INT168, "int168", 0) \ K(Int168, "int168", 0) \
K(INT176, "int178", 0) \ K(Int176, "int178", 0) \
K(INT184, "int184", 0) \ K(Int184, "int184", 0) \
K(INT192, "int192", 0) \ K(Int192, "int192", 0) \
K(INT200, "int200", 0) \ K(Int200, "int200", 0) \
K(INT208, "int208", 0) \ K(Int208, "int208", 0) \
K(INT216, "int216", 0) \ K(Int216, "int216", 0) \
K(INT224, "int224", 0) \ K(Int224, "int224", 0) \
K(INT232, "int232", 0) \ K(Int232, "int232", 0) \
K(INT240, "int240", 0) \ K(Int240, "int240", 0) \
K(INT248, "int248", 0) \ K(Int248, "int248", 0) \
K(INT256, "int256", 0) \ K(Int256, "int256", 0) \
K(UINT, "uint", 0) \ K(Uint, "uint", 0) \
K(UINT8, "uint8", 0) \ K(Uint8, "uint8", 0) \
K(UINT16, "uint16", 0) \ K(Uint16, "uint16", 0) \
K(UINT24, "uint24", 0) \ K(Uint24, "uint24", 0) \
K(UINT32, "uint32", 0) \ K(Uint32, "uint32", 0) \
K(UINT40, "uint40", 0) \ K(Uint40, "uint40", 0) \
K(UINT48, "uint48", 0) \ K(Uint48, "uint48", 0) \
K(UINT56, "uint56", 0) \ K(Uint56, "uint56", 0) \
K(UINT64, "uint64", 0) \ K(Uint64, "uint64", 0) \
K(UINT72, "uint72", 0) \ K(Uint72, "uint72", 0) \
K(UINT80, "uint80", 0) \ K(Uint80, "uint80", 0) \
K(UINT88, "uint88", 0) \ K(Uint88, "uint88", 0) \
K(UINT96, "uint96", 0) \ K(Uint96, "uint96", 0) \
K(UINT104, "uint104", 0) \ K(Uint104, "uint104", 0) \
K(UINT112, "uint112", 0) \ K(Uint112, "uint112", 0) \
K(UINT120, "uint120", 0) \ K(Uint120, "uint120", 0) \
K(UINT128, "uint128", 0) \ K(Uint128, "uint128", 0) \
K(UINT136, "uint136", 0) \ K(Uint136, "uint136", 0) \
K(UINT144, "uint144", 0) \ K(Uint144, "uint144", 0) \
K(UINT152, "uint152", 0) \ K(Uint152, "uint152", 0) \
K(UINT160, "uint160", 0) \ K(Uint160, "uint160", 0) \
K(UINT168, "uint168", 0) \ K(Uint168, "uint168", 0) \
K(UINT176, "uint178", 0) \ K(Uint176, "uint178", 0) \
K(UINT184, "uint184", 0) \ K(Uint184, "uint184", 0) \
K(UINT192, "uint192", 0) \ K(Uint192, "uint192", 0) \
K(UINT200, "uint200", 0) \ K(Uint200, "uint200", 0) \
K(UINT208, "uint208", 0) \ K(Uint208, "uint208", 0) \
K(UINT216, "uint216", 0) \ K(Uint216, "uint216", 0) \
K(UINT224, "uint224", 0) \ K(Uint224, "uint224", 0) \
K(UINT232, "uint232", 0) \ K(Uint232, "uint232", 0) \
K(UINT240, "uint240", 0) \ K(Uint240, "uint240", 0) \
K(UINT248, "uint248", 0) \ K(Uint248, "uint248", 0) \
K(UINT256, "uint256", 0) \ K(Uint256, "uint256", 0) \
K(HASH, "hash", 0) \ K(Hash, "hash", 0) \
K(HASH8, "hash8", 0) \ K(Hash8, "hash8", 0) \
K(HASH16, "hash16", 0) \ K(Hash16, "hash16", 0) \
K(HASH24, "hash24", 0) \ K(Hash24, "hash24", 0) \
K(HASH32, "hash32", 0) \ K(Hash32, "hash32", 0) \
K(HASH40, "hash40", 0) \ K(Hash40, "hash40", 0) \
K(HASH48, "hash48", 0) \ K(Hash48, "hash48", 0) \
K(HASH56, "hash56", 0) \ K(Hash56, "hash56", 0) \
K(HASH64, "hash64", 0) \ K(Hash64, "hash64", 0) \
K(HASH72, "hash72", 0) \ K(Hash72, "hash72", 0) \
K(HASH80, "hash80", 0) \ K(Hash80, "hash80", 0) \
K(HASH88, "hash88", 0) \ K(Hash88, "hash88", 0) \
K(HASH96, "hash96", 0) \ K(Hash96, "hash96", 0) \
K(HASH104, "hash104", 0) \ K(Hash104, "hash104", 0) \
K(HASH112, "hash112", 0) \ K(Hash112, "hash112", 0) \
K(HASH120, "hash120", 0) \ K(Hash120, "hash120", 0) \
K(HASH128, "hash128", 0) \ K(Hash128, "hash128", 0) \
K(HASH136, "hash136", 0) \ K(Hash136, "hash136", 0) \
K(HASH144, "hash144", 0) \ K(Hash144, "hash144", 0) \
K(HASH152, "hash152", 0) \ K(Hash152, "hash152", 0) \
K(HASH160, "hash160", 0) \ K(Hash160, "hash160", 0) \
K(HASH168, "hash168", 0) \ K(Hash168, "hash168", 0) \
K(HASH176, "hash178", 0) \ K(Hash176, "hash178", 0) \
K(HASH184, "hash184", 0) \ K(Hash184, "hash184", 0) \
K(HASH192, "hash192", 0) \ K(Hash192, "hash192", 0) \
K(HASH200, "hash200", 0) \ K(Hash200, "hash200", 0) \
K(HASH208, "hash208", 0) \ K(Hash208, "hash208", 0) \
K(HASH216, "hash216", 0) \ K(Hash216, "hash216", 0) \
K(HASH224, "hash224", 0) \ K(Hash224, "hash224", 0) \
K(HASH232, "hash232", 0) \ K(Hash232, "hash232", 0) \
K(HASH240, "hash240", 0) \ K(Hash240, "hash240", 0) \
K(HASH248, "hash248", 0) \ K(Hash248, "hash248", 0) \
K(HASH256, "hash256", 0) \ K(Hash256, "hash256", 0) \
K(ADDRESS, "address", 0) \ K(Address, "address", 0) \
K(BOOL, "bool", 0) \ K(Bool, "bool", 0) \
K(STRING_TYPE, "string", 0) \ K(StringType, "string", 0) \
K(STRING0, "string0", 0) \ K(String0, "string0", 0) \
K(STRING1, "string1", 0) \ K(String1, "string1", 0) \
K(STRING2, "string2", 0) \ K(String2, "string2", 0) \
K(STRING3, "string3", 0) \ K(String3, "string3", 0) \
K(STRING4, "string4", 0) \ K(String4, "string4", 0) \
K(STRING5, "string5", 0) \ K(String5, "string5", 0) \
K(STRING6, "string6", 0) \ K(String6, "string6", 0) \
K(STRING7, "string7", 0) \ K(String7, "string7", 0) \
K(STRING8, "string8", 0) \ K(String8, "string8", 0) \
K(STRING9, "string9", 0) \ K(String9, "string9", 0) \
K(STRING10, "string10", 0) \ K(String10, "string10", 0) \
K(STRING11, "string11", 0) \ K(String11, "string11", 0) \
K(STRING12, "string12", 0) \ K(String12, "string12", 0) \
K(STRING13, "string13", 0) \ K(String13, "string13", 0) \
K(STRING14, "string14", 0) \ K(String14, "string14", 0) \
K(STRING15, "string15", 0) \ K(String15, "string15", 0) \
K(STRING16, "string16", 0) \ K(String16, "string16", 0) \
K(STRING17, "string17", 0) \ K(String17, "string17", 0) \
K(STRING18, "string18", 0) \ K(String18, "string18", 0) \
K(STRING19, "string19", 0) \ K(String19, "string19", 0) \
K(STRING20, "string20", 0) \ K(String20, "string20", 0) \
K(STRING21, "string21", 0) \ K(String21, "string21", 0) \
K(STRING22, "string22", 0) \ K(String22, "string22", 0) \
K(STRING23, "string23", 0) \ K(String23, "string23", 0) \
K(STRING24, "string24", 0) \ K(String24, "string24", 0) \
K(STRING25, "string25", 0) \ K(String25, "string25", 0) \
K(STRING26, "string26", 0) \ K(String26, "string26", 0) \
K(STRING27, "string27", 0) \ K(String27, "string27", 0) \
K(STRING28, "string28", 0) \ K(String28, "string28", 0) \
K(STRING29, "string29", 0) \ K(String29, "string29", 0) \
K(STRING30, "string30", 0) \ K(String30, "string30", 0) \
K(STRING31, "string31", 0) \ K(String31, "string31", 0) \
K(STRING32, "string32", 0) \ K(String32, "string32", 0) \
K(TEXT, "text", 0) \ K(Text, "text", 0) \
K(REAL, "real", 0) \ K(Real, "real", 0) \
K(UREAL, "ureal", 0) \ K(UReal, "ureal", 0) \
T(TYPES_END, NULL, 0) /* used as type enum end marker */ \ T(TypesEnd, NULL, 0) /* used as type enum end marker */ \
\ \
/* Literals */ \ /* Literals */ \
K(NULL_LITERAL, "null", 0) \ K(NullLiteral, "null", 0) \
K(TRUE_LITERAL, "true", 0) \ K(TrueLiteral, "true", 0) \
K(FALSE_LITERAL, "false", 0) \ K(FalseLiteral, "false", 0) \
T(NUMBER, NULL, 0) \ T(Number, NULL, 0) \
T(STRING_LITERAL, NULL, 0) \ T(StringLiteral, NULL, 0) \
T(COMMENT_LITERAL, NULL, 0) \ T(CommentLiteral, NULL, 0) \
\ \
/* Identifiers (not keywords or future reserved words). */ \ /* Identifiers (not keywords or future reserved words). */ \
T(IDENTIFIER, NULL, 0) \ T(Identifier, NULL, 0) \
\ \
/* Illegal token - not able to scan. */ \ /* Illegal token - not able to scan. */ \
T(ILLEGAL, "ILLEGAL", 0) \ T(Illegal, "ILLEGAL", 0) \
\ \
/* Scanner-internal use only. */ \ /* Scanner-internal use only. */ \
T(WHITESPACE, NULL, 0) T(Whitespace, NULL, 0)
class Token class Token
@ -364,25 +359,25 @@ public:
} }
// Predicates // Predicates
static bool isElementaryTypeName(Value tok) { return INT <= tok && tok < TYPES_END; } static bool isElementaryTypeName(Value tok) { return Int <= tok && tok < TypesEnd; }
static bool isAssignmentOp(Value tok) { return ASSIGN <= tok && tok <= ASSIGN_MOD; } static bool isAssignmentOp(Value tok) { return Assign <= tok && tok <= AssignMod; }
static bool isBinaryOp(Value op) { return COMMA <= op && op <= MOD; } static bool isBinaryOp(Value op) { return Comma <= op && op <= Mod; }
static bool isCommutativeOp(Value op) { return op == BIT_OR || op == BIT_XOR || op == BIT_AND || static bool isCommutativeOp(Value op) { return op == BitOr || op == BitXor || op == BitAnd ||
op == ADD || op == MUL || op == EQ || op == NE; } op == Add || op == Mul || op == Equals || op == NotEquals; }
static bool isArithmeticOp(Value op) { return ADD <= op && op <= MOD; } static bool isArithmeticOp(Value op) { return Add <= op && op <= Mod; }
static bool isCompareOp(Value op) { return EQ <= op && op <= IN; } static bool isCompareOp(Value op) { return Equals <= op && op <= In; }
static Value AssignmentToBinaryOp(Value op) static Value AssignmentToBinaryOp(Value op)
{ {
solAssert(isAssignmentOp(op) && op != ASSIGN, ""); solAssert(isAssignmentOp(op) && op != Assign, "");
return Token::Value(op + (BIT_OR - ASSIGN_BIT_OR)); return Token::Value(op + (BitOr - AssignBitOr));
} }
static bool isBitOp(Value op) { return (BIT_OR <= op && op <= SHR) || op == BIT_NOT; } static bool isBitOp(Value op) { return (BitOr <= op && op <= SHR) || op == BitNot; }
static bool isUnaryOp(Value op) { return (NOT <= op && op <= DELETE) || op == ADD || op == SUB; } static bool isUnaryOp(Value op) { return (Not <= op && op <= Delete) || op == Add || op == Sub; }
static bool isCountOp(Value op) { return op == INC || op == DEC; } static bool isCountOp(Value op) { return op == Inc || op == Dec; }
static bool isShiftOp(Value op) { return (SHL <= op) && (op <= SHR); } static bool isShiftOp(Value op) { return (SHL <= op) && (op <= SHR); }
static bool isVisibilitySpecifier(Value op) { return op == PUBLIC || op == PRIVATE || op == PROTECTED; } static bool isVisibilitySpecifier(Value op) { return op == Public || op == Private || op == Protected; }
static bool isEtherSubdenomination(Value op) { return op == SubWei || op == SubSzabo || op == SubFinney || op == Token::SubEther; } static bool isEtherSubdenomination(Value op) { return op == SubWei || op == SubSzabo || op == SubFinney || op == Token::SubEther; }
// Returns a string corresponding to the JS token string // Returns a string corresponding to the JS token string

94
Types.cpp
View File

@ -37,9 +37,9 @@ shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
{ {
solAssert(Token::isElementaryTypeName(_typeToken), "Elementary type name expected."); solAssert(Token::isElementaryTypeName(_typeToken), "Elementary type name expected.");
if (Token::INT <= _typeToken && _typeToken <= Token::HASH256) if (Token::Int <= _typeToken && _typeToken <= Token::Hash256)
{ {
int offset = _typeToken - Token::INT; int offset = _typeToken - Token::Int;
int bytes = offset % 33; int bytes = offset % 33;
if (bytes == 0) if (bytes == 0)
bytes = 32; bytes = 32;
@ -47,14 +47,14 @@ shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
return make_shared<IntegerType>(bytes * 8, return make_shared<IntegerType>(bytes * 8,
modifier == 0 ? IntegerType::Modifier::SIGNED : modifier == 0 ? IntegerType::Modifier::SIGNED :
modifier == 1 ? IntegerType::Modifier::UNSIGNED : modifier == 1 ? IntegerType::Modifier::UNSIGNED :
IntegerType::Modifier::HASH); IntegerType::Modifier::Hash);
} }
else if (_typeToken == Token::ADDRESS) else if (_typeToken == Token::Address)
return make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS); return make_shared<IntegerType>(0, IntegerType::Modifier::Address);
else if (_typeToken == Token::BOOL) else if (_typeToken == Token::Bool)
return make_shared<BoolType>(); return make_shared<BoolType>();
else if (Token::STRING0 <= _typeToken && _typeToken <= Token::STRING32) else if (Token::String0 <= _typeToken && _typeToken <= Token::String32)
return make_shared<StaticStringType>(int(_typeToken) - int(Token::STRING0)); return make_shared<StaticStringType>(int(_typeToken) - int(Token::String0));
else else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unable to convert elementary typename " + BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unable to convert elementary typename " +
std::string(Token::toString(_typeToken)) + " to type.")); std::string(Token::toString(_typeToken)) + " to type."));
@ -87,12 +87,12 @@ shared_ptr<Type const> Type::forLiteral(Literal const& _literal)
{ {
switch (_literal.getToken()) switch (_literal.getToken())
{ {
case Token::TRUE_LITERAL: case Token::TrueLiteral:
case Token::FALSE_LITERAL: case Token::FalseLiteral:
return make_shared<BoolType>(); return make_shared<BoolType>();
case Token::NUMBER: case Token::Number:
return make_shared<IntegerConstantType>(_literal); return make_shared<IntegerConstantType>(_literal);
case Token::STRING_LITERAL: case Token::StringLiteral:
//@todo put larger strings into dynamic strings //@todo put larger strings into dynamic strings
return StaticStringType::smallestTypeForLiteral(_literal.getValue()); return StaticStringType::smallestTypeForLiteral(_literal.getValue());
default: default:
@ -140,31 +140,31 @@ bool IntegerType::isImplicitlyConvertibleTo(Type const& _convertTo) const
bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const bool IntegerType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{ {
if (_convertTo.getCategory() == Category::STRING) if (_convertTo.getCategory() == Category::String)
{ {
StaticStringType const& convertTo = dynamic_cast<StaticStringType const&>(_convertTo); StaticStringType const& convertTo = dynamic_cast<StaticStringType const&>(_convertTo);
return isHash() && (m_bits == convertTo.getNumBytes() * 8); return isHash() && (m_bits == convertTo.getNumBytes() * 8);
} }
return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::CONTRACT; return _convertTo.getCategory() == getCategory() || _convertTo.getCategory() == Category::Contract;
} }
TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const TypePointer IntegerType::unaryOperatorResult(Token::Value _operator) const
{ {
// "delete" is ok for all integer types // "delete" is ok for all integer types
if (_operator == Token::DELETE) if (_operator == Token::Delete)
return make_shared<VoidType>(); return make_shared<VoidType>();
// no further unary operators for addresses // no further unary operators for addresses
else if (isAddress()) else if (isAddress())
return TypePointer(); return TypePointer();
// "~" is ok for all other types // "~" is ok for all other types
else if (_operator == Token::BIT_NOT) else if (_operator == Token::BitNot)
return shared_from_this(); return shared_from_this();
// nothing else for hashes // nothing else for hashes
else if (isHash()) else if (isHash())
return TypePointer(); return TypePointer();
// for non-hash integers, we allow +, -, ++ and -- // for non-hash integers, we allow +, -, ++ and --
else if (_operator == Token::ADD || _operator == Token::SUB || else if (_operator == Token::Add || _operator == Token::Sub ||
_operator == Token::INC || _operator == Token::DEC) _operator == Token::Inc || _operator == Token::Dec)
return shared_from_this(); return shared_from_this();
else else
return TypePointer(); return TypePointer();
@ -188,7 +188,7 @@ string IntegerType::toString() const
TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const TypePointer IntegerType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{ {
if (_other->getCategory() != Category::INTEGER_CONSTANT && _other->getCategory() != getCategory()) if (_other->getCategory() != Category::IntegerConstant && _other->getCategory() != getCategory())
return TypePointer(); return TypePointer();
auto commonType = dynamic_pointer_cast<IntegerType const>(Type::commonType(shared_from_this(), _other)); auto commonType = dynamic_pointer_cast<IntegerType const>(Type::commonType(shared_from_this(), _other));
@ -254,13 +254,13 @@ TypePointer IntegerConstantType::unaryOperatorResult(Token::Value _operator) con
bigint value; bigint value;
switch (_operator) switch (_operator)
{ {
case Token::BIT_NOT: case Token::BitNot:
value = ~m_value; value = ~m_value;
break; break;
case Token::ADD: case Token::Add:
value = m_value; value = m_value;
break; break;
case Token::SUB: case Token::Sub:
value = -m_value; value = -m_value;
break; break;
default: default:
@ -271,7 +271,7 @@ TypePointer IntegerConstantType::unaryOperatorResult(Token::Value _operator) con
TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{ {
if (_other->getCategory() == Category::INTEGER) if (_other->getCategory() == Category::Integer)
{ {
shared_ptr<IntegerType const> integerType = getIntegerType(); shared_ptr<IntegerType const> integerType = getIntegerType();
if (!integerType) if (!integerType)
@ -295,30 +295,30 @@ TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, Ty
bigint value; bigint value;
switch (_operator) switch (_operator)
{ {
case Token::BIT_OR: case Token::BitOr:
value = m_value | other.m_value; value = m_value | other.m_value;
break; break;
case Token::BIT_XOR: case Token::BitXor:
value = m_value ^ other.m_value; value = m_value ^ other.m_value;
break; break;
case Token::BIT_AND: case Token::BitAnd:
value = m_value & other.m_value; value = m_value & other.m_value;
break; break;
case Token::ADD: case Token::Add:
value = m_value + other.m_value; value = m_value + other.m_value;
break; break;
case Token::SUB: case Token::Sub:
value = m_value - other.m_value; value = m_value - other.m_value;
break; break;
case Token::MUL: case Token::Mul:
value = m_value * other.m_value; value = m_value * other.m_value;
break; break;
case Token::DIV: case Token::Div:
if (other.m_value == 0) if (other.m_value == 0)
return TypePointer(); return TypePointer();
value = m_value / other.m_value; value = m_value / other.m_value;
break; break;
case Token::MOD: case Token::Mod:
if (other.m_value == 0) if (other.m_value == 0)
return TypePointer(); return TypePointer();
value = m_value % other.m_value; value = m_value % other.m_value;
@ -401,7 +401,7 @@ bool StaticStringType::isImplicitlyConvertibleTo(Type const& _convertTo) const
bool StaticStringType::isExplicitlyConvertibleTo(Type const& _convertTo) const bool StaticStringType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{ {
if (_convertTo.getCategory() == Category::INTEGER) if (_convertTo.getCategory() == Category::Integer)
{ {
IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo); IntegerType const& convertTo = dynamic_cast<IntegerType const&>(_convertTo);
if (convertTo.isHash() && (m_bytes * 8 == convertTo.getNumBits())) if (convertTo.isHash() && (m_bytes * 8 == convertTo.getNumBits()))
@ -443,9 +443,9 @@ bool BoolType::isExplicitlyConvertibleTo(Type const& _convertTo) const
u256 BoolType::literalValue(Literal const* _literal) const u256 BoolType::literalValue(Literal const* _literal) const
{ {
solAssert(_literal, ""); solAssert(_literal, "");
if (_literal->getToken() == Token::TRUE_LITERAL) if (_literal->getToken() == Token::TrueLiteral)
return u256(1); return u256(1);
else if (_literal->getToken() == Token::FALSE_LITERAL) else if (_literal->getToken() == Token::FalseLiteral)
return u256(0); return u256(0);
else else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Bool type constructed from non-boolean literal.")); BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Bool type constructed from non-boolean literal."));
@ -453,16 +453,16 @@ u256 BoolType::literalValue(Literal const* _literal) const
TypePointer BoolType::unaryOperatorResult(Token::Value _operator) const TypePointer BoolType::unaryOperatorResult(Token::Value _operator) const
{ {
if (_operator == Token::DELETE) if (_operator == Token::Delete)
return make_shared<VoidType>(); return make_shared<VoidType>();
return (_operator == Token::NOT) ? shared_from_this() : TypePointer(); return (_operator == Token::Not) ? shared_from_this() : TypePointer();
} }
TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const TypePointer BoolType::binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const
{ {
if (getCategory() != _other->getCategory()) if (getCategory() != _other->getCategory())
return TypePointer(); return TypePointer();
if (Token::isCompareOp(_operator) || _operator == Token::AND || _operator == Token::OR) if (Token::isCompareOp(_operator) || _operator == Token::And || _operator == Token::Or)
return _other; return _other;
else else
return TypePointer(); return TypePointer();
@ -472,9 +472,9 @@ bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{ {
if (*this == _convertTo) if (*this == _convertTo)
return true; return true;
if (_convertTo.getCategory() == Category::INTEGER) if (_convertTo.getCategory() == Category::Integer)
return dynamic_cast<IntegerType const&>(_convertTo).isAddress(); return dynamic_cast<IntegerType const&>(_convertTo).isAddress();
if (_convertTo.getCategory() == Category::CONTRACT) if (_convertTo.getCategory() == Category::Contract)
{ {
auto const& bases = getContractDefinition().getLinearizedBaseContracts(); auto const& bases = getContractDefinition().getLinearizedBaseContracts();
if (m_super && bases.size() <= 1) if (m_super && bases.size() <= 1)
@ -487,13 +487,13 @@ bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{ {
return isImplicitlyConvertibleTo(_convertTo) || _convertTo.getCategory() == Category::INTEGER || return isImplicitlyConvertibleTo(_convertTo) || _convertTo.getCategory() == Category::Integer ||
_convertTo.getCategory() == Category::CONTRACT; _convertTo.getCategory() == Category::Contract;
} }
TypePointer ContractType::unaryOperatorResult(Token::Value _operator) const TypePointer ContractType::unaryOperatorResult(Token::Value _operator) const
{ {
return _operator == Token::DELETE ? make_shared<VoidType>() : TypePointer(); return _operator == Token::Delete ? make_shared<VoidType>() : TypePointer();
} }
bool ContractType::operator==(Type const& _other) const bool ContractType::operator==(Type const& _other) const
@ -557,7 +557,7 @@ u256 ContractType::getFunctionIdentifier(string const& _functionName) const
TypePointer StructType::unaryOperatorResult(Token::Value _operator) const TypePointer StructType::unaryOperatorResult(Token::Value _operator) const
{ {
return _operator == Token::DELETE ? make_shared<VoidType>() : TypePointer(); return _operator == Token::Delete ? make_shared<VoidType>() : TypePointer();
} }
bool StructType::operator==(Type const& _other) const bool StructType::operator==(Type const& _other) const
@ -865,7 +865,7 @@ MemberList const& TypeType::getMembers() const
if (!m_members) if (!m_members)
{ {
map<string, TypePointer> members; map<string, TypePointer> members;
if (m_actualType->getCategory() == Category::CONTRACT && m_currentContract != nullptr) if (m_actualType->getCategory() == Category::Contract && m_currentContract != nullptr)
{ {
ContractDefinition const& contract = dynamic_cast<ContractType const&>(*m_actualType).getContractDefinition(); ContractDefinition const& contract = dynamic_cast<ContractType const&>(*m_actualType).getContractDefinition();
vector<ContractDefinition const*> currentBases = m_currentContract->getLinearizedBaseContracts(); vector<ContractDefinition const*> currentBases = m_currentContract->getLinearizedBaseContracts();
@ -920,7 +920,7 @@ MagicType::MagicType(MagicType::Kind _kind):
switch (m_kind) switch (m_kind)
{ {
case Kind::BLOCK: case Kind::BLOCK:
m_members = MemberList({{"coinbase", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)}, m_members = MemberList({{"coinbase", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"timestamp", make_shared<IntegerType>(256)}, {"timestamp", make_shared<IntegerType>(256)},
{"blockhash", make_shared<FunctionType>(strings{"uint"}, strings{"hash"}, FunctionType::Location::BLOCKHASH)}, {"blockhash", make_shared<FunctionType>(strings{"uint"}, strings{"hash"}, FunctionType::Location::BLOCKHASH)},
{"difficulty", make_shared<IntegerType>(256)}, {"difficulty", make_shared<IntegerType>(256)},
@ -928,12 +928,12 @@ MagicType::MagicType(MagicType::Kind _kind):
{"gaslimit", make_shared<IntegerType>(256)}}); {"gaslimit", make_shared<IntegerType>(256)}});
break; break;
case Kind::MSG: case Kind::MSG:
m_members = MemberList({{"sender", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)}, m_members = MemberList({{"sender", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"gas", make_shared<IntegerType>(256)}, {"gas", make_shared<IntegerType>(256)},
{"value", make_shared<IntegerType>(256)}}); {"value", make_shared<IntegerType>(256)}});
break; break;
case Kind::TX: case Kind::TX:
m_members = MemberList({{"origin", make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS)}, m_members = MemberList({{"origin", make_shared<IntegerType>(0, IntegerType::Modifier::Address)},
{"gasprice", make_shared<IntegerType>(256)}}); {"gasprice", make_shared<IntegerType>(256)}});
break; break;
default: default:

34
Types.h
View File

@ -76,7 +76,9 @@ class Type: private boost::noncopyable, public std::enable_shared_from_this<Type
public: public:
enum class Category enum class Category
{ {
INTEGER, INTEGER_CONSTANT, BOOL, REAL, STRING, CONTRACT, STRUCT, FUNCTION, MAPPING, VOID, TYPE, MODIFIER, MAGIC Integer, IntegerConstant, Bool, Real,
String, Contract, Struct, Function,
Mapping, Void, Type, Modifier, Magic
}; };
///@{ ///@{
@ -158,9 +160,9 @@ class IntegerType: public Type
public: public:
enum class Modifier enum class Modifier
{ {
UNSIGNED, SIGNED, HASH, ADDRESS UNSIGNED, SIGNED, Hash, Address
}; };
virtual Category getCategory() const override { return Category::INTEGER; } virtual Category getCategory() const override { return Category::Integer; }
explicit IntegerType(int _bits, Modifier _modifier = Modifier::UNSIGNED); explicit IntegerType(int _bits, Modifier _modifier = Modifier::UNSIGNED);
@ -180,8 +182,8 @@ public:
virtual TypePointer getRealType() const { return std::make_shared<IntegerType>(m_bits, m_modifier); } virtual TypePointer getRealType() const { return std::make_shared<IntegerType>(m_bits, m_modifier); }
int getNumBits() const { return m_bits; } int getNumBits() const { return m_bits; }
bool isHash() const { return m_modifier == Modifier::HASH || m_modifier == Modifier::ADDRESS; } bool isHash() const { return m_modifier == Modifier::Hash || m_modifier == Modifier::Address; }
bool isAddress() const { return m_modifier == Modifier::ADDRESS; } bool isAddress() const { return m_modifier == Modifier::Address; }
bool isSigned() const { return m_modifier == Modifier::SIGNED; } bool isSigned() const { return m_modifier == Modifier::SIGNED; }
static const MemberList AddressMemberList; static const MemberList AddressMemberList;
@ -198,7 +200,7 @@ private:
class IntegerConstantType: public Type class IntegerConstantType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::INTEGER_CONSTANT; } virtual Category getCategory() const override { return Category::IntegerConstant; }
explicit IntegerConstantType(Literal const& _literal); explicit IntegerConstantType(Literal const& _literal);
explicit IntegerConstantType(bigint _value): m_value(_value) {} explicit IntegerConstantType(bigint _value): m_value(_value) {}
@ -231,7 +233,7 @@ private:
class StaticStringType: public Type class StaticStringType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::STRING; } virtual Category getCategory() const override { return Category::String; }
/// @returns the smallest string type for the given literal or an empty pointer /// @returns the smallest string type for the given literal or an empty pointer
/// if no type fits. /// if no type fits.
@ -263,7 +265,7 @@ class BoolType: public Type
{ {
public: public:
BoolType() {} BoolType() {}
virtual Category getCategory() const { return Category::BOOL; } virtual Category getCategory() const { return Category::Bool; }
virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override; virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
virtual TypePointer unaryOperatorResult(Token::Value _operator) const override; virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const override; virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const override;
@ -281,7 +283,7 @@ public:
class ContractType: public Type class ContractType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::CONTRACT; } virtual Category getCategory() const override { return Category::Contract; }
explicit ContractType(ContractDefinition const& _contract, bool _super = false): explicit ContractType(ContractDefinition const& _contract, bool _super = false):
m_contract(_contract), m_super(_super) {} m_contract(_contract), m_super(_super) {}
/// Contracts can be implicitly converted to super classes and to addresses. /// Contracts can be implicitly converted to super classes and to addresses.
@ -323,7 +325,7 @@ private:
class StructType: public Type class StructType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::STRUCT; } virtual Category getCategory() const override { return Category::Struct; }
explicit StructType(StructDefinition const& _struct): m_struct(_struct) {} explicit StructType(StructDefinition const& _struct): m_struct(_struct) {}
virtual TypePointer unaryOperatorResult(Token::Value _operator) const override; virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
virtual bool operator==(Type const& _other) const override; virtual bool operator==(Type const& _other) const override;
@ -362,7 +364,7 @@ public:
SET_GAS, SET_VALUE, BLOCKHASH, SET_GAS, SET_VALUE, BLOCKHASH,
BARE }; BARE };
virtual Category getCategory() const override { return Category::FUNCTION; } virtual Category getCategory() const override { return Category::Function; }
explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true); explicit FunctionType(FunctionDefinition const& _function, bool _isInternal = true);
explicit FunctionType(VariableDeclaration const& _varDecl); explicit FunctionType(VariableDeclaration const& _varDecl);
explicit FunctionType(EventDefinition const& _event); explicit FunctionType(EventDefinition const& _event);
@ -435,7 +437,7 @@ private:
class MappingType: public Type class MappingType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::MAPPING; } virtual Category getCategory() const override { return Category::Mapping; }
MappingType(TypePointer const& _keyType, TypePointer const& _valueType): MappingType(TypePointer const& _keyType, TypePointer const& _valueType):
m_keyType(_keyType), m_valueType(_valueType) {} m_keyType(_keyType), m_valueType(_valueType) {}
@ -458,7 +460,7 @@ private:
class VoidType: public Type class VoidType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::VOID; } virtual Category getCategory() const override { return Category::Void; }
VoidType() {} VoidType() {}
virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); } virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
@ -476,7 +478,7 @@ public:
class TypeType: public Type class TypeType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::TYPE; } virtual Category getCategory() const override { return Category::Type; }
explicit TypeType(TypePointer const& _actualType, ContractDefinition const* _currentContract = nullptr): explicit TypeType(TypePointer const& _actualType, ContractDefinition const* _currentContract = nullptr):
m_actualType(_actualType), m_currentContract(_currentContract) {} m_actualType(_actualType), m_currentContract(_currentContract) {}
TypePointer const& getActualType() const { return m_actualType; } TypePointer const& getActualType() const { return m_actualType; }
@ -505,7 +507,7 @@ private:
class ModifierType: public Type class ModifierType: public Type
{ {
public: public:
virtual Category getCategory() const override { return Category::MODIFIER; } virtual Category getCategory() const override { return Category::Modifier; }
explicit ModifierType(ModifierDefinition const& _modifier); explicit ModifierType(ModifierDefinition const& _modifier);
virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); } virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
@ -529,7 +531,7 @@ class MagicType: public Type
{ {
public: public:
enum class Kind { BLOCK, MSG, TX }; enum class Kind { BLOCK, MSG, TX };
virtual Category getCategory() const override { return Category::MAGIC; } virtual Category getCategory() const override { return Category::Magic; }
explicit MagicType(Kind _kind); explicit MagicType(Kind _kind);