From 3c412ed2f63a58b27eeb00fe584b9378311b099f Mon Sep 17 00:00:00 2001 From: chriseth Date: Fri, 19 Aug 2016 19:57:21 +0200 Subject: Version pragma. --- libsolidity/analysis/SemVerHandler.cpp | 290 +++++++++++++++++++++++++++++++++ libsolidity/analysis/SemVerHandler.h | 102 ++++++++++++ libsolidity/analysis/SyntaxChecker.cpp | 53 +++++- libsolidity/analysis/SyntaxChecker.h | 7 + libsolidity/ast/AST.h | 28 ++++ libsolidity/ast/ASTForward.h | 1 + libsolidity/ast/ASTJsonConverter.cpp | 13 ++ libsolidity/ast/ASTJsonConverter.h | 2 + libsolidity/ast/ASTPrinter.cpp | 12 ++ libsolidity/ast/ASTPrinter.h | 2 + libsolidity/ast/ASTVisitor.h | 4 + libsolidity/ast/AST_accept.h | 12 ++ libsolidity/grammar.txt | 11 +- libsolidity/parsing/Parser.cpp | 33 ++++ libsolidity/parsing/Parser.h | 1 + libsolidity/parsing/Token.h | 1 + 16 files changed, 565 insertions(+), 7 deletions(-) create mode 100644 libsolidity/analysis/SemVerHandler.cpp create mode 100644 libsolidity/analysis/SemVerHandler.h (limited to 'libsolidity') diff --git a/libsolidity/analysis/SemVerHandler.cpp b/libsolidity/analysis/SemVerHandler.cpp new file mode 100644 index 00000000..c7b212b2 --- /dev/null +++ b/libsolidity/analysis/SemVerHandler.cpp @@ -0,0 +1,290 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . +*/ +/** + * @author Christian + * @date 2016 + * Utilities to handle semantic versioning. + */ + +#include +#include + +using namespace std; +using namespace dev; +using namespace dev::solidity; + +SemVerVersion::SemVerVersion(string const& _versionString) +{ + auto i = _versionString.begin(); + auto end = _versionString.end(); + + for (unsigned level = 0; level < 3; ++level) + { + unsigned v = 0; + for (; i != end && '0' <= *i && *i <= '9'; ++i) + v = v * 10 + (*i - '0'); + numbers[level] = v; + if (level < 2) + { + if (i == end || *i != '.') + throw SemVerError(); + else + ++i; + } + } + if (i != end && *i == '-') + { + auto prereleaseStart = ++i; + while (i != end && *i != '+') ++i; + prerelease = string(prereleaseStart, i); + } + if (i != end && *i == '+') + { + auto buildStart = ++i; + while (i != end) ++i; + build = string(buildStart, i); + } + if (i != end) + throw SemVerError(); +} + +bool SemVerMatchExpression::MatchComponent::matches(SemVerVersion const& _version) const +{ + if (prefix == Token::BitNot) + { + MatchComponent comp = *this; + + comp.prefix = Token::GreaterThanOrEqual; + if (!comp.matches(_version)) + return false; + + if (levelsPresent >= 2) + comp.levelsPresent = 2; + else + comp.levelsPresent = 1; + comp.prefix = Token::LessThanOrEqual; + return comp.matches(_version); + } + else if (prefix == Token::BitXor) + { + MatchComponent comp = *this; + + comp.prefix = Token::GreaterThanOrEqual; + if (!comp.matches(_version)) + return false; + + if (comp.version.numbers[0] == 0) + comp.levelsPresent = 2; + else + comp.levelsPresent = 1; + comp.prefix = Token::LessThanOrEqual; + return comp.matches(_version); + } + else + { + int cmp = 0; + bool didCompare = false; + for (unsigned i = 0; i < levelsPresent && cmp == 0; i++) + if (version.numbers[i] != unsigned(-1)) + { + didCompare = true; + cmp = _version.numbers[i] - version.numbers[i]; + } + if (cmp == 0 && !_version.prerelease.empty() && didCompare) + cmp = -1; + if (prefix == Token::Assign) + return cmp == 0; + else if (prefix == Token::LessThan) + return cmp < 0; + else if (prefix == Token::LessThanOrEqual) + return cmp <= 0; + else if (prefix == Token::GreaterThan) + return cmp > 0; + else if (prefix == Token::GreaterThanOrEqual) + return cmp >= 0; + else + solAssert(false, "Invalid SemVer expression"); + return false; + } +} + +bool SemVerMatchExpression::Conjunction::matches(SemVerVersion const& _version) const +{ + for (auto const& component: components) + if (!component.matches(_version)) + return false; + return true; +} + +bool SemVerMatchExpression::matches(SemVerVersion const& _version) const +{ + if (!isValid()) + return false; + for (auto const& range: m_disjunction) + if (range.matches(_version)) + return true; + return false; +} + +SemVerMatchExpression SemVerMatchExpressionParser::parse() +{ + reset(); + + try + { + while (true) + { + parseMatchExpression(); + if (m_pos >= m_tokens.size()) + break; + if (currentToken() != Token::Or) + throw SemVerError(); + nextToken(); + } + } + catch (SemVerError const&) + { + reset(); + } + + return m_expression; +} + + +void SemVerMatchExpressionParser::reset() +{ + m_expression = SemVerMatchExpression(); + m_pos = 0; + m_posInside = 0; +} + +void SemVerMatchExpressionParser::parseMatchExpression() +{ + // component - component (range) + // or component component* (conjunction) + + SemVerMatchExpression::Conjunction range; + range.components.push_back(parseMatchComponent()); + if (currentToken() == Token::Sub) + { + range.components[0].prefix = Token::GreaterThanOrEqual; + nextToken(); + range.components.push_back(parseMatchComponent()); + range.components[1].prefix = Token::LessThanOrEqual; + } + else + while (currentToken() != Token::Or && currentToken() != Token::Illegal) + range.components.push_back(parseMatchComponent()); + m_expression.m_disjunction.push_back(range); +} + +SemVerMatchExpression::MatchComponent SemVerMatchExpressionParser::parseMatchComponent() +{ + SemVerMatchExpression::MatchComponent component; + Token::Value token = currentToken(); + if ( + token == Token::BitXor || + token == Token::BitNot || + token == Token::LessThan || + token == Token::LessThanOrEqual|| + token == Token::GreaterThan || + token == Token::GreaterThanOrEqual || + token == Token::Assign + ) + { + component.prefix = token; + nextToken(); + } + else + component.prefix = Token::Assign; + + component.levelsPresent = 0; + while (component.levelsPresent < 3) + { + component.version.numbers[component.levelsPresent] = parseVersionPart(); + component.levelsPresent++; + if (currentChar() == '.') + nextChar(); + else + break; + } + // TODO we do not support pre and build version qualifiers for now in match expressions + // (but we do support them in the actual versions) + return component; +} + +unsigned SemVerMatchExpressionParser::parseVersionPart() +{ + auto startPos = m_pos; + char c = currentChar(); + nextChar(); + if (c == 'x' || c == 'X' || c == '*') + return unsigned(-1); + else if (c == '0') + return 0; + else if ('1' <= c && c <= '9') + { + unsigned v = c - '0'; + // If we skip to the next token, the current number is terminated. + while (m_pos == startPos && '0' <= currentChar() && currentChar() <= '9') + { + c = currentChar(); + if (v * 10 < v || v * 10 + (c - '0') < v * 10) + throw SemVerError(); + v = v * 10 + c - '0'; + nextChar(); + } + return v; + } + else + throw SemVerError(); +} + +char SemVerMatchExpressionParser::currentChar() const +{ + if (m_pos >= m_literals.size()) + return char(-1); + if (m_posInside >= m_literals[m_pos].size()) + return char(-1); + return m_literals[m_pos][m_posInside]; +} + +char SemVerMatchExpressionParser::nextChar() +{ + if (m_pos < m_literals.size()) + { + if (m_posInside + 1 >= m_literals[m_pos].size()) + nextToken(); + else + ++m_posInside; + } + return currentChar(); +} + +Token::Value SemVerMatchExpressionParser::currentToken() const +{ + if (m_pos < m_tokens.size()) + return m_tokens[m_pos]; + else + return Token::Illegal; +} + +void SemVerMatchExpressionParser::nextToken() +{ + ++m_pos; + m_posInside = 0; +} diff --git a/libsolidity/analysis/SemVerHandler.h b/libsolidity/analysis/SemVerHandler.h new file mode 100644 index 00000000..3c110b19 --- /dev/null +++ b/libsolidity/analysis/SemVerHandler.h @@ -0,0 +1,102 @@ +/* + This file is part of cpp-ethereum. + + cpp-ethereum is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + cpp-ethereum is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with cpp-ethereum. If not, see . +*/ +/** + * @author Christian + * @date 2016 + * Utilities to handle semantic versioning. + */ + +#pragma once + +#include +#include + +namespace dev +{ +namespace solidity +{ + +class SemVerError: dev::Exception +{ +}; + +struct SemVerVersion +{ + unsigned numbers[3]; + std::string prerelease; + std::string build; + + explicit SemVerVersion(std::string const& _versionString = "0.0.0"); +}; + +struct SemVerMatchExpression +{ + bool matches(SemVerVersion const& _version) const; + + bool isValid() const { return !m_disjunction.empty(); } + + struct MatchComponent + { + /// Prefix from < > <= >= ~ ^ + Token::Value prefix = Token::Illegal; + /// Version, where unsigned(-1) in major, minor or patch denotes '*', 'x' or 'X' + SemVerVersion version; + /// Whether we have 1, 1.2 or 1.2.4 + unsigned levelsPresent = 1; + bool matches(SemVerVersion const& _version) const; + }; + + struct Conjunction + { + std::vector components; + bool matches(SemVerVersion const& _version) const; + }; + + std::vector m_disjunction; +}; + +class SemVerMatchExpressionParser +{ +public: + SemVerMatchExpressionParser(std::vector const& _tokens, std::vector const& _literals): + m_tokens(_tokens), m_literals(_literals) + {} + SemVerMatchExpression parse(); + +private: + void reset(); + + void parseMatchExpression(); + SemVerMatchExpression::MatchComponent parseMatchComponent(); + unsigned parseVersionPart(); + + char currentChar() const; + char nextChar(); + Token::Value currentToken() const; + void nextToken(); + + std::vector m_tokens; + std::vector m_literals; + + unsigned m_pos = 0; + unsigned m_posInside = 0; + + SemVerMatchExpression m_expression; +}; + +} +} diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index 593f2f69..d44fceb4 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -15,9 +15,11 @@ along with cpp-ethereum. If not, see . */ +#include #include #include -#include +#include +#include using namespace std; using namespace dev; @@ -27,7 +29,7 @@ using namespace dev::solidity; bool SyntaxChecker::checkSyntax(SourceUnit const& _sourceUnit) { _sourceUnit.accept(*this); - return m_errors.empty(); + return Error::containsOnlyWarnings(m_errors); } void SyntaxChecker::syntaxError(SourceLocation const& _location, std::string const& _description) @@ -40,6 +42,51 @@ void SyntaxChecker::syntaxError(SourceLocation const& _location, std::string con m_errors.push_back(err); } +bool SyntaxChecker::visit(SourceUnit const&) +{ + m_versionPragmaFound = false; + return true; +} + +void SyntaxChecker::endVisit(SourceUnit const& _sourceUnit) +{ + if (!m_versionPragmaFound) + { + auto err = make_shared(Error::Type::Warning); + *err << + errinfo_sourceLocation(_sourceUnit.location()) << + errinfo_comment( + string("Source file does not specify required compiler version! ") + + string("Consider adding \"pragma solidity ^") + VersionNumber + string(";\".") + ); + m_errors.push_back(err); + } +} + +bool SyntaxChecker::visit(PragmaDirective const& _pragma) +{ + solAssert(!_pragma.tokens().empty(), ""); + solAssert(_pragma.tokens().size() == _pragma.literals().size(), ""); + if (_pragma.tokens()[0] != Token::Identifier && _pragma.literals()[0] != "solidity") + syntaxError(_pragma.location(), "Unknown pragma \"" + _pragma.literals()[0] + "\""); + else + { + vector tokens(_pragma.tokens().begin() + 1, _pragma.tokens().end()); + vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); + SemVerMatchExpressionParser parser(tokens, literals); + auto matchExpression = parser.parse(); + SemVerVersion currentVersion{string(VersionNumber)}; + if (!matchExpression.matches(currentVersion)) + syntaxError( + _pragma.location(), + "Source file requires different compiler version (current compiler is " + + string(VersionNumber) + ")." + ); + m_versionPragmaFound = true; + } + return true; +} + bool SyntaxChecker::visit(ModifierDefinition const&) { m_placeholderFound = false; @@ -91,7 +138,7 @@ bool SyntaxChecker::visit(Break const& _breakStatement) return true; } -bool SyntaxChecker::visit(const PlaceholderStatement&) +bool SyntaxChecker::visit(PlaceholderStatement const&) { m_placeholderFound = true; return true; diff --git a/libsolidity/analysis/SyntaxChecker.h b/libsolidity/analysis/SyntaxChecker.h index 3198ffd0..ac8ed872 100644 --- a/libsolidity/analysis/SyntaxChecker.h +++ b/libsolidity/analysis/SyntaxChecker.h @@ -45,6 +45,10 @@ private: /// Adds a new error to the list of errors. void syntaxError(SourceLocation const& _location, std::string const& _description); + virtual bool visit(SourceUnit const& _sourceUnit) override; + virtual void endVisit(SourceUnit const& _sourceUnit) override; + virtual bool visit(PragmaDirective const& _pragma) override; + virtual bool visit(ModifierDefinition const& _modifier) override; virtual void endVisit(ModifierDefinition const& _modifier) override; @@ -63,6 +67,9 @@ private: /// Flag that indicates whether a function modifier actually contains '_'. bool m_placeholderFound = false; + /// Flag that indicates whether some version pragma was present. + bool m_versionPragmaFound = false; + int m_inLoopDepth = 0; }; diff --git a/libsolidity/ast/AST.h b/libsolidity/ast/AST.h index bf275869..761d85fe 100644 --- a/libsolidity/ast/AST.h +++ b/libsolidity/ast/AST.h @@ -175,6 +175,34 @@ private: ASTNode const* m_scope; }; +/** + * Pragma directive, only version requirements in the form `pragma solidity "^0.4.0";` are + * supported for now. + */ +class PragmaDirective: public ASTNode +{ +public: + PragmaDirective( + SourceLocation const& _location, + std::vector const& _tokens, + std::vector const& _literals + ): ASTNode(_location), m_tokens(_tokens), m_literals(_literals) + {} + + virtual void accept(ASTVisitor& _visitor) override; + virtual void accept(ASTConstVisitor& _visitor) const override; + + std::vector const& tokens() const { return m_tokens; } + std::vector const& literals() const { return m_literals; } + +private: + + /// Sequence of tokens following the "pragma" keyword. + std::vector m_tokens; + /// Sequence of literals following the "pragma" keyword. + std::vector m_literals; +}; + /** * Import directive for referencing other files / source objects. * Example: import "abc.sol" // imports all symbols of "abc.sol" into current scope diff --git a/libsolidity/ast/ASTForward.h b/libsolidity/ast/ASTForward.h index dad2b2e2..59fc1b57 100644 --- a/libsolidity/ast/ASTForward.h +++ b/libsolidity/ast/ASTForward.h @@ -35,6 +35,7 @@ namespace solidity class ASTNode; class SourceUnit; +class PragmaDirective; class ImportDirective; class Declaration; class ContractDefinition; diff --git a/libsolidity/ast/ASTJsonConverter.cpp b/libsolidity/ast/ASTJsonConverter.cpp index 35fd0b7d..49ee6d34 100644 --- a/libsolidity/ast/ASTJsonConverter.cpp +++ b/libsolidity/ast/ASTJsonConverter.cpp @@ -103,6 +103,15 @@ bool ASTJsonConverter::visit(SourceUnit const&) return true; } +bool ASTJsonConverter::visit(PragmaDirective const& _node) +{ + Json::Value literals(Json::arrayValue); + for (auto const& literal: _node.literals()) + literals.append(literal); + addJsonNode(_node, "PragmaDirective", { make_pair("literals", literals) }); + return true; +} + bool ASTJsonConverter::visit(ImportDirective const& _node) { addJsonNode(_node, "ImportDirective", { make_pair("file", _node.path())}); @@ -401,6 +410,10 @@ void ASTJsonConverter::endVisit(SourceUnit const&) goUp(); } +void ASTJsonConverter::endVisit(PragmaDirective const&) +{ +} + void ASTJsonConverter::endVisit(ImportDirective const&) { } diff --git a/libsolidity/ast/ASTJsonConverter.h b/libsolidity/ast/ASTJsonConverter.h index 97aa8654..7c7b37f8 100644 --- a/libsolidity/ast/ASTJsonConverter.h +++ b/libsolidity/ast/ASTJsonConverter.h @@ -52,6 +52,7 @@ public: Json::Value const& json(); bool visit(SourceUnit const& _node) override; + bool visit(PragmaDirective const& _node) override; bool visit(ImportDirective const& _node) override; bool visit(ContractDefinition const& _node) override; bool visit(InheritanceSpecifier const& _node) override; @@ -96,6 +97,7 @@ public: bool visit(Literal const& _node) override; void endVisit(SourceUnit const&) override; + void endVisit(PragmaDirective const&) override; void endVisit(ImportDirective const&) override; void endVisit(ContractDefinition const&) override; void endVisit(InheritanceSpecifier const&) override; diff --git a/libsolidity/ast/ASTPrinter.cpp b/libsolidity/ast/ASTPrinter.cpp index 9ed9c6d5..a9de457a 100644 --- a/libsolidity/ast/ASTPrinter.cpp +++ b/libsolidity/ast/ASTPrinter.cpp @@ -47,6 +47,13 @@ void ASTPrinter::print(ostream& _stream) } +bool ASTPrinter::visit(PragmaDirective const& _node) +{ + writeLine("PragmaDirective"); + printSourcePart(_node); + return goDeeper(); +} + bool ASTPrinter::visit(ImportDirective const& _node) { writeLine("ImportDirective \"" + _node.path() + "\""); @@ -355,6 +362,11 @@ bool ASTPrinter::visit(Literal const& _node) return goDeeper(); } +void ASTPrinter::endVisit(PragmaDirective const&) +{ + m_indentation--; +} + void ASTPrinter::endVisit(ImportDirective const&) { m_indentation--; diff --git a/libsolidity/ast/ASTPrinter.h b/libsolidity/ast/ASTPrinter.h index a2546935..f0ab1098 100644 --- a/libsolidity/ast/ASTPrinter.h +++ b/libsolidity/ast/ASTPrinter.h @@ -47,6 +47,7 @@ public: /// Output the string representation of the AST to _stream. void print(std::ostream& _stream); + bool visit(PragmaDirective const& _node) override; bool visit(ImportDirective const& _node) override; bool visit(ContractDefinition const& _node) override; bool visit(InheritanceSpecifier const& _node) override; @@ -89,6 +90,7 @@ public: bool visit(ElementaryTypeNameExpression const& _node) override; bool visit(Literal const& _node) override; + void endVisit(PragmaDirective const&) override; void endVisit(ImportDirective const&) override; void endVisit(ContractDefinition const&) override; void endVisit(InheritanceSpecifier const&) override; diff --git a/libsolidity/ast/ASTVisitor.h b/libsolidity/ast/ASTVisitor.h index 5aac2066..3a1b55d3 100644 --- a/libsolidity/ast/ASTVisitor.h +++ b/libsolidity/ast/ASTVisitor.h @@ -44,6 +44,7 @@ class ASTVisitor { public: virtual bool visit(SourceUnit& _node) { return visitNode(_node); } + virtual bool visit(PragmaDirective& _node) { return visitNode(_node); } virtual bool visit(ImportDirective& _node) { return visitNode(_node); } virtual bool visit(ContractDefinition& _node) { return visitNode(_node); } virtual bool visit(InheritanceSpecifier& _node) { return visitNode(_node); } @@ -88,6 +89,7 @@ public: virtual bool visit(Literal& _node) { return visitNode(_node); } virtual void endVisit(SourceUnit& _node) { endVisitNode(_node); } + virtual void endVisit(PragmaDirective& _node) { endVisitNode(_node); } virtual void endVisit(ImportDirective& _node) { endVisitNode(_node); } virtual void endVisit(ContractDefinition& _node) { endVisitNode(_node); } virtual void endVisit(InheritanceSpecifier& _node) { endVisitNode(_node); } @@ -144,6 +146,7 @@ class ASTConstVisitor { public: virtual bool visit(SourceUnit const& _node) { return visitNode(_node); } + virtual bool visit(PragmaDirective const& _node) { return visitNode(_node); } virtual bool visit(ImportDirective const& _node) { return visitNode(_node); } virtual bool visit(ContractDefinition const& _node) { return visitNode(_node); } virtual bool visit(InheritanceSpecifier const& _node) { return visitNode(_node); } @@ -188,6 +191,7 @@ public: virtual bool visit(Literal const& _node) { return visitNode(_node); } virtual void endVisit(SourceUnit const& _node) { endVisitNode(_node); } + virtual void endVisit(PragmaDirective const& _node) { endVisitNode(_node); } virtual void endVisit(ImportDirective const& _node) { endVisitNode(_node); } virtual void endVisit(ContractDefinition const& _node) { endVisitNode(_node); } virtual void endVisit(InheritanceSpecifier const& _node) { endVisitNode(_node); } diff --git a/libsolidity/ast/AST_accept.h b/libsolidity/ast/AST_accept.h index dd2a7d60..b5a3806b 100644 --- a/libsolidity/ast/AST_accept.h +++ b/libsolidity/ast/AST_accept.h @@ -45,6 +45,18 @@ void SourceUnit::accept(ASTConstVisitor& _visitor) const _visitor.endVisit(*this); } +void PragmaDirective::accept(ASTVisitor& _visitor) +{ + _visitor.visit(*this); + _visitor.endVisit(*this); +} + +void PragmaDirective::accept(ASTConstVisitor& _visitor) const +{ + _visitor.visit(*this); + _visitor.endVisit(*this); +} + void ImportDirective::accept(ASTVisitor& _visitor) { _visitor.visit(*this); diff --git a/libsolidity/grammar.txt b/libsolidity/grammar.txt index 0d1f68a6..0230729a 100644 --- a/libsolidity/grammar.txt +++ b/libsolidity/grammar.txt @@ -1,13 +1,16 @@ -SourceUnit = (ImportDirective | ContractDefinition)* +SourceUnit = (PragmaDirective | ImportDirective | ContractDefinition)* -ContractDefinition = ( 'contract' | 'library' ) Identifier - ( 'is' InheritanceSpecifier (',' InheritanceSpecifier )* )? - '{' ContractPart* '}' +// Pragma actually parses anything up to the trailing ';' to be fully forward-compatible. +PragmaDirective = 'pragma' Identifier Expression ';' ImportDirective = 'import' StringLiteral ('as' Identifier)? ';' | 'import' ('*' | Identifier) ('as' Identifier)? 'from' StringLiteral ';' | 'import' '{' Identifier ('as' Identifier)? ( ',' Identifier ('as' Identifier)? )* '}' 'from' StringLiteral ';' +ContractDefinition = ( 'contract' | 'library' ) Identifier + ( 'is' InheritanceSpecifier (',' InheritanceSpecifier )* )? + '{' ContractPart* '}' + ContractPart = StateVariableDeclaration | UsingForDeclaration | StructDefinition | ModifierDefinition | FunctionDefinition | EventDefinition | EnumDefinition diff --git a/libsolidity/parsing/Parser.cpp b/libsolidity/parsing/Parser.cpp index b8f72238..b2f4a156 100644 --- a/libsolidity/parsing/Parser.cpp +++ b/libsolidity/parsing/Parser.cpp @@ -76,6 +76,9 @@ ASTPointer Parser::parse(shared_ptr const& _scanner) { switch (auto token = m_scanner->currentToken()) { + case Token::Pragma: + nodes.push_back(parsePragmaDirective()); + break; case Token::Import: nodes.push_back(parseImportDirective()); break; @@ -97,6 +100,36 @@ ASTPointer Parser::parse(shared_ptr const& _scanner) } } +ASTPointer Parser::parsePragmaDirective() +{ + // pragma anything* ; + // Currently supported: + // pragma solidity ^0.4.0 || ^0.3.0; + ASTNodeFactory nodeFactory(*this); + expectToken(Token::Pragma); + vector literals; + vector tokens; + do + { + Token::Value token = m_scanner->currentToken(); + if (token == Token::Illegal) + parserError("Token incompatible with Solidity parser as part of pragma directive."); + else + { + string literal = m_scanner->currentLiteral(); + if (literal.empty() && Token::toString(token)) + literal = Token::toString(token); + literals.push_back(literal); + tokens.push_back(token); + } + m_scanner->next(); + } + while (m_scanner->currentToken() != Token::Semicolon && m_scanner->currentToken() != Token::EOS); + nodeFactory.markEndPosition(); + expectToken(Token::Semicolon); + return nodeFactory.createNode(tokens, literals); +} + ASTPointer Parser::parseImportDirective() { // import "abc" [as x]; diff --git a/libsolidity/parsing/Parser.h b/libsolidity/parsing/Parser.h index d776c3fd..9c30cf60 100644 --- a/libsolidity/parsing/Parser.h +++ b/libsolidity/parsing/Parser.h @@ -55,6 +55,7 @@ private: ///@{ ///@name Parsing functions for the AST nodes + ASTPointer parsePragmaDirective(); ASTPointer parseImportDirective(); ASTPointer parseContractDefinition(bool _isLibrary); ASTPointer parseInheritanceSpecifier(); diff --git a/libsolidity/parsing/Token.h b/libsolidity/parsing/Token.h index 007baef4..15d4860f 100644 --- a/libsolidity/parsing/Token.h +++ b/libsolidity/parsing/Token.h @@ -167,6 +167,7 @@ namespace solidity K(Modifier, "modifier", 0) \ K(New, "new", 0) \ K(Public, "public", 0) \ + K(Pragma, "pragma", 0) \ K(Private, "private", 0) \ K(Return, "return", 0) \ K(Returns, "returns", 0) \ -- cgit v1.2.3 From d87450b9b2ba110b218c8f58224ca3af4e62993b Mon Sep 17 00:00:00 2001 From: chriseth Date: Tue, 23 Aug 2016 17:03:23 +0200 Subject: Use version string (including prerelease) for pragma matching. --- libsolidity/analysis/SyntaxChecker.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'libsolidity') diff --git a/libsolidity/analysis/SyntaxChecker.cpp b/libsolidity/analysis/SyntaxChecker.cpp index d44fceb4..a95b4879 100644 --- a/libsolidity/analysis/SyntaxChecker.cpp +++ b/libsolidity/analysis/SyntaxChecker.cpp @@ -75,12 +75,13 @@ bool SyntaxChecker::visit(PragmaDirective const& _pragma) vector literals(_pragma.literals().begin() + 1, _pragma.literals().end()); SemVerMatchExpressionParser parser(tokens, literals); auto matchExpression = parser.parse(); - SemVerVersion currentVersion{string(VersionNumber)}; + SemVerVersion currentVersion{string(VersionString)}; if (!matchExpression.matches(currentVersion)) syntaxError( _pragma.location(), "Source file requires different compiler version (current compiler is " + - string(VersionNumber) + ")." + string(VersionString) + " - note that nightly builds are considered to be " + "strictly less than the released version" ); m_versionPragmaFound = true; } -- cgit v1.2.3