aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLefteris Karapetsas <lefteris@refu.co>2015-02-09 21:00:12 +0800
committerLefteris Karapetsas <lefteris@refu.co>2015-02-09 21:00:12 +0800
commit6f621f8486ca6685b29008cb66ea6a819d7c91dc (patch)
tree32cca3cea5809732c55a2da23587e238d554049c
parent75a5c20f541a7dc41f80bdb3b4fe3478d18ad4fe (diff)
downloaddexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar.gz
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar.bz2
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar.lz
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar.xz
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.tar.zst
dexon-solidity-6f621f8486ca6685b29008cb66ea6a819d7c91dc.zip
Changing Solidity Code to use CamelCase enum values
Diffstat
-rw-r--r--AST.cpp20
-rw-r--r--AST.h2
-rw-r--r--Compiler.cpp4
-rw-r--r--ExpressionCompiler.cpp114
-rw-r--r--Parser.cpp222
-rw-r--r--Scanner.cpp126
-rw-r--r--Token.cpp4
-rw-r--r--Token.h471
-rw-r--r--Types.cpp94
-rw-r--r--Types.h34
10 files changed, 544 insertions, 547 deletions
diff --git a/AST.cpp b/AST.cpp
index 79d724fc..962097ed 100644
--- a/AST.cpp
+++ b/AST.cpp
@@ -247,7 +247,7 @@ void StructDefinition::checkRecursion() const
<< errinfo_comment("Recursive struct definition."));
definitionsSeen.insert(def);
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());
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
m_value->checkTypeRequirements();
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();
if (!intType)
BOOST_THROW_EXCEPTION(m_value->createTypeError("Invalid integer constant " + type->toString()));
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"));
m_variable->setType(type);
}
@@ -406,7 +406,7 @@ void Assignment::checkTypeRequirements()
if (!m_leftHandSide->getType()->isValueType() && !m_leftHandSide->isLocalLValue())
BOOST_THROW_EXCEPTION(createTypeError("Assignment to non-local non-value lvalue."));
m_type = m_leftHandSide->getType();
- if (m_assigmentOperator == Token::ASSIGN)
+ if (m_assigmentOperator == Token::Assign)
m_rightHandSide->expectType(*m_type);
else
{
@@ -425,7 +425,7 @@ void Assignment::checkTypeRequirements()
void ExpressionStatement::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())
BOOST_THROW_EXCEPTION(m_expression->createTypeError("Invalid integer constant."));
}
@@ -449,9 +449,9 @@ void Expression::requireLValue()
void UnaryOperation::checkTypeRequirements()
{
- // INC, DEC, ADD, SUB, NOT, BIT_NOT, DELETE
+ // INC, DEC, ADD, SUB, NOT, BitNot, DELETE
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_type = m_subExpression->getType()->unaryOperatorResult(m_operator);
if (!m_type)
@@ -553,7 +553,7 @@ void FunctionCall::checkTypeRequirements()
bool FunctionCall::isTypeConversion() const
{
- return m_expression->getType()->getCategory() == Type::Category::TYPE;
+ return m_expression->getType()->getCategory() == Type::Category::Type;
}
void NewExpression::checkTypeRequirements()
@@ -577,13 +577,13 @@ void MemberAccess::checkTypeRequirements()
BOOST_THROW_EXCEPTION(createTypeError("Member \"" + *m_memberName + "\" not found or not "
"visible in " + type.toString()));
//@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()
{
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 " +
m_base->getType()->toString() + ")"));
MappingType const& type = dynamic_cast<MappingType const&>(*m_base->getType());
diff --git a/AST.h b/AST.h
index 98f28afb..0056de64 100644
--- a/AST.h
+++ b/AST.h
@@ -1119,7 +1119,7 @@ class Literal: public PrimaryExpression
public:
enum class SubDenomination
{
- None = Token::ILLEGAL,
+ None = Token::Illegal,
Wei = Token::SubWei,
Szabo = Token::SubSzabo,
Finney = Token::SubFinney,
diff --git a/Compiler.cpp b/Compiler.cpp
index 389f826b..b3615367 100644
--- a/Compiler.cpp
+++ b/Compiler.cpp
@@ -189,7 +189,7 @@ unsigned Compiler::appendCalldataUnpacker(TypePointers const& _typeParameters, b
if (c_numBytes > 32)
BOOST_THROW_EXCEPTION(CompilerError()
<< 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;
dataOffset += CompilerUtils(m_context).loadFromMemory(dataOffset, c_numBytes, c_leftAligned,
!_fromMemory, c_padToWords);
@@ -213,7 +213,7 @@ void Compiler::appendReturnValuePacker(TypePointers const& _typeParameters)
<< errinfo_comment("Type " + type->toString() + " not yet supported."));
CompilerUtils(m_context).copyToStackTop(stackDepth, *type);
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;
dataOffset += CompilerUtils(m_context).storeInMemory(dataOffset, numBytes, c_leftAligned, c_padToWords);
stackDepth -= type->getSizeOnStack();
diff --git a/ExpressionCompiler.cpp b/ExpressionCompiler.cpp
index 4a1110db..b7f8dab9 100644
--- a/ExpressionCompiler.cpp
+++ b/ExpressionCompiler.cpp
@@ -64,7 +64,7 @@ bool ExpressionCompiler::visit(Assignment const& _assignment)
solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
Token::Value op = _assignment.getAssignmentOperator();
- if (op != Token::ASSIGN) // compound assignment
+ if (op != Token::Assign) // compound assignment
{
if (m_currentLValue.storesReferenceOnStack())
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
// put this code together with "Type::acceptsBinary/UnaryOperator" into a class that
// represents the operator
- if (_unaryOperation.getType()->getCategory() == Type::Category::INTEGER_CONSTANT)
+ if (_unaryOperation.getType()->getCategory() == Type::Category::IntegerConstant)
{
m_context << _unaryOperation.getType()->literalValue(nullptr);
return false;
@@ -95,19 +95,19 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
switch (_unaryOperation.getOperator())
{
- case Token::NOT: // !
+ case Token::Not: // !
m_context << eth::Instruction::ISZERO;
break;
- case Token::BIT_NOT: // ~
+ case Token::BitNot: // ~
m_context << eth::Instruction::NOT;
break;
- case Token::DELETE: // delete
+ case Token::Delete: // delete
solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
m_currentLValue.setToZero(_unaryOperation);
m_currentLValue.reset();
break;
- case Token::INC: // ++ (pre- or postfix)
- case Token::DEC: // -- (pre- or postfix)
+ case Token::Inc: // ++ (pre- or postfix)
+ case Token::Dec: // -- (pre- or postfix)
solAssert(m_currentLValue.isValid(), "LValue not retrieved.");
m_currentLValue.retrieveValue(_unaryOperation.getType(), _unaryOperation.getLocation());
if (!_unaryOperation.isPrefixOperation())
@@ -118,7 +118,7 @@ bool ExpressionCompiler::visit(UnaryOperation const& _unaryOperation)
m_context << eth::Instruction::DUP1;
}
m_context << u256(1);
- if (_unaryOperation.getOperator() == Token::INC)
+ if (_unaryOperation.getOperator() == Token::Inc)
m_context << eth::Instruction::ADD;
else
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.reset();
break;
- case Token::ADD: // +
+ case Token::Add: // +
// unary add, so basically no-op
break;
- case Token::SUB: // -
+ case Token::Sub: // -
m_context << u256(0) << eth::Instruction::SUB;
break;
default:
@@ -149,19 +149,19 @@ bool ExpressionCompiler::visit(BinaryOperation const& _binaryOperation)
Type const& commonType = _binaryOperation.getCommonType();
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);
- else if (commonType.getCategory() == Type::Category::INTEGER_CONSTANT)
+ else if (commonType.getCategory() == Type::Category::IntegerConstant)
m_context << commonType.literalValue(nullptr);
else
{
- bool cleanupNeeded = commonType.getCategory() == Type::Category::INTEGER &&
- (Token::isCompareOp(c_op) || c_op == Token::DIV || c_op == Token::MOD);
+ bool cleanupNeeded = commonType.getCategory() == Type::Category::Integer &&
+ (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
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);
if (swap)
@@ -411,7 +411,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
ASTString const& member = _memberAccess.getMemberName();
switch (_memberAccess.getExpression().getType()->getCategory())
{
- case Type::Category::CONTRACT:
+ case Type::Category::Contract:
{
bool alsoSearchInteger = false;
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);
if (identifier != Invalid256)
{
- appendTypeConversion(type, IntegerType(0, IntegerType::Modifier::ADDRESS), true);
+ appendTypeConversion(type, IntegerType(0, IntegerType::Modifier::Address), true);
m_context << identifier;
}
else
@@ -433,24 +433,24 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
if (!alsoSearchInteger)
break;
}
- case Type::Category::INTEGER:
+ case Type::Category::Integer:
if (member == "balance")
{
appendTypeConversion(*_memberAccess.getExpression().getType(),
- IntegerType(0, IntegerType::Modifier::ADDRESS), true);
+ IntegerType(0, IntegerType::Modifier::Address), true);
m_context << eth::Instruction::BALANCE;
}
else if (member == "send" || member.substr(0, min<size_t>(member.size(), 4)) == "call")
appendTypeConversion(*_memberAccess.getExpression().getType(),
- IntegerType(0, IntegerType::Modifier::ADDRESS), true);
+ IntegerType(0, IntegerType::Modifier::Address), true);
else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Invalid member access to integer."));
break;
- case Type::Category::FUNCTION:
+ case Type::Category::Function:
solAssert(!!_memberAccess.getExpression().getType()->getMemberType(member),
"Invalid member access to function.");
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
if (member == "coinbase")
m_context << eth::Instruction::COINBASE;
@@ -475,7 +475,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unknown magic member."));
break;
- case Type::Category::STRUCT:
+ case Type::Category::Struct:
{
StructType const& type = dynamic_cast<StructType const&>(*_memberAccess.getExpression().getType());
m_context << type.getStorageOffsetOfMember(member) << eth::Instruction::ADD;
@@ -483,7 +483,7 @@ void ExpressionCompiler::endVisit(MemberAccess const& _memberAccess)
m_currentLValue.retrieveValueIfLValueNotRequested(_memberAccess);
break;
}
- case Type::Category::TYPE:
+ case Type::Category::Type:
{
TypeType const& type = dynamic_cast<TypeType const&>(*_memberAccess.getExpression().getType());
if (type.getMembers().getMemberType(member))
@@ -526,7 +526,7 @@ void ExpressionCompiler::endVisit(Identifier const& _identifier)
Declaration const* declaration = _identifier.getReferencedDeclaration();
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"
if (!dynamic_cast<ContractType const&>(*magicVar->getType()).isSuper())
m_context << eth::Instruction::ADDRESS;
@@ -556,9 +556,9 @@ void ExpressionCompiler::endVisit(Literal const& _literal)
{
switch (_literal.getType()->getCategory())
{
- case Type::Category::INTEGER_CONSTANT:
- case Type::Category::BOOL:
- case Type::Category::STRING:
+ case Type::Category::IntegerConstant:
+ case Type::Category::Bool:
+ case Type::Category::String:
m_context << _literal.getType()->literalValue(&_literal);
break;
default:
@@ -569,11 +569,11 @@ void ExpressionCompiler::endVisit(Literal const& _literal)
void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryOperation)
{
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);
m_context << eth::Instruction::DUP1;
- if (c_op == Token::AND)
+ if (c_op == Token::And)
m_context << eth::Instruction::ISZERO;
eth::AssemblyItem endLabel = m_context.appendConditionalJump();
m_context << eth::Instruction::POP;
@@ -583,10 +583,10 @@ void ExpressionCompiler::appendAndOrOperatorCode(BinaryOperation const& _binaryO
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;
- if (_operator == Token::NE)
+ if (_operator == Token::NotEquals)
m_context << eth::Instruction::ISZERO;
}
else
@@ -596,18 +596,18 @@ void ExpressionCompiler::appendCompareOperatorCode(Token::Value _operator, Type
switch (_operator)
{
- case Token::GTE:
+ case Token::GreaterThanOrEquals:
m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT)
<< eth::Instruction::ISZERO;
break;
- case Token::LTE:
+ case Token::LessThanOrEquals:
m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT)
<< eth::Instruction::ISZERO;
break;
- case Token::GT:
+ case Token::GreaterThan:
m_context << (c_isSigned ? eth::Instruction::SGT : eth::Instruction::GT);
break;
- case Token::LT:
+ case Token::LessThan:
m_context << (c_isSigned ? eth::Instruction::SLT : eth::Instruction::LT);
break;
default:
@@ -635,19 +635,19 @@ void ExpressionCompiler::appendArithmeticOperatorCode(Token::Value _operator, Ty
switch (_operator)
{
- case Token::ADD:
+ case Token::Add:
m_context << eth::Instruction::ADD;
break;
- case Token::SUB:
+ case Token::Sub:
m_context << eth::Instruction::SUB;
break;
- case Token::MUL:
+ case Token::Mul:
m_context << eth::Instruction::MUL;
break;
- case Token::DIV:
+ case Token::Div:
m_context << (c_isSigned ? eth::Instruction::SDIV : eth::Instruction::DIV);
break;
- case Token::MOD:
+ case Token::Mod:
m_context << (c_isSigned ? eth::Instruction::SMOD : eth::Instruction::MOD);
break;
default:
@@ -659,13 +659,13 @@ void ExpressionCompiler::appendBitOperatorCode(Token::Value _operator)
{
switch (_operator)
{
- case Token::BIT_OR:
+ case Token::BitOr:
m_context << eth::Instruction::OR;
break;
- case Token::BIT_AND:
+ case Token::BitAnd:
m_context << eth::Instruction::AND;
break;
- case Token::BIT_XOR:
+ case Token::BitXor:
m_context << eth::Instruction::XOR;
break;
default:
@@ -698,9 +698,9 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
Type::Category stackTypeCategory = _typeOnStack.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
// only to shift right because of opposite alignment
@@ -712,15 +712,15 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
}
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
//@todo clear lower-order bytes if we allow explicit conversion to shorter strings
}
}
- else if (stackTypeCategory == Type::Category::INTEGER || stackTypeCategory == Type::Category::CONTRACT ||
- stackTypeCategory == Type::Category::INTEGER_CONSTANT)
+ else if (stackTypeCategory == Type::Category::Integer || stackTypeCategory == Type::Category::Contract ||
+ 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
// only to shift left because of opposite alignment
@@ -732,11 +732,11 @@ void ExpressionCompiler::appendTypeConversion(Type const& _typeOnStack, Type con
}
else
{
- solAssert(targetTypeCategory == Type::Category::INTEGER || targetTypeCategory == Type::Category::CONTRACT, "");
- IntegerType addressType(0, IntegerType::Modifier::ADDRESS);
- IntegerType const& targetType = targetTypeCategory == Type::Category::INTEGER
+ solAssert(targetTypeCategory == Type::Category::Integer || targetTypeCategory == Type::Category::Contract, "");
+ IntegerType addressType(0, IntegerType::Modifier::Address);
+ IntegerType const& targetType = targetTypeCategory == Type::Category::Integer
? 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);
// 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
{
- IntegerType const& typeOnStack = stackTypeCategory == Type::Category::INTEGER
+ IntegerType const& typeOnStack = stackTypeCategory == Type::Category::Integer
? dynamic_cast<IntegerType const&>(_typeOnStack) : addressType;
// Widening: clean up according to source type width
// Non-widening and force: clean up according to target type bits
@@ -831,7 +831,7 @@ void ExpressionCompiler::appendExternalFunctionCall(FunctionType const& _functio
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);
}
}
@@ -866,7 +866,7 @@ unsigned ExpressionCompiler::moveTypeToMemory(Type const& _type, Location const&
BOOST_THROW_EXCEPTION(CompilerError()
<< errinfo_sourceLocation(_location)
<< 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);
}
diff --git a/Parser.cpp b/Parser.cpp
index c4bb5482..1fa8fbe8 100644
--- a/Parser.cpp
+++ b/Parser.cpp
@@ -69,10 +69,10 @@ ASTPointer<SourceUnit> Parser::parse(shared_ptr<Scanner> const& _scanner)
{
switch (m_scanner->getCurrentToken())
{
- case Token::IMPORT:
+ case Token::Import:
nodes.push_back(parseImportDirective());
break;
- case Token::CONTRACT:
+ case Token::Contract:
nodes.push_back(parseContractDefinition());
break;
default:
@@ -100,12 +100,12 @@ int Parser::getEndPosition() const
ASTPointer<ImportDirective> Parser::parseImportDirective()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::IMPORT);
- if (m_scanner->getCurrentToken() != Token::STRING_LITERAL)
+ expectToken(Token::Import);
+ if (m_scanner->getCurrentToken() != Token::StringLiteral)
BOOST_THROW_EXCEPTION(createParserError("Expected string literal (URL)."));
ASTPointer<ASTString> url = getLiteralAndAdvance();
nodeFactory.markEndPosition();
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
return nodeFactory.createNode<ImportDirective>(url);
}
@@ -115,7 +115,7 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
ASTPointer<ASTString> docString;
if (m_scanner->getCurrentCommentLiteral() != "")
docString = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
- expectToken(Token::CONTRACT);
+ expectToken(Token::Contract);
ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<InheritanceSpecifier>> baseContracts;
vector<ASTPointer<StructDefinition>> structs;
@@ -123,40 +123,40 @@ ASTPointer<ContractDefinition> Parser::parseContractDefinition()
vector<ASTPointer<FunctionDefinition>> functions;
vector<ASTPointer<ModifierDefinition>> modifiers;
vector<ASTPointer<EventDefinition>> events;
- if (m_scanner->getCurrentToken() == Token::IS)
+ if (m_scanner->getCurrentToken() == Token::Is)
do
{
m_scanner->next();
baseContracts.push_back(parseInheritanceSpecifier());
}
- while (m_scanner->getCurrentToken() == Token::COMMA);
- expectToken(Token::LBRACE);
+ while (m_scanner->getCurrentToken() == Token::Comma);
+ expectToken(Token::LBrace);
while (true)
{
Token::Value currentToken = m_scanner->getCurrentToken();
- if (currentToken == Token::RBRACE)
+ if (currentToken == Token::RBrace)
break;
- else if (currentToken == Token::FUNCTION)
+ else if (currentToken == Token::Function)
functions.push_back(parseFunctionDefinition(name.get()));
- else if (currentToken == Token::STRUCT)
+ else if (currentToken == Token::Struct)
structs.push_back(parseStructDefinition());
- else if (currentToken == Token::IDENTIFIER || currentToken == Token::MAPPING ||
+ else if (currentToken == Token::Identifier || currentToken == Token::Mapping ||
Token::isElementaryTypeName(currentToken))
{
VarDeclParserOptions options;
options.isStateVariable = true;
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());
- else if (currentToken == Token::EVENT)
+ else if (currentToken == Token::Event)
events.push_back(parseEventDefinition());
else
BOOST_THROW_EXCEPTION(createParserError("Function, variable, struct or modifier declaration expected."));
}
nodeFactory.markEndPosition();
- expectToken(Token::RBRACE);
+ expectToken(Token::RBrace);
return nodeFactory.createNode<ContractDefinition>(name, docString, baseContracts, structs,
stateVariables, functions, modifiers, events);
}
@@ -166,12 +166,12 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
ASTNodeFactory nodeFactory(*this);
ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments;
- if (m_scanner->getCurrentToken() == Token::LPAREN)
+ if (m_scanner->getCurrentToken() == Token::LParen)
{
m_scanner->next();
arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
@@ -181,11 +181,11 @@ ASTPointer<InheritanceSpecifier> Parser::parseInheritanceSpecifier()
Declaration::Visibility Parser::parseVisibilitySpecifier(Token::Value _token)
{
Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
- if (_token == Token::PUBLIC)
+ if (_token == Token::Public)
visibility = Declaration::Visibility::PUBLIC;
- else if (_token == Token::PROTECTED)
+ else if (_token == Token::Protected)
visibility = Declaration::Visibility::PROTECTED;
- else if (_token == Token::PRIVATE)
+ else if (_token == Token::Private)
visibility = Declaration::Visibility::PRIVATE;
else
solAssert(false, "Invalid visibility specifier.");
@@ -200,9 +200,9 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
- expectToken(Token::FUNCTION);
+ expectToken(Token::Function);
ASTPointer<ASTString> name;
- if (m_scanner->getCurrentToken() == Token::LPAREN)
+ if (m_scanner->getCurrentToken() == Token::LParen)
name = make_shared<ASTString>(); // anonymous function
else
name = expectIdentifierToken();
@@ -213,12 +213,12 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
while (true)
{
Token::Value token = m_scanner->getCurrentToken();
- if (token == Token::CONST)
+ if (token == Token::Const)
{
isDeclaredConst = true;
m_scanner->next();
}
- else if (token == Token::IDENTIFIER)
+ else if (token == Token::Identifier)
modifiers.push_back(parseModifierInvocation());
else if (Token::isVisibilitySpecifier(token))
{
@@ -230,7 +230,7 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
break;
}
ASTPointer<ParameterList> returnParameters;
- if (m_scanner->getCurrentToken() == Token::RETURNS)
+ if (m_scanner->getCurrentToken() == Token::Returns)
{
bool const permitEmptyParameterList = false;
m_scanner->next();
@@ -249,17 +249,17 @@ ASTPointer<FunctionDefinition> Parser::parseFunctionDefinition(ASTString const*
ASTPointer<StructDefinition> Parser::parseStructDefinition()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::STRUCT);
+ expectToken(Token::Struct);
ASTPointer<ASTString> name = expectIdentifierToken();
vector<ASTPointer<VariableDeclaration>> members;
- expectToken(Token::LBRACE);
- while (m_scanner->getCurrentToken() != Token::RBRACE)
+ expectToken(Token::LBrace);
+ while (m_scanner->getCurrentToken() != Token::RBrace)
{
members.push_back(parseVariableDeclaration());
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
}
nodeFactory.markEndPosition();
- expectToken(Token::RBRACE);
+ expectToken(Token::RBrace);
return nodeFactory.createNode<StructDefinition>(name, members);
}
@@ -275,13 +275,13 @@ ASTPointer<VariableDeclaration> Parser::parseVariableDeclaration(VarDeclParserOp
Declaration::Visibility visibility(Declaration::Visibility::DEFAULT);
if (_options.isStateVariable && Token::isVisibilitySpecifier(token))
visibility = parseVisibilitySpecifier(token);
- if (_options.allowIndexed && token == Token::INDEXED)
+ if (_options.allowIndexed && token == Token::Indexed)
{
isIndexed = true;
m_scanner->next();
}
nodeFactory.markEndPosition();
- if (_options.allowEmptyName && m_scanner->getCurrentToken() != Token::IDENTIFIER)
+ if (_options.allowEmptyName && m_scanner->getCurrentToken() != Token::Identifier)
{
identifier = make_shared<ASTString>("");
solAssert(type != nullptr, "");
@@ -304,10 +304,10 @@ ASTPointer<ModifierDefinition> Parser::parseModifierDefinition()
if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
- expectToken(Token::MODIFIER);
+ expectToken(Token::Modifier);
ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters;
- if (m_scanner->getCurrentToken() == Token::LPAREN)
+ if (m_scanner->getCurrentToken() == Token::LParen)
parameters = parseParameterList();
else
parameters = createEmptyParameterList();
@@ -323,15 +323,15 @@ ASTPointer<EventDefinition> Parser::parseEventDefinition()
if (m_scanner->getCurrentCommentLiteral() != "")
docstring = make_shared<ASTString>(m_scanner->getCurrentCommentLiteral());
- expectToken(Token::EVENT);
+ expectToken(Token::Event);
ASTPointer<ASTString> name(expectIdentifierToken());
ASTPointer<ParameterList> parameters;
- if (m_scanner->getCurrentToken() == Token::LPAREN)
+ if (m_scanner->getCurrentToken() == Token::LParen)
parameters = parseParameterList(true, true);
else
parameters = createEmptyParameterList();
nodeFactory.markEndPosition();
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
return nodeFactory.createNode<EventDefinition>(name, docstring, parameters);
}
@@ -340,12 +340,12 @@ ASTPointer<ModifierInvocation> Parser::parseModifierInvocation()
ASTNodeFactory nodeFactory(*this);
ASTPointer<Identifier> name(parseIdentifier());
vector<ASTPointer<Expression>> arguments;
- if (m_scanner->getCurrentToken() == Token::LPAREN)
+ if (m_scanner->getCurrentToken() == Token::LParen)
{
m_scanner->next();
arguments = parseFunctionCallListArguments();
nodeFactory.markEndPosition();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
}
else
nodeFactory.setEndPositionFromNode(name);
@@ -368,17 +368,17 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
type = ASTNodeFactory(*this).createNode<ElementaryTypeName>(token);
m_scanner->next();
}
- else if (token == Token::VAR)
+ else if (token == Token::Var)
{
if (!_allowVar)
BOOST_THROW_EXCEPTION(createParserError("Expected explicit type name."));
m_scanner->next();
}
- else if (token == Token::MAPPING)
+ else if (token == Token::Mapping)
{
type = parseMapping();
}
- else if (token == Token::IDENTIFIER)
+ else if (token == Token::Identifier)
{
ASTNodeFactory nodeFactory(*this);
nodeFactory.markEndPosition();
@@ -392,18 +392,18 @@ ASTPointer<TypeName> Parser::parseTypeName(bool _allowVar)
ASTPointer<Mapping> Parser::parseMapping()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::MAPPING);
- expectToken(Token::LPAREN);
+ expectToken(Token::Mapping);
+ expectToken(Token::LParen);
if (!Token::isElementaryTypeName(m_scanner->getCurrentToken()))
BOOST_THROW_EXCEPTION(createParserError("Expected elementary type name for mapping key type"));
ASTPointer<ElementaryTypeName> keyType;
keyType = ASTNodeFactory(*this).createNode<ElementaryTypeName>(m_scanner->getCurrentToken());
m_scanner->next();
- expectToken(Token::ARROW);
+ expectToken(Token::Arrow);
bool const allowVar = false;
ASTPointer<TypeName> valueType = parseTypeName(allowVar);
nodeFactory.markEndPosition();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
return nodeFactory.createNode<Mapping>(keyType, valueType);
}
@@ -414,13 +414,13 @@ ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty, bool _all
VarDeclParserOptions options;
options.allowIndexed = _allowIndexed;
options.allowEmptyName = true;
- expectToken(Token::LPAREN);
- if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RPAREN)
+ expectToken(Token::LParen);
+ if (!_allowEmpty || m_scanner->getCurrentToken() != Token::RParen)
{
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));
}
}
@@ -432,12 +432,12 @@ ASTPointer<ParameterList> Parser::parseParameterList(bool _allowEmpty, bool _all
ASTPointer<Block> Parser::parseBlock()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::LBRACE);
+ expectToken(Token::LBrace);
vector<ASTPointer<Statement>> statements;
- while (m_scanner->getCurrentToken() != Token::RBRACE)
+ while (m_scanner->getCurrentToken() != Token::RBrace)
statements.push_back(parseStatement());
nodeFactory.markEndPosition();
- expectToken(Token::RBRACE);
+ expectToken(Token::RBrace);
return nodeFactory.createNode<Block>(statements);
}
@@ -446,28 +446,28 @@ ASTPointer<Statement> Parser::parseStatement()
ASTPointer<Statement> statement;
switch (m_scanner->getCurrentToken())
{
- case Token::IF:
+ case Token::If:
return parseIfStatement();
- case Token::WHILE:
+ case Token::While:
return parseWhileStatement();
- case Token::FOR:
+ case Token::For:
return parseForStatement();
- case Token::LBRACE:
+ case Token::LBrace:
return parseBlock();
// starting from here, all statements must be terminated by a semicolon
- case Token::CONTINUE:
+ case Token::Continue:
statement = ASTNodeFactory(*this).createNode<Continue>();
m_scanner->next();
break;
- case Token::BREAK:
+ case Token::Break:
statement = ASTNodeFactory(*this).createNode<Break>();
m_scanner->next();
break;
- case Token::RETURN:
+ case Token::Return:
{
ASTNodeFactory nodeFactory(*this);
ASTPointer<Expression> expression;
- if (m_scanner->next() != Token::SEMICOLON)
+ if (m_scanner->next() != Token::Semicolon)
{
expression = parseExpression();
nodeFactory.setEndPositionFromNode(expression);
@@ -475,7 +475,7 @@ ASTPointer<Statement> Parser::parseStatement()
statement = nodeFactory.createNode<Return>(expression);
break;
}
- case Token::IDENTIFIER:
+ case Token::Identifier:
if (m_insideModifier && m_scanner->getCurrentLiteral() == "_")
{
statement = ASTNodeFactory(*this).createNode<PlaceholderStatement>();
@@ -486,20 +486,20 @@ ASTPointer<Statement> Parser::parseStatement()
default:
statement = parseVarDefOrExprStmt();
}
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
return statement;
}
ASTPointer<IfStatement> Parser::parseIfStatement()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::IF);
- expectToken(Token::LPAREN);
+ expectToken(Token::If);
+ expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
ASTPointer<Statement> trueBody = parseStatement();
ASTPointer<Statement> falseBody;
- if (m_scanner->getCurrentToken() == Token::ELSE)
+ if (m_scanner->getCurrentToken() == Token::Else)
{
m_scanner->next();
falseBody = parseStatement();
@@ -513,10 +513,10 @@ ASTPointer<IfStatement> Parser::parseIfStatement()
ASTPointer<WhileStatement> Parser::parseWhileStatement()
{
ASTNodeFactory nodeFactory(*this);
- expectToken(Token::WHILE);
- expectToken(Token::LPAREN);
+ expectToken(Token::While);
+ expectToken(Token::LParen);
ASTPointer<Expression> condition = parseExpression();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
return nodeFactory.createNode<WhileStatement>(condition, body);
@@ -528,21 +528,21 @@ ASTPointer<ForStatement> Parser::parseForStatement()
ASTPointer<Statement> initExpression;
ASTPointer<Expression> conditionExpression;
ASTPointer<ExpressionStatement> loopExpression;
- expectToken(Token::FOR);
- expectToken(Token::LPAREN);
+ expectToken(Token::For);
+ expectToken(Token::LParen);
- // LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RPAREN?
- if (m_scanner->getCurrentToken() != Token::SEMICOLON)
+ // LTODO: Maybe here have some predicate like peekExpression() instead of checking for semicolon and RParen?
+ if (m_scanner->getCurrentToken() != Token::Semicolon)
initExpression = parseVarDefOrExprStmt();
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
- if (m_scanner->getCurrentToken() != Token::SEMICOLON)
+ if (m_scanner->getCurrentToken() != Token::Semicolon)
conditionExpression = parseExpression();
- expectToken(Token::SEMICOLON);
+ expectToken(Token::Semicolon);
- if (m_scanner->getCurrentToken() != Token::RPAREN)
+ if (m_scanner->getCurrentToken() != Token::RParen)
loopExpression = parseExpressionStatement();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
ASTPointer<Statement> body = parseStatement();
nodeFactory.setEndPositionFromNode(body);
@@ -567,7 +567,7 @@ ASTPointer<VariableDefinition> Parser::parseVariableDefinition()
options.allowVar = true;
ASTPointer<VariableDeclaration> variable = parseVariableDeclaration(options);
ASTPointer<Expression> value;
- if (m_scanner->getCurrentToken() == Token::ASSIGN)
+ if (m_scanner->getCurrentToken() == Token::Assign)
{
m_scanner->next();
value = parseExpression();
@@ -644,9 +644,9 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
{
ASTNodeFactory nodeFactory(*this);
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());
nodeFactory.setEndPositionFromNode(contractName);
expression = nodeFactory.createNode<NewExpression>(contractName);
@@ -658,30 +658,30 @@ ASTPointer<Expression> Parser::parseLeftHandSideExpression()
{
switch (m_scanner->getCurrentToken())
{
- case Token::LBRACK:
+ case Token::LBrack:
{
m_scanner->next();
ASTPointer<Expression> index = parseExpression();
nodeFactory.markEndPosition();
- expectToken(Token::RBRACK);
+ expectToken(Token::RBrack);
expression = nodeFactory.createNode<IndexAccess>(expression, index);
}
break;
- case Token::PERIOD:
+ case Token::Period:
{
m_scanner->next();
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<MemberAccess>(expression, expectIdentifierToken());
}
break;
- case Token::LPAREN:
+ case Token::LParen:
{
m_scanner->next();
vector<ASTPointer<Expression>> arguments;
vector<ASTPointer<ASTString>> names;
std::tie(arguments, names) = parseFunctionCallArguments();
nodeFactory.markEndPosition();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
expression = nodeFactory.createNode<FunctionCall>(expression, arguments, names);
}
break;
@@ -698,11 +698,11 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
ASTPointer<Expression> expression;
switch (token)
{
- case Token::TRUE_LITERAL:
- case Token::FALSE_LITERAL:
+ case Token::TrueLiteral:
+ case Token::FalseLiteral:
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
- case Token::NUMBER:
+ case Token::Number:
if (Token::isEtherSubdenomination(m_scanner->peekNextToken()))
{
ASTPointer<ASTString> literal = getLiteralAndAdvance();
@@ -713,19 +713,19 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
break;
}
// fall-through
- case Token::STRING_LITERAL:
+ case Token::StringLiteral:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Literal>(token, getLiteralAndAdvance());
break;
- case Token::IDENTIFIER:
+ case Token::Identifier:
nodeFactory.markEndPosition();
expression = nodeFactory.createNode<Identifier>(getLiteralAndAdvance());
break;
- case Token::LPAREN:
+ case Token::LParen:
{
m_scanner->next();
ASTPointer<Expression> expression = parseExpression();
- expectToken(Token::RPAREN);
+ expectToken(Token::RParen);
return expression;
}
default:
@@ -748,12 +748,12 @@ ASTPointer<Expression> Parser::parsePrimaryExpression()
vector<ASTPointer<Expression>> Parser::parseFunctionCallListArguments()
{
vector<ASTPointer<Expression>> arguments;
- if (m_scanner->getCurrentToken() != Token::RPAREN)
+ if (m_scanner->getCurrentToken() != Token::RParen)
{
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());
}
}
@@ -764,22 +764,22 @@ pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> Parser::pars
{
pair<vector<ASTPointer<Expression>>, vector<ASTPointer<ASTString>>> ret;
Token::Value token = m_scanner->getCurrentToken();
- if (token == Token::LBRACE)
+ if (token == Token::LBrace)
{
// call({arg1 : 1, arg2 : 2 })
- expectToken(Token::LBRACE);
- while (m_scanner->getCurrentToken() != Token::RBRACE)
+ expectToken(Token::LBrace);
+ while (m_scanner->getCurrentToken() != Token::RBrace)
{
ret.second.push_back(expectIdentifierToken());
- expectToken(Token::COLON);
+ expectToken(Token::Colon);
ret.first.push_back(parseExpression());
- if (m_scanner->getCurrentToken() == Token::COMMA)
- expectToken(Token::COMMA);
+ if (m_scanner->getCurrentToken() == Token::Comma)
+ expectToken(Token::Comma);
else
break;
}
- expectToken(Token::RBRACE);
+ expectToken(Token::RBrace);
}
else
ret.first = parseFunctionCallListArguments();
@@ -793,11 +793,11 @@ bool Parser::peekVariableDefinition()
// (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
// in the case of a user-defined type, we have two identifiers following each other.
- return (m_scanner->getCurrentToken() == Token::MAPPING ||
- m_scanner->getCurrentToken() == Token::VAR ||
+ return (m_scanner->getCurrentToken() == Token::Mapping ||
+ m_scanner->getCurrentToken() == Token::Var ||
((Token::isElementaryTypeName(m_scanner->getCurrentToken()) ||
- m_scanner->getCurrentToken() == Token::IDENTIFIER) &&
- m_scanner->peekNextToken() == Token::IDENTIFIER));
+ m_scanner->getCurrentToken() == Token::Identifier) &&
+ m_scanner->peekNextToken() == Token::Identifier));
}
void Parser::expectToken(Token::Value _value)
@@ -818,7 +818,7 @@ Token::Value Parser::expectAssignmentOperator()
ASTPointer<ASTString> Parser::expectIdentifierToken()
{
- if (m_scanner->getCurrentToken() != Token::IDENTIFIER)
+ if (m_scanner->getCurrentToken() != Token::Identifier)
BOOST_THROW_EXCEPTION(createParserError("Expected identifier"));
return getLiteralAndAdvance();
}
diff --git a/Scanner.cpp b/Scanner.cpp
index 6a8ecd9d..8d2530b9 100644
--- a/Scanner.cpp
+++ b/Scanner.cpp
@@ -225,7 +225,7 @@ Token::Value Scanner::skipSingleLineComment()
// separately by the lexical grammar and becomes part of the
// stream of input elements for the syntactic grammar
while (advance() && !isLineTerminator(m_char)) { };
- return Token::WHITESPACE;
+ return Token::Whitespace;
}
Token::Value Scanner::scanSingleLineDocComment()
@@ -255,7 +255,7 @@ Token::Value Scanner::scanSingleLineDocComment()
advance();
}
literal.complete();
- return Token::COMMENT_LITERAL;
+ return Token::CommentLiteral;
}
Token::Value Scanner::skipMultiLineComment()
@@ -272,11 +272,11 @@ Token::Value Scanner::skipMultiLineComment()
if (ch == '*' && m_char == '/')
{
m_char = ' ';
- return Token::WHITESPACE;
+ return Token::Whitespace;
}
}
// Unterminated multi-line comment.
- return Token::ILLEGAL;
+ return Token::Illegal;
}
Token::Value Scanner::scanMultiLineDocComment()
@@ -319,9 +319,9 @@ Token::Value Scanner::scanMultiLineDocComment()
}
literal.complete();
if (!endFound)
- return Token::ILLEGAL;
+ return Token::Illegal;
else
- return Token::COMMENT_LITERAL;
+ return Token::CommentLiteral;
}
Token::Value Scanner::scanSlash()
@@ -331,7 +331,7 @@ Token::Value Scanner::scanSlash()
if (m_char == '/')
{
if (!advance()) /* double slash comment directly before EOS */
- return Token::WHITESPACE;
+ return Token::Whitespace;
else if (m_char == '/')
{
// doxygen style /// comment
@@ -340,7 +340,7 @@ Token::Value Scanner::scanSlash()
comment = scanSingleLineDocComment();
m_nextSkippedComment.location.end = getSourcePos();
m_nextSkippedComment.token = comment;
- return Token::WHITESPACE;
+ return Token::Whitespace;
}
else
return skipSingleLineComment();
@@ -349,7 +349,7 @@ Token::Value Scanner::scanSlash()
{
// doxygen style /** natspec comment
if (!advance()) /* slash star comment before EOS */
- return Token::WHITESPACE;
+ return Token::Whitespace;
else if (m_char == '*')
{
advance(); //consume the last '*' at /**
@@ -366,15 +366,15 @@ Token::Value Scanner::scanSlash()
m_nextSkippedComment.location.end = getSourcePos();
m_nextSkippedComment.token = comment;
}
- return Token::WHITESPACE;
+ return Token::Whitespace;
}
else
return skipMultiLineComment();
}
else if (m_char == '=')
- return selectToken(Token::ASSIGN_DIV);
+ return selectToken(Token::AssignDiv);
else
- return Token::DIV;
+ return Token::Div;
}
void Scanner::scanToken()
@@ -391,7 +391,7 @@ void Scanner::scanToken()
case '\n': // fall-through
case ' ':
case '\t':
- token = selectToken(Token::WHITESPACE);
+ token = selectToken(Token::Whitespace);
break;
case '"':
case '\'':
@@ -401,76 +401,76 @@ void Scanner::scanToken()
// < <= << <<=
advance();
if (m_char == '=')
- token = selectToken(Token::LTE);
+ token = selectToken(Token::LessThanOrEquals);
else if (m_char == '<')
- token = selectToken('=', Token::ASSIGN_SHL, Token::SHL);
+ token = selectToken('=', Token::AssignShl, Token::SHL);
else
- token = Token::LT;
+ token = Token::LessThan;
break;
case '>':
// > >= >> >>= >>> >>>=
advance();
if (m_char == '=')
- token = selectToken(Token::GTE);
+ token = selectToken(Token::GreaterThanOrEquals);
else if (m_char == '>')
{
// >> >>= >>> >>>=
advance();
if (m_char == '=')
- token = selectToken(Token::ASSIGN_SAR);
+ token = selectToken(Token::AssignSar);
else if (m_char == '>')
- token = selectToken('=', Token::ASSIGN_SHR, Token::SHR);
+ token = selectToken('=', Token::AssignShr, Token::SHR);
else
token = Token::SAR;
}
else
- token = Token::GT;
+ token = Token::GreaterThan;
break;
case '=':
// = == =>
advance();
if (m_char == '=')
- token = selectToken(Token::EQ);
+ token = selectToken(Token::Equals);
else if (m_char == '>')
- token = selectToken(Token::ARROW);
+ token = selectToken(Token::Arrow);
else
- token = Token::ASSIGN;
+ token = Token::Assign;
break;
case '!':
// ! !=
advance();
if (m_char == '=')
- token = selectToken(Token::NE);
+ token = selectToken(Token::NotEquals);
else
- token = Token::NOT;
+ token = Token::Not;
break;
case '+':
// + ++ +=
advance();
if (m_char == '+')
- token = selectToken(Token::INC);
+ token = selectToken(Token::Inc);
else if (m_char == '=')
- token = selectToken(Token::ASSIGN_ADD);
+ token = selectToken(Token::AssignAdd);
else
- token = Token::ADD;
+ token = Token::Add;
break;
case '-':
// - -- -=
advance();
if (m_char == '-')
- token = selectToken(Token::DEC);
+ token = selectToken(Token::Dec);
else if (m_char == '=')
- token = selectToken(Token::ASSIGN_SUB);
+ token = selectToken(Token::AssignSub);
else
- token = Token::SUB;
+ token = Token::Sub;
break;
case '*':
// * *=
- token = selectToken('=', Token::ASSIGN_MUL, Token::MUL);
+ token = selectToken('=', Token::AssignMul, Token::Mul);
break;
case '%':
// % %=
- token = selectToken('=', Token::ASSIGN_MOD, Token::MOD);
+ token = selectToken('=', Token::AssignMod, Token::Mod);
break;
case '/':
// / // /* /=
@@ -480,25 +480,25 @@ void Scanner::scanToken()
// & && &=
advance();
if (m_char == '&')
- token = selectToken(Token::AND);
+ token = selectToken(Token::And);
else if (m_char == '=')
- token = selectToken(Token::ASSIGN_BIT_AND);
+ token = selectToken(Token::AssignBitAnd);
else
- token = Token::BIT_AND;
+ token = Token::BitAnd;
break;
case '|':
// | || |=
advance();
if (m_char == '|')
- token = selectToken(Token::OR);
+ token = selectToken(Token::Or);
else if (m_char == '=')
- token = selectToken(Token::ASSIGN_BIT_OR);
+ token = selectToken(Token::AssignBitOr);
else
- token = Token::BIT_OR;
+ token = Token::BitOr;
break;
case '^':
// ^ ^=
- token = selectToken('=', Token::ASSIGN_BIT_XOR, Token::BIT_XOR);
+ token = selectToken('=', Token::AssignBitXor, Token::BitXor);
break;
case '.':
// . Number
@@ -506,40 +506,40 @@ void Scanner::scanToken()
if (isDecimalDigit(m_char))
token = scanNumber('.');
else
- token = Token::PERIOD;
+ token = Token::Period;
break;
case ':':
- token = selectToken(Token::COLON);
+ token = selectToken(Token::Colon);
break;
case ';':
- token = selectToken(Token::SEMICOLON);
+ token = selectToken(Token::Semicolon);
break;
case ',':
- token = selectToken(Token::COMMA);
+ token = selectToken(Token::Comma);
break;
case '(':
- token = selectToken(Token::LPAREN);
+ token = selectToken(Token::LParen);
break;
case ')':
- token = selectToken(Token::RPAREN);
+ token = selectToken(Token::RParen);
break;
case '[':
- token = selectToken(Token::LBRACK);
+ token = selectToken(Token::LBrack);
break;
case ']':
- token = selectToken(Token::RBRACK);
+ token = selectToken(Token::RBrack);
break;
case '{':
- token = selectToken(Token::LBRACE);
+ token = selectToken(Token::LBrace);
break;
case '}':
- token = selectToken(Token::RBRACE);
+ token = selectToken(Token::RBrace);
break;
case '?':
- token = selectToken(Token::CONDITIONAL);
+ token = selectToken(Token::Conditional);
break;
case '~':
- token = selectToken(Token::BIT_NOT);
+ token = selectToken(Token::BitNot);
break;
default:
if (isIdentifierStart(m_char))
@@ -547,17 +547,17 @@ void Scanner::scanToken()
else if (isDecimalDigit(m_char))
token = scanNumber();
else if (skipWhitespace())
- token = Token::WHITESPACE;
+ token = Token::Whitespace;
else if (isSourcePastEndOfInput())
token = Token::EOS;
else
- token = selectToken(Token::ILLEGAL);
+ token = selectToken(Token::Illegal);
break;
}
// Continue scanning for tokens as long as we're just skipping
// whitespace.
}
- while (token == Token::WHITESPACE);
+ while (token == Token::Whitespace);
m_nextToken.location.end = getSourcePos();
m_nextToken.token = token;
}
@@ -615,16 +615,16 @@ Token::Value Scanner::scanString()
if (c == '\\')
{
if (isSourcePastEndOfInput() || !scanEscape())
- return Token::ILLEGAL;
+ return Token::Illegal;
}
else
addLiteralChar(c);
}
if (m_char != quote)
- return Token::ILLEGAL;
+ return Token::Illegal;
literal.complete();
advance(); // consume quote
- return Token::STRING_LITERAL;
+ return Token::StringLiteral;
}
void Scanner::scanDecimalDigits()
@@ -657,7 +657,7 @@ Token::Value Scanner::scanNumber(char _charSeen)
kind = HEX;
addLiteralCharAndAdvance();
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))
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");
if (kind != DECIMAL)
- return Token::ILLEGAL;
+ return Token::Illegal;
// scan exponent
addLiteralCharAndAdvance();
if (m_char == '+' || m_char == '-')
addLiteralCharAndAdvance();
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();
}
// 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
// if the value is 0).
if (isDecimalDigit(m_char) || isIdentifierStart(m_char))
- return Token::ILLEGAL;
+ return Token::Illegal;
literal.complete();
- return Token::NUMBER;
+ return Token::Number;
}
Token::Value Scanner::scanIdentifierOrKeyword()
diff --git a/Token.cpp b/Token.cpp
index 7dc56c32..915e9ad9 100644
--- a/Token.cpp
+++ b/Token.cpp
@@ -79,8 +79,8 @@ int8_t const Token::m_precedence[NUM_TOKENS] =
char const Token::m_tokenType[] =
{
TOKEN_LIST(KT, KK)
-};
+};
Token::Value Token::fromIdentifierOrKeyword(const std::string& _name)
{
// 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 TOKEN
auto it = keywords.find(_name);
- return it == keywords.end() ? Token::IDENTIFIER : it->second;
+ return it == keywords.end() ? Token::Identifier : it->second;
}
#undef KT
diff --git a/Token.h b/Token.h
index b07fc46c..c0d23f13 100644
--- a/Token.h
+++ b/Token.h
@@ -47,11 +47,6 @@
#include <libsolidity/Utils.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 solidity
@@ -77,101 +72,101 @@ namespace solidity
T(EOS, "EOS", 0) \
\
/* Punctuators (ECMA-262, section 7.7, page 15). */ \
- T(LPAREN, "(", 0) \
- T(RPAREN, ")", 0) \
- T(LBRACK, "[", 0) \
- T(RBRACK, "]", 0) \
- T(LBRACE, "{", 0) \
- T(RBRACE, "}", 0) \
- T(COLON, ":", 0) \
- T(SEMICOLON, ";", 0) \
- T(PERIOD, ".", 0) \
- T(CONDITIONAL, "?", 3) \
- T(ARROW, "=>", 0) \
+ T(LParen, "(", 0) \
+ T(RParen, ")", 0) \
+ T(LBrack, "[", 0) \
+ T(RBrack, "]", 0) \
+ T(LBrace, "{", 0) \
+ T(RBrace, "}", 0) \
+ T(Colon, ":", 0) \
+ T(Semicolon, ";", 0) \
+ T(Period, ".", 0) \
+ T(Conditional, "?", 3) \
+ T(Arrow, "=>", 0) \
\
/* Assignment operators. */ \
/* IsAssignmentOp() relies on this block of enum values being */ \
/* 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*/ \
- T(ASSIGN_BIT_OR, "|=", 2) \
- T(ASSIGN_BIT_XOR, "^=", 2) \
- T(ASSIGN_BIT_AND, "&=", 2) \
- T(ASSIGN_SHL, "<<=", 2) \
- T(ASSIGN_SAR, ">>=", 2) \
- T(ASSIGN_SHR, ">>>=", 2) \
- T(ASSIGN_ADD, "+=", 2) \
- T(ASSIGN_SUB, "-=", 2) \
- T(ASSIGN_MUL, "*=", 2) \
- T(ASSIGN_DIV, "/=", 2) \
- T(ASSIGN_MOD, "%=", 2) \
+ T(AssignBitOr, "|=", 2) \
+ T(AssignBitXor, "^=", 2) \
+ T(AssignBitAnd, "&=", 2) \
+ T(AssignShl, "<<=", 2) \
+ T(AssignSar, ">>=", 2) \
+ T(AssignShr, ">>>=", 2) \
+ T(AssignAdd, "+=", 2) \
+ T(AssignSub, "-=", 2) \
+ T(AssignMul, "*=", 2) \
+ T(AssignDiv, "/=", 2) \
+ T(AssignMod, "%=", 2) \
\
/* Binary operators sorted by precedence. */ \
/* IsBinaryOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \
- T(COMMA, ",", 1) \
- T(OR, "||", 4) \
- T(AND, "&&", 5) \
- T(BIT_OR, "|", 8) \
- T(BIT_XOR, "^", 9) \
- T(BIT_AND, "&", 10) \
+ T(Comma, ",", 1) \
+ T(Or, "||", 4) \
+ T(And, "&&", 5) \
+ T(BitOr, "|", 8) \
+ T(BitXor, "^", 9) \
+ T(BitAnd, "&", 10) \
T(SHL, "<<", 11) \
T(SAR, ">>", 11) \
T(SHR, ">>>", 11) \
- T(ADD, "+", 12) \
- T(SUB, "-", 12) \
- T(MUL, "*", 13) \
- T(DIV, "/", 13) \
- T(MOD, "%", 13) \
+ T(Add, "+", 12) \
+ T(Sub, "-", 12) \
+ T(Mul, "*", 13) \
+ T(Div, "/", 13) \
+ T(Mod, "%", 13) \
\
/* Compare operators sorted by precedence. */ \
/* IsCompareOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \
- T(EQ, "==", 6) \
- T(NE, "!=", 6) \
- T(LT, "<", 7) \
- T(GT, ">", 7) \
- T(LTE, "<=", 7) \
- T(GTE, ">=", 7) \
- K(IN, "in", 7) \
+ T(Equals, "==", 6) \
+ T(NotEquals, "!=", 6) \
+ T(LessThan, "<", 7) \
+ T(GreaterThan, ">", 7) \
+ T(LessThanOrEquals, "<=", 7) \
+ T(GreaterThanOrEquals, ">=", 7) \
+ K(In, "in", 7) \
\
/* Unary operators. */ \
/* IsUnaryOp() relies on this block of enum values */ \
/* being contiguous and sorted in the same order! */ \
- T(NOT, "!", 0) \
- T(BIT_NOT, "~", 0) \
- T(INC, "++", 0) \
- T(DEC, "--", 0) \
- K(DELETE, "delete", 0) \
+ T(Not, "!", 0) \
+ T(BitNot, "~", 0) \
+ T(Inc, "++", 0) \
+ T(Dec, "--", 0) \
+ K(Delete, "delete", 0) \
\
/* Keywords */ \
- K(BREAK, "break", 0) \
- K(CASE, "case", 0) \
- K(CONST, "constant", 0) \
- K(CONTINUE, "continue", 0) \
- K(CONTRACT, "contract", 0) \
- K(DEFAULT, "default", 0) \
- K(DO, "do", 0) \
- K(ELSE, "else", 0) \
- K(EVENT, "event", 0) \
- K(IS, "is", 0) \
- K(INDEXED, "indexed", 0) \
- K(FOR, "for", 0) \
- K(FUNCTION, "function", 0) \
- K(IF, "if", 0) \
- K(IMPORT, "import", 0) \
- K(MAPPING, "mapping", 0) \
- K(MODIFIER, "modifier", 0) \
- K(NEW, "new", 0) \
- K(PUBLIC, "public", 0) \
- K(PRIVATE, "private", 0) \
- K(PROTECTED, "protected", 0) \
- K(RETURN, "return", 0) \
- K(RETURNS, "returns", 0) \
- K(STRUCT, "struct", 0) \
- K(SWITCH, "switch", 0) \
- K(VAR, "var", 0) \
- K(WHILE, "while", 0) \
+ K(Break, "break", 0) \
+ K(Case, "case", 0) \
+ K(Const, "constant", 0) \
+ K(Continue, "continue", 0) \
+ K(Contract, "contract", 0) \
+ K(Default, "default", 0) \
+ K(Do, "do", 0) \
+ K(Else, "else", 0) \
+ K(Event, "event", 0) \
+ K(Is, "is", 0) \
+ K(Indexed, "indexed", 0) \
+ K(For, "for", 0) \
+ K(Function, "function", 0) \
+ K(If, "if", 0) \
+ K(Import, "import", 0) \
+ K(Mapping, "mapping", 0) \
+ K(Modifier, "modifier", 0) \
+ K(New, "new", 0) \
+ K(Public, "public", 0) \
+ K(Private, "private", 0) \
+ K(Protected, "protected", 0) \
+ K(Return, "return", 0) \
+ K(Returns, "returns", 0) \
+ K(Struct, "struct", 0) \
+ K(Switch, "switch", 0) \
+ K(Var, "var", 0) \
+ K(While, "while", 0) \
\
\
/* Ether subdenominations */ \
@@ -182,162 +177,162 @@ namespace solidity
/* type keywords, keep them in this order, keep int as first keyword
* the implementation in Types.cpp has to be synced to this here
* TODO more to be added */ \
- K(INT, "int", 0) \
- K(INT8, "int8", 0) \
- K(INT16, "int16", 0) \
- K(INT24, "int24", 0) \
- K(INT32, "int32", 0) \
- K(INT40, "int40", 0) \
+ K(Int, "int", 0) \
+ K(Int8, "int8", 0) \
+ K(Int16, "int16", 0) \
+ K(Int24, "int24", 0) \
+ K(Int32, "int32", 0) \
+ K(Int40, "int40", 0) \
K(INT48, "int48", 0) \
- K(INT56, "int56", 0) \
- K(INT64, "int64", 0) \
- K(INT72, "int72", 0) \
- K(INT80, "int80", 0) \
- K(INT88, "int88", 0) \
- K(INT96, "int96", 0) \
- K(INT104, "int104", 0) \
- K(INT112, "int112", 0) \
- K(INT120, "int120", 0) \
- K(INT128, "int128", 0) \
- K(INT136, "int136", 0) \
- K(INT144, "int144", 0) \
- K(INT152, "int152", 0) \
- K(INT160, "int160", 0) \
- K(INT168, "int168", 0) \
- K(INT176, "int178", 0) \
- K(INT184, "int184", 0) \
- K(INT192, "int192", 0) \
- K(INT200, "int200", 0) \
- K(INT208, "int208", 0) \
- K(INT216, "int216", 0) \
- K(INT224, "int224", 0) \
- K(INT232, "int232", 0) \
- K(INT240, "int240", 0) \
- K(INT248, "int248", 0) \
- K(INT256, "int256", 0) \
- K(UINT, "uint", 0) \
- K(UINT8, "uint8", 0) \
- K(UINT16, "uint16", 0) \
- K(UINT24, "uint24", 0) \
- K(UINT32, "uint32", 0) \
- K(UINT40, "uint40", 0) \
- K(UINT48, "uint48", 0) \
- K(UINT56, "uint56", 0) \
- K(UINT64, "uint64", 0) \
- K(UINT72, "uint72", 0) \
- K(UINT80, "uint80", 0) \
- K(UINT88, "uint88", 0) \
- K(UINT96, "uint96", 0) \
- K(UINT104, "uint104", 0) \
- K(UINT112, "uint112", 0) \
- K(UINT120, "uint120", 0) \
- K(UINT128, "uint128", 0) \
- K(UINT136, "uint136", 0) \
- K(UINT144, "uint144", 0) \
- K(UINT152, "uint152", 0) \
- K(UINT160, "uint160", 0) \
- K(UINT168, "uint168", 0) \
- K(UINT176, "uint178", 0) \
- K(UINT184, "uint184", 0) \
- K(UINT192, "uint192", 0) \
- K(UINT200, "uint200", 0) \
- K(UINT208, "uint208", 0) \
- K(UINT216, "uint216", 0) \
- K(UINT224, "uint224", 0) \
- K(UINT232, "uint232", 0) \
- K(UINT240, "uint240", 0) \
- K(UINT248, "uint248", 0) \
- K(UINT256, "uint256", 0) \
- K(HASH, "hash", 0) \
- K(HASH8, "hash8", 0) \
- K(HASH16, "hash16", 0) \
- K(HASH24, "hash24", 0) \
- K(HASH32, "hash32", 0) \
- K(HASH40, "hash40", 0) \
- K(HASH48, "hash48", 0) \
- K(HASH56, "hash56", 0) \
- K(HASH64, "hash64", 0) \
- K(HASH72, "hash72", 0) \
- K(HASH80, "hash80", 0) \
- K(HASH88, "hash88", 0) \
- K(HASH96, "hash96", 0) \
- K(HASH104, "hash104", 0) \
- K(HASH112, "hash112", 0) \
- K(HASH120, "hash120", 0) \
- K(HASH128, "hash128", 0) \
- K(HASH136, "hash136", 0) \
- K(HASH144, "hash144", 0) \
- K(HASH152, "hash152", 0) \
- K(HASH160, "hash160", 0) \
- K(HASH168, "hash168", 0) \
- K(HASH176, "hash178", 0) \
- K(HASH184, "hash184", 0) \
- K(HASH192, "hash192", 0) \
- K(HASH200, "hash200", 0) \
- K(HASH208, "hash208", 0) \
- K(HASH216, "hash216", 0) \
- K(HASH224, "hash224", 0) \
- K(HASH232, "hash232", 0) \
- K(HASH240, "hash240", 0) \
- K(HASH248, "hash248", 0) \
- K(HASH256, "hash256", 0) \
- K(ADDRESS, "address", 0) \
- K(BOOL, "bool", 0) \
- K(STRING_TYPE, "string", 0) \
- K(STRING0, "string0", 0) \
- K(STRING1, "string1", 0) \
- K(STRING2, "string2", 0) \
- K(STRING3, "string3", 0) \
- K(STRING4, "string4", 0) \
- K(STRING5, "string5", 0) \
- K(STRING6, "string6", 0) \
- K(STRING7, "string7", 0) \
- K(STRING8, "string8", 0) \
- K(STRING9, "string9", 0) \
- K(STRING10, "string10", 0) \
- K(STRING11, "string11", 0) \
- K(STRING12, "string12", 0) \
- K(STRING13, "string13", 0) \
- K(STRING14, "string14", 0) \
- K(STRING15, "string15", 0) \
- K(STRING16, "string16", 0) \
- K(STRING17, "string17", 0) \
- K(STRING18, "string18", 0) \
- K(STRING19, "string19", 0) \
- K(STRING20, "string20", 0) \
- K(STRING21, "string21", 0) \
- K(STRING22, "string22", 0) \
- K(STRING23, "string23", 0) \
- K(STRING24, "string24", 0) \
- K(STRING25, "string25", 0) \
- K(STRING26, "string26", 0) \
- K(STRING27, "string27", 0) \
- K(STRING28, "string28", 0) \
- K(STRING29, "string29", 0) \
- K(STRING30, "string30", 0) \
- K(STRING31, "string31", 0) \
- K(STRING32, "string32", 0) \
- K(TEXT, "text", 0) \
- K(REAL, "real", 0) \
- K(UREAL, "ureal", 0) \
- T(TYPES_END, NULL, 0) /* used as type enum end marker */ \
+ K(Int56, "int56", 0) \
+ K(Int64, "int64", 0) \
+ K(Int72, "int72", 0) \
+ K(Int80, "int80", 0) \
+ K(Int88, "int88", 0) \
+ K(Int96, "int96", 0) \
+ K(Int104, "int104", 0) \
+ K(Int112, "int112", 0) \
+ K(Int120, "int120", 0) \
+ K(Int128, "int128", 0) \
+ K(Int136, "int136", 0) \
+ K(Int144, "int144", 0) \
+ K(Int152, "int152", 0) \
+ K(Int160, "int160", 0) \
+ K(Int168, "int168", 0) \
+ K(Int176, "int178", 0) \
+ K(Int184, "int184", 0) \
+ K(Int192, "int192", 0) \
+ K(Int200, "int200", 0) \
+ K(Int208, "int208", 0) \
+ K(Int216, "int216", 0) \
+ K(Int224, "int224", 0) \
+ K(Int232, "int232", 0) \
+ K(Int240, "int240", 0) \
+ K(Int248, "int248", 0) \
+ K(Int256, "int256", 0) \
+ K(Uint, "uint", 0) \
+ K(Uint8, "uint8", 0) \
+ K(Uint16, "uint16", 0) \
+ K(Uint24, "uint24", 0) \
+ K(Uint32, "uint32", 0) \
+ K(Uint40, "uint40", 0) \
+ K(Uint48, "uint48", 0) \
+ K(Uint56, "uint56", 0) \
+ K(Uint64, "uint64", 0) \
+ K(Uint72, "uint72", 0) \
+ K(Uint80, "uint80", 0) \
+ K(Uint88, "uint88", 0) \
+ K(Uint96, "uint96", 0) \
+ K(Uint104, "uint104", 0) \
+ K(Uint112, "uint112", 0) \
+ K(Uint120, "uint120", 0) \
+ K(Uint128, "uint128", 0) \
+ K(Uint136, "uint136", 0) \
+ K(Uint144, "uint144", 0) \
+ K(Uint152, "uint152", 0) \
+ K(Uint160, "uint160", 0) \
+ K(Uint168, "uint168", 0) \
+ K(Uint176, "uint178", 0) \
+ K(Uint184, "uint184", 0) \
+ K(Uint192, "uint192", 0) \
+ K(Uint200, "uint200", 0) \
+ K(Uint208, "uint208", 0) \
+ K(Uint216, "uint216", 0) \
+ K(Uint224, "uint224", 0) \
+ K(Uint232, "uint232", 0) \
+ K(Uint240, "uint240", 0) \
+ K(Uint248, "uint248", 0) \
+ K(Uint256, "uint256", 0) \
+ K(Hash, "hash", 0) \
+ K(Hash8, "hash8", 0) \
+ K(Hash16, "hash16", 0) \
+ K(Hash24, "hash24", 0) \
+ K(Hash32, "hash32", 0) \
+ K(Hash40, "hash40", 0) \
+ K(Hash48, "hash48", 0) \
+ K(Hash56, "hash56", 0) \
+ K(Hash64, "hash64", 0) \
+ K(Hash72, "hash72", 0) \
+ K(Hash80, "hash80", 0) \
+ K(Hash88, "hash88", 0) \
+ K(Hash96, "hash96", 0) \
+ K(Hash104, "hash104", 0) \
+ K(Hash112, "hash112", 0) \
+ K(Hash120, "hash120", 0) \
+ K(Hash128, "hash128", 0) \
+ K(Hash136, "hash136", 0) \
+ K(Hash144, "hash144", 0) \
+ K(Hash152, "hash152", 0) \
+ K(Hash160, "hash160", 0) \
+ K(Hash168, "hash168", 0) \
+ K(Hash176, "hash178", 0) \
+ K(Hash184, "hash184", 0) \
+ K(Hash192, "hash192", 0) \
+ K(Hash200, "hash200", 0) \
+ K(Hash208, "hash208", 0) \
+ K(Hash216, "hash216", 0) \
+ K(Hash224, "hash224", 0) \
+ K(Hash232, "hash232", 0) \
+ K(Hash240, "hash240", 0) \
+ K(Hash248, "hash248", 0) \
+ K(Hash256, "hash256", 0) \
+ K(Address, "address", 0) \
+ K(Bool, "bool", 0) \
+ K(StringType, "string", 0) \
+ K(String0, "string0", 0) \
+ K(String1, "string1", 0) \
+ K(String2, "string2", 0) \
+ K(String3, "string3", 0) \
+ K(String4, "string4", 0) \
+ K(String5, "string5", 0) \
+ K(String6, "string6", 0) \
+ K(String7, "string7", 0) \
+ K(String8, "string8", 0) \
+ K(String9, "string9", 0) \
+ K(String10, "string10", 0) \
+ K(String11, "string11", 0) \
+ K(String12, "string12", 0) \
+ K(String13, "string13", 0) \
+ K(String14, "string14", 0) \
+ K(String15, "string15", 0) \
+ K(String16, "string16", 0) \
+ K(String17, "string17", 0) \
+ K(String18, "string18", 0) \
+ K(String19, "string19", 0) \
+ K(String20, "string20", 0) \
+ K(String21, "string21", 0) \
+ K(String22, "string22", 0) \
+ K(String23, "string23", 0) \
+ K(String24, "string24", 0) \
+ K(String25, "string25", 0) \
+ K(String26, "string26", 0) \
+ K(String27, "string27", 0) \
+ K(String28, "string28", 0) \
+ K(String29, "string29", 0) \
+ K(String30, "string30", 0) \
+ K(String31, "string31", 0) \
+ K(String32, "string32", 0) \
+ K(Text, "text", 0) \
+ K(Real, "real", 0) \
+ K(UReal, "ureal", 0) \
+ T(TypesEnd, NULL, 0) /* used as type enum end marker */ \
\
/* Literals */ \
- K(NULL_LITERAL, "null", 0) \
- K(TRUE_LITERAL, "true", 0) \
- K(FALSE_LITERAL, "false", 0) \
- T(NUMBER, NULL, 0) \
- T(STRING_LITERAL, NULL, 0) \
- T(COMMENT_LITERAL, NULL, 0) \
+ K(NullLiteral, "null", 0) \
+ K(TrueLiteral, "true", 0) \
+ K(FalseLiteral, "false", 0) \
+ T(Number, NULL, 0) \
+ T(StringLiteral, NULL, 0) \
+ T(CommentLiteral, NULL, 0) \
\
/* Identifiers (not keywords or future reserved words). */ \
- T(IDENTIFIER, NULL, 0) \
+ T(Identifier, NULL, 0) \
\
/* Illegal token - not able to scan. */ \
- T(ILLEGAL, "ILLEGAL", 0) \
+ T(Illegal, "ILLEGAL", 0) \
\
/* Scanner-internal use only. */ \
- T(WHITESPACE, NULL, 0)
+ T(Whitespace, NULL, 0)
class Token
@@ -364,25 +359,25 @@ public:
}
// Predicates
- static bool isElementaryTypeName(Value tok) { return INT <= tok && tok < TYPES_END; }
- static bool isAssignmentOp(Value tok) { return ASSIGN <= tok && tok <= ASSIGN_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 ||
- op == ADD || op == MUL || op == EQ || op == NE; }
- static bool isArithmeticOp(Value op) { return ADD <= op && op <= MOD; }
- static bool isCompareOp(Value op) { return EQ <= op && op <= IN; }
+ static bool isElementaryTypeName(Value tok) { return Int <= tok && tok < TypesEnd; }
+ static bool isAssignmentOp(Value tok) { return Assign <= tok && tok <= AssignMod; }
+ static bool isBinaryOp(Value op) { return Comma <= op && op <= Mod; }
+ static bool isCommutativeOp(Value op) { return op == BitOr || op == BitXor || op == BitAnd ||
+ op == Add || op == Mul || op == Equals || op == NotEquals; }
+ static bool isArithmeticOp(Value op) { return Add <= op && op <= Mod; }
+ static bool isCompareOp(Value op) { return Equals <= op && op <= In; }
static Value AssignmentToBinaryOp(Value op)
{
- solAssert(isAssignmentOp(op) && op != ASSIGN, "");
- return Token::Value(op + (BIT_OR - ASSIGN_BIT_OR));
+ solAssert(isAssignmentOp(op) && op != Assign, "");
+ return Token::Value(op + (BitOr - AssignBitOr));
}
- static bool isBitOp(Value op) { return (BIT_OR <= op && op <= SHR) || op == BIT_NOT; }
- 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 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 isCountOp(Value op) { return op == Inc || op == Dec; }
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; }
// Returns a string corresponding to the JS token string
diff --git a/Types.cpp b/Types.cpp
index 7a7672c6..1046e65e 100644
--- a/Types.cpp
+++ b/Types.cpp
@@ -37,9 +37,9 @@ shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
{
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;
if (bytes == 0)
bytes = 32;
@@ -47,14 +47,14 @@ shared_ptr<Type const> Type::fromElementaryTypeName(Token::Value _typeToken)
return make_shared<IntegerType>(bytes * 8,
modifier == 0 ? IntegerType::Modifier::SIGNED :
modifier == 1 ? IntegerType::Modifier::UNSIGNED :
- IntegerType::Modifier::HASH);
+ IntegerType::Modifier::Hash);
}
- else if (_typeToken == Token::ADDRESS)
- return make_shared<IntegerType>(0, IntegerType::Modifier::ADDRESS);
- else if (_typeToken == Token::BOOL)
+ else if (_typeToken == Token::Address)
+ return make_shared<IntegerType>(0, IntegerType::Modifier::Address);
+ else if (_typeToken == Token::Bool)
return make_shared<BoolType>();
- else if (Token::STRING0 <= _typeToken && _typeToken <= Token::STRING32)
- return make_shared<StaticStringType>(int(_typeToken) - int(Token::STRING0));
+ else if (Token::String0 <= _typeToken && _typeToken <= Token::String32)
+ return make_shared<StaticStringType>(int(_typeToken) - int(Token::String0));
else
BOOST_THROW_EXCEPTION(InternalCompilerError() << errinfo_comment("Unable to convert elementary typename " +
std::string(Token::toString(_typeToken)) + " to type."));
@@ -87,12 +87,12 @@ shared_ptr<Type const> Type::forLiteral(Literal const& _literal)
{
switch (_literal.getToken())
{
- case Token::TRUE_LITERAL:
- case Token::FALSE_LITERAL:
+ case Token::TrueLiteral:
+ case Token::FalseLiteral:
return make_shared<BoolType>();
- case Token::NUMBER:
+ case Token::Number:
return make_shared<IntegerConstantType>(_literal);
- case Token::STRING_LITERAL:
+ case Token::StringLiteral:
//@todo put larger strings into dynamic strings
return StaticStringType::smallestTypeForLiteral(_literal.getValue());
default:
@@ -140,31 +140,31 @@ bool IntegerType::isImplicitlyConvertibleTo(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);
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
{
// "delete" is ok for all integer types
- if (_operator == Token::DELETE)
+ if (_operator == Token::Delete)
return make_shared<VoidType>();
// no further unary operators for addresses
else if (isAddress())
return TypePointer();
// "~" is ok for all other types
- else if (_operator == Token::BIT_NOT)
+ else if (_operator == Token::BitNot)
return shared_from_this();
// nothing else for hashes
else if (isHash())
return TypePointer();
// for non-hash integers, we allow +, -, ++ and --
- else if (_operator == Token::ADD || _operator == Token::SUB ||
- _operator == Token::INC || _operator == Token::DEC)
+ else if (_operator == Token::Add || _operator == Token::Sub ||
+ _operator == Token::Inc || _operator == Token::Dec)
return shared_from_this();
else
return TypePointer();
@@ -188,7 +188,7 @@ string IntegerType::toString() 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();
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;
switch (_operator)
{
- case Token::BIT_NOT:
+ case Token::BitNot:
value = ~m_value;
break;
- case Token::ADD:
+ case Token::Add:
value = m_value;
break;
- case Token::SUB:
+ case Token::Sub:
value = -m_value;
break;
default:
@@ -271,7 +271,7 @@ TypePointer IntegerConstantType::unaryOperatorResult(Token::Value _operator) con
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();
if (!integerType)
@@ -295,30 +295,30 @@ TypePointer IntegerConstantType::binaryOperatorResult(Token::Value _operator, Ty
bigint value;
switch (_operator)
{
- case Token::BIT_OR:
+ case Token::BitOr:
value = m_value | other.m_value;
break;
- case Token::BIT_XOR:
+ case Token::BitXor:
value = m_value ^ other.m_value;
break;
- case Token::BIT_AND:
+ case Token::BitAnd:
value = m_value & other.m_value;
break;
- case Token::ADD:
+ case Token::Add:
value = m_value + other.m_value;
break;
- case Token::SUB:
+ case Token::Sub:
value = m_value - other.m_value;
break;
- case Token::MUL:
+ case Token::Mul:
value = m_value * other.m_value;
break;
- case Token::DIV:
+ case Token::Div:
if (other.m_value == 0)
return TypePointer();
value = m_value / other.m_value;
break;
- case Token::MOD:
+ case Token::Mod:
if (other.m_value == 0)
return TypePointer();
value = m_value % other.m_value;
@@ -401,7 +401,7 @@ bool StaticStringType::isImplicitlyConvertibleTo(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);
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
{
solAssert(_literal, "");
- if (_literal->getToken() == Token::TRUE_LITERAL)
+ if (_literal->getToken() == Token::TrueLiteral)
return u256(1);
- else if (_literal->getToken() == Token::FALSE_LITERAL)
+ else if (_literal->getToken() == Token::FalseLiteral)
return u256(0);
else
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
{
- if (_operator == Token::DELETE)
+ if (_operator == Token::Delete)
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
{
if (getCategory() != _other->getCategory())
return TypePointer();
- if (Token::isCompareOp(_operator) || _operator == Token::AND || _operator == Token::OR)
+ if (Token::isCompareOp(_operator) || _operator == Token::And || _operator == Token::Or)
return _other;
else
return TypePointer();
@@ -472,9 +472,9 @@ bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
{
if (*this == _convertTo)
return true;
- if (_convertTo.getCategory() == Category::INTEGER)
+ if (_convertTo.getCategory() == Category::Integer)
return dynamic_cast<IntegerType const&>(_convertTo).isAddress();
- if (_convertTo.getCategory() == Category::CONTRACT)
+ if (_convertTo.getCategory() == Category::Contract)
{
auto const& bases = getContractDefinition().getLinearizedBaseContracts();
if (m_super && bases.size() <= 1)
@@ -487,13 +487,13 @@ bool ContractType::isImplicitlyConvertibleTo(Type const& _convertTo) const
bool ContractType::isExplicitlyConvertibleTo(Type const& _convertTo) const
{
- return isImplicitlyConvertibleTo(_convertTo) || _convertTo.getCategory() == Category::INTEGER ||
- _convertTo.getCategory() == Category::CONTRACT;
+ return isImplicitlyConvertibleTo(_convertTo) || _convertTo.getCategory() == Category::Integer ||
+ _convertTo.getCategory() == Category::Contract;
}
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
@@ -557,7 +557,7 @@ u256 ContractType::getFunctionIdentifier(string const& _functionName) 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
@@ -865,7 +865,7 @@ MemberList const& TypeType::getMembers() const
if (!m_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();
vector<ContractDefinition const*> currentBases = m_currentContract->getLinearizedBaseContracts();
@@ -920,7 +920,7 @@ MagicType::MagicType(MagicType::Kind _kind):
switch (m_kind)
{
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)},
{"blockhash", make_shared<FunctionType>(strings{"uint"}, strings{"hash"}, FunctionType::Location::BLOCKHASH)},
{"difficulty", make_shared<IntegerType>(256)},
@@ -928,12 +928,12 @@ MagicType::MagicType(MagicType::Kind _kind):
{"gaslimit", make_shared<IntegerType>(256)}});
break;
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)},
{"value", make_shared<IntegerType>(256)}});
break;
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)}});
break;
default:
diff --git a/Types.h b/Types.h
index 7118f746..57d0c3ae 100644
--- a/Types.h
+++ b/Types.h
@@ -76,7 +76,9 @@ class Type: private boost::noncopyable, public std::enable_shared_from_this<Type
public:
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:
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);
@@ -180,8 +182,8 @@ public:
virtual TypePointer getRealType() const { return std::make_shared<IntegerType>(m_bits, m_modifier); }
int getNumBits() const { return m_bits; }
- bool isHash() const { return m_modifier == Modifier::HASH || m_modifier == Modifier::ADDRESS; }
- bool isAddress() const { return 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 isSigned() const { return m_modifier == Modifier::SIGNED; }
static const MemberList AddressMemberList;
@@ -198,7 +200,7 @@ private:
class IntegerConstantType: public Type
{
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(bigint _value): m_value(_value) {}
@@ -231,7 +233,7 @@ private:
class StaticStringType: public Type
{
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
/// if no type fits.
@@ -263,7 +265,7 @@ class BoolType: public Type
{
public:
BoolType() {}
- virtual Category getCategory() const { return Category::BOOL; }
+ virtual Category getCategory() const { return Category::Bool; }
virtual bool isExplicitlyConvertibleTo(Type const& _convertTo) const override;
virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
virtual TypePointer binaryOperatorResult(Token::Value _operator, TypePointer const& _other) const override;
@@ -281,7 +283,7 @@ public:
class ContractType: public Type
{
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):
m_contract(_contract), m_super(_super) {}
/// Contracts can be implicitly converted to super classes and to addresses.
@@ -323,7 +325,7 @@ private:
class StructType: public Type
{
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) {}
virtual TypePointer unaryOperatorResult(Token::Value _operator) const override;
virtual bool operator==(Type const& _other) const override;
@@ -362,7 +364,7 @@ public:
SET_GAS, SET_VALUE, BLOCKHASH,
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(VariableDeclaration const& _varDecl);
explicit FunctionType(EventDefinition const& _event);
@@ -435,7 +437,7 @@ private:
class MappingType: public Type
{
public:
- virtual Category getCategory() const override { return Category::MAPPING; }
+ virtual Category getCategory() const override { return Category::Mapping; }
MappingType(TypePointer const& _keyType, TypePointer const& _valueType):
m_keyType(_keyType), m_valueType(_valueType) {}
@@ -458,7 +460,7 @@ private:
class VoidType: public Type
{
public:
- virtual Category getCategory() const override { return Category::VOID; }
+ virtual Category getCategory() const override { return Category::Void; }
VoidType() {}
virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
@@ -476,7 +478,7 @@ public:
class TypeType: public Type
{
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):
m_actualType(_actualType), m_currentContract(_currentContract) {}
TypePointer const& getActualType() const { return m_actualType; }
@@ -505,7 +507,7 @@ private:
class ModifierType: public Type
{
public:
- virtual Category getCategory() const override { return Category::MODIFIER; }
+ virtual Category getCategory() const override { return Category::Modifier; }
explicit ModifierType(ModifierDefinition const& _modifier);
virtual TypePointer binaryOperatorResult(Token::Value, TypePointer const&) const override { return TypePointer(); }
@@ -529,7 +531,7 @@ class MagicType: public Type
{
public:
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);
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-10 12:41:25 +0800