solidity/libsolidity/inlineasm/AsmParser.cpp

404 lines
11 KiB
C++
Raw Normal View History

2016-02-22 01:13:41 +00:00
/*
This file is part of solidity.
2016-02-22 01:13:41 +00:00
solidity is free software: you can redistribute it and/or modify
2016-02-22 01:13:41 +00:00
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
solidity is distributed in the hope that it will be useful,
2016-02-22 01:13:41 +00:00
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with solidity. If not, see <http://www.gnu.org/licenses/>.
2016-02-22 01:13:41 +00:00
*/
/**
* @author Christian <c@ethdev.com>
* @date 2016
* Solidity inline assembly parser.
*/
#include <libsolidity/inlineasm/AsmParser.h>
#include <ctype.h>
#include <algorithm>
#include <libsolidity/parsing/Scanner.h>
#include <libsolidity/interface/Exceptions.h>
2016-02-22 01:13:41 +00:00
using namespace std;
using namespace dev;
using namespace dev::solidity;
using namespace dev::solidity::assembly;
2016-02-22 01:13:41 +00:00
shared_ptr<assembly::Block> Parser::parse(std::shared_ptr<Scanner> const& _scanner)
2016-02-22 01:13:41 +00:00
{
try
{
m_scanner = _scanner;
2016-04-18 11:47:40 +00:00
return make_shared<Block>(parseBlock());
2016-02-22 01:13:41 +00:00
}
catch (FatalError const&)
{
if (m_errors.empty())
throw; // Something is weird here, rather throw again.
}
return nullptr;
}
assembly::Block Parser::parseBlock()
2016-02-22 01:13:41 +00:00
{
2016-04-18 11:47:40 +00:00
assembly::Block block = createWithLocation<Block>();
2016-02-22 01:13:41 +00:00
expectToken(Token::LBrace);
while (m_scanner->currentToken() != Token::RBrace)
block.statements.emplace_back(parseStatement());
2016-04-18 11:47:40 +00:00
block.location.end = endPosition();
2016-02-22 01:13:41 +00:00
m_scanner->next();
return block;
}
assembly::Statement Parser::parseStatement()
2016-02-22 01:13:41 +00:00
{
switch (m_scanner->currentToken())
{
case Token::Let:
return parseVariableDeclaration();
2017-01-31 22:59:41 +00:00
case Token::Function:
return parseFunctionDefinition();
2016-02-22 01:13:41 +00:00
case Token::LBrace:
return parseBlock();
case Token::Assign:
{
if (m_julia)
break;
2016-04-18 11:47:40 +00:00
assembly::Assignment assignment = createWithLocation<assembly::Assignment>();
2016-02-22 01:13:41 +00:00
m_scanner->next();
expectToken(Token::Colon);
2016-04-18 11:47:40 +00:00
assignment.variableName.location = location();
assignment.variableName.name = m_scanner->currentLiteral();
if (!m_julia && instructions().count(assignment.variableName.name))
2017-01-26 12:52:02 +00:00
fatalParserError("Identifier expected, got instruction name.");
2016-04-18 11:47:40 +00:00
assignment.location.end = endPosition();
2016-02-22 01:13:41 +00:00
expectToken(Token::Identifier);
2016-04-18 11:47:40 +00:00
return assignment;
2016-02-22 01:13:41 +00:00
}
case Token::Return: // opcode
2016-04-05 12:57:40 +00:00
case Token::Byte: // opcode
2017-05-01 16:40:37 +00:00
case Token::Address: // opcode
2016-02-22 01:13:41 +00:00
default:
break;
}
// Options left:
// Simple instruction (might turn into functional),
// literal,
// identifier (might turn into label or functional assignment)
Statement statement(parseElementaryOperation(false));
2016-02-22 01:13:41 +00:00
switch (m_scanner->currentToken())
{
case Token::LParen:
2016-04-18 11:47:40 +00:00
return parseFunctionalInstruction(std::move(statement));
2016-02-22 01:13:41 +00:00
case Token::Colon:
{
if (statement.type() != typeid(assembly::Identifier))
2016-02-22 01:13:41 +00:00
fatalParserError("Label name / variable name must precede \":\".");
2016-04-18 11:47:40 +00:00
assembly::Identifier const& identifier = boost::get<assembly::Identifier>(statement);
2016-02-22 01:13:41 +00:00
m_scanner->next();
// identifier:=: should be parsed as identifier: =: (i.e. a label),
// while identifier:= (being followed by a non-colon) as identifier := (assignment).
if (m_scanner->currentToken() == Token::Assign && m_scanner->peekNextToken() != Token::Colon)
2016-02-22 01:13:41 +00:00
{
// functional assignment
2016-04-18 11:47:40 +00:00
FunctionalAssignment funAss = createWithLocation<FunctionalAssignment>(identifier.location);
if (!m_julia && instructions().count(identifier.name))
2017-01-25 16:29:06 +00:00
fatalParserError("Cannot use instruction names for identifier names.");
2016-02-22 01:13:41 +00:00
m_scanner->next();
2016-04-18 11:47:40 +00:00
funAss.variableName = identifier;
funAss.value.reset(new Statement(parseExpression()));
funAss.location.end = locationOf(*funAss.value).end;
return funAss;
2016-02-22 01:13:41 +00:00
}
else
2016-04-18 11:47:40 +00:00
{
2016-02-22 01:13:41 +00:00
// label
2017-05-01 16:40:37 +00:00
if (m_julia)
fatalParserError("Labels are not supported.");
2016-04-18 11:47:40 +00:00
Label label = createWithLocation<Label>(identifier.location);
label.name = identifier.name;
return label;
}
2016-02-22 01:13:41 +00:00
}
default:
2017-05-02 08:24:35 +00:00
if (m_julia)
fatalParserError("Call or assignment expected.");
2016-02-22 01:13:41 +00:00
break;
}
return statement;
}
assembly::Statement Parser::parseExpression()
2016-02-22 01:13:41 +00:00
{
Statement operation = parseElementaryOperation(true);
2016-02-22 01:13:41 +00:00
if (m_scanner->currentToken() == Token::LParen)
2016-04-18 11:47:40 +00:00
return parseFunctionalInstruction(std::move(operation));
2016-02-22 01:13:41 +00:00
else
return operation;
}
2017-01-25 16:24:50 +00:00
std::map<string, dev::solidity::Instruction> const& Parser::instructions()
2016-02-22 01:13:41 +00:00
{
// Allowed instructions, lowercase names.
static map<string, dev::solidity::Instruction> s_instructions;
2016-02-22 01:13:41 +00:00
if (s_instructions.empty())
{
for (auto const& instruction: solidity::c_instructions)
2016-02-22 01:13:41 +00:00
{
if (
instruction.second == solidity::Instruction::JUMPDEST ||
(solidity::Instruction::PUSH1 <= instruction.second && instruction.second <= solidity::Instruction::PUSH32)
2016-02-22 01:13:41 +00:00
)
continue;
string name = instruction.first;
transform(name.begin(), name.end(), name.begin(), [](unsigned char _c) { return tolower(_c); });
s_instructions[name] = instruction.second;
}
// add alias for suicide
s_instructions["suicide"] = solidity::Instruction::SELFDESTRUCT;
}
return s_instructions;
}
assembly::Statement Parser::parseElementaryOperation(bool _onlySinglePusher)
{
2016-04-18 11:47:40 +00:00
Statement ret;
2016-02-22 01:13:41 +00:00
switch (m_scanner->currentToken())
{
case Token::Identifier:
case Token::Return:
2016-04-05 12:57:40 +00:00
case Token::Byte:
2016-10-05 10:47:56 +00:00
case Token::Address:
2016-02-22 01:13:41 +00:00
{
string literal;
if (m_scanner->currentToken() == Token::Return)
literal = "return";
2016-04-05 12:57:40 +00:00
else if (m_scanner->currentToken() == Token::Byte)
literal = "byte";
2016-10-05 10:47:56 +00:00
else if (m_scanner->currentToken() == Token::Address)
literal = "address";
else
literal = m_scanner->currentLiteral();
2016-02-22 01:13:41 +00:00
// first search the set of instructions.
if (!m_julia && instructions().count(literal))
2016-02-22 01:13:41 +00:00
{
2017-01-25 16:29:06 +00:00
dev::solidity::Instruction const& instr = instructions().at(literal);
2016-02-22 01:13:41 +00:00
if (_onlySinglePusher)
{
2016-04-04 11:27:09 +00:00
InstructionInfo info = dev::solidity::instructionInfo(instr);
2016-02-22 01:13:41 +00:00
if (info.ret != 1)
fatalParserError("Instruction " + info.name + " not allowed in this context.");
}
2016-04-18 11:47:40 +00:00
ret = Instruction{location(), instr};
2016-02-22 01:13:41 +00:00
}
else
2016-04-18 11:47:40 +00:00
ret = Identifier{location(), literal};
2017-04-26 22:58:34 +00:00
m_scanner->next();
2016-02-22 01:13:41 +00:00
break;
}
case Token::StringLiteral:
case Token::Number:
case Token::TrueLiteral:
case Token::FalseLiteral:
2016-02-22 01:13:41 +00:00
{
LiteralKind kind = LiteralKind::Number;
switch (m_scanner->currentToken())
{
case Token::StringLiteral:
kind = LiteralKind::String;
break;
case Token::Number:
kind = LiteralKind::Number;
break;
case Token::TrueLiteral:
case Token::FalseLiteral:
kind = LiteralKind::Boolean;
break;
default:
break;
}
2017-04-26 22:58:34 +00:00
Literal literal{
2016-04-18 11:47:40 +00:00
location(),
kind,
2017-04-26 22:58:34 +00:00
m_scanner->currentLiteral(),
""
2016-02-22 01:13:41 +00:00
};
2017-04-26 22:58:34 +00:00
m_scanner->next();
if (m_julia)
{
expectToken(Token::Colon);
literal.location.end = endPosition();
literal.type = expectAsmIdentifier();
}
else if (kind == LiteralKind::Boolean)
fatalParserError("True and false are not valid literals.");
2017-04-26 22:58:34 +00:00
ret = std::move(literal);
2016-04-18 11:47:40 +00:00
break;
2016-02-22 01:13:41 +00:00
}
default:
fatalParserError(
m_julia ?
"Literal or identifier expected." :
"Expected elementary inline assembly operation."
);
2016-02-22 01:13:41 +00:00
}
2016-04-18 11:47:40 +00:00
return ret;
2016-02-22 01:13:41 +00:00
}
assembly::VariableDeclaration Parser::parseVariableDeclaration()
2016-02-22 01:13:41 +00:00
{
2016-04-18 11:47:40 +00:00
VariableDeclaration varDecl = createWithLocation<VariableDeclaration>();
2016-02-22 01:13:41 +00:00
expectToken(Token::Let);
while (true)
{
varDecl.variables.push_back(parseTypedName());
if (m_scanner->currentToken() == Token::Comma)
expectToken(Token::Comma);
else
break;
}
2016-02-22 01:13:41 +00:00
expectToken(Token::Colon);
expectToken(Token::Assign);
2017-05-05 17:56:29 +00:00
varDecl.value.reset(new Statement(parseExpression()));
varDecl.location.end = locationOf(*varDecl.value).end;
2016-04-18 11:47:40 +00:00
return varDecl;
2016-02-22 01:13:41 +00:00
}
2017-01-31 22:59:41 +00:00
assembly::FunctionDefinition Parser::parseFunctionDefinition()
{
FunctionDefinition funDef = createWithLocation<FunctionDefinition>();
expectToken(Token::Function);
funDef.name = expectAsmIdentifier();
expectToken(Token::LParen);
while (m_scanner->currentToken() != Token::RParen)
{
2017-04-26 22:58:34 +00:00
funDef.arguments.emplace_back(parseTypedName());
2017-01-31 22:59:41 +00:00
if (m_scanner->currentToken() == Token::RParen)
break;
expectToken(Token::Comma);
}
expectToken(Token::RParen);
if (m_scanner->currentToken() == Token::Sub)
{
expectToken(Token::Sub);
expectToken(Token::GreaterThan);
while (true)
{
2017-04-26 22:58:34 +00:00
funDef.returns.emplace_back(parseTypedName());
if (m_scanner->currentToken() == Token::LBrace)
2017-01-31 22:59:41 +00:00
break;
expectToken(Token::Comma);
}
}
funDef.body = parseBlock();
funDef.location.end = funDef.body.location.end;
return funDef;
}
2017-02-01 20:20:21 +00:00
assembly::Statement Parser::parseFunctionalInstruction(assembly::Statement&& _instruction)
2016-02-22 01:13:41 +00:00
{
2017-02-01 20:20:21 +00:00
if (_instruction.type() == typeid(Instruction))
2016-02-22 01:13:41 +00:00
{
solAssert(!m_julia, "Instructions are invalid in JULIA");
2017-02-01 20:20:21 +00:00
FunctionalInstruction ret;
ret.instruction = std::move(boost::get<Instruction>(_instruction));
ret.location = ret.instruction.location;
solidity::Instruction instr = ret.instruction.instruction;
InstructionInfo instrInfo = instructionInfo(instr);
if (solidity::Instruction::DUP1 <= instr && instr <= solidity::Instruction::DUP16)
fatalParserError("DUPi instructions not allowed for functional notation");
if (solidity::Instruction::SWAP1 <= instr && instr <= solidity::Instruction::SWAP16)
fatalParserError("SWAPi instructions not allowed for functional notation");
expectToken(Token::LParen);
unsigned args = unsigned(instrInfo.args);
for (unsigned i = 0; i < args; ++i)
2016-04-18 11:47:40 +00:00
{
2017-02-01 20:20:21 +00:00
ret.arguments.emplace_back(parseExpression());
if (i != args - 1)
{
if (m_scanner->currentToken() != Token::Comma)
fatalParserError(string(
"Expected comma (" +
instrInfo.name +
" expects " +
boost::lexical_cast<string>(args) +
" arguments)"
));
else
m_scanner->next();
}
2016-04-18 11:47:40 +00:00
}
2017-02-01 20:20:21 +00:00
ret.location.end = endPosition();
if (m_scanner->currentToken() == Token::Comma)
fatalParserError(
string("Expected ')' (" + instrInfo.name + " expects " + boost::lexical_cast<string>(args) + " arguments)")
);
expectToken(Token::RParen);
return ret;
2016-02-22 01:13:41 +00:00
}
2017-02-01 20:20:21 +00:00
else if (_instruction.type() == typeid(Identifier))
{
FunctionCall ret;
ret.functionName = std::move(boost::get<Identifier>(_instruction));
ret.location = ret.functionName.location;
expectToken(Token::LParen);
while (m_scanner->currentToken() != Token::RParen)
{
ret.arguments.emplace_back(parseExpression());
if (m_scanner->currentToken() == Token::RParen)
break;
expectToken(Token::Comma);
}
ret.location.end = endPosition();
expectToken(Token::RParen);
return ret;
}
else
fatalParserError(
m_julia ?
"Function name expected." :
"Assembly instruction or function name required in front of \"(\")"
);
2017-02-01 20:20:21 +00:00
return {};
2016-02-22 01:13:41 +00:00
}
2017-01-31 22:59:41 +00:00
2017-04-26 22:58:34 +00:00
TypedName Parser::parseTypedName()
{
TypedName typedName = createWithLocation<TypedName>();
typedName.name = expectAsmIdentifier();
if (m_julia)
{
expectToken(Token::Colon);
typedName.location.end = endPosition();
typedName.type = expectAsmIdentifier();
}
return typedName;
}
2017-01-31 22:59:41 +00:00
string Parser::expectAsmIdentifier()
{
string name = m_scanner->currentLiteral();
2017-05-17 12:33:05 +00:00
if (m_julia)
{
if (m_scanner->currentToken() == Token::Bool)
{
m_scanner->next();
return name;
}
}
else if (instructions().count(name))
2017-01-31 22:59:41 +00:00
fatalParserError("Cannot use instruction names for identifier names.");
expectToken(Token::Identifier);
return name;
}