SemVerHandler.cpp

/*
	This file is part of solidity.

	solidity is free software: you can redistribute it and/or modify
	it under the terms of the GNU General Public License as published by
	the Free Software Foundation, either version 3 of the License, or
	(at your option) any later version.

	solidity is distributed in the hope that it will be useful,
	but WITHOUT ANY WARRANTY; without even the implied warranty of
	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
	GNU General Public License for more details.

	You should have received a copy of the GNU General Public License
	along with solidity.  If not, see <http://www.gnu.org/licenses/>.
*/
// SPDX-License-Identifier: GPL-3.0
/**
 * @author Christian <chris@ethereum.org>
 * @date 2016
 * Utilities to handle semantic versioning.
 */

#include <liblangutil/SemVerHandler.h>

#include <liblangutil/Exceptions.h>

#include <functional>
#include <limits>
#include <fmt/format.h>

using namespace std::string_literals;
using namespace solidity;
using namespace solidity::langutil;
using namespace solidity::util;

SemVerMatchExpressionParser::SemVerMatchExpressionParser(std::vector<Token> _tokens, std::vector<std::string> _literals):
	m_tokens(std::move(_tokens)), m_literals(std::move(_literals))
{
	solAssert(m_tokens.size() == m_literals.size(), "");
}

SemVerVersion::SemVerVersion(std::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 + unsigned(*i - '0');
		numbers[level] = v;
		if (level < 2)
		{
			if (i == end || *i != '.')
				solThrow(SemVerError, "Invalid versionString: "s + _versionString);
			else
				++i;
		}
	}
	if (i != end && *i == '-')
	{
		auto prereleaseStart = ++i;
		while (i != end && *i != '+') ++i;
		prerelease = std::string(prereleaseStart, i);
	}
	if (i != end && *i == '+')
	{
		auto buildStart = ++i;
		while (i != end) ++i;
		build = std::string(buildStart, i);
	}
	if (i != end)
		solThrow(SemVerError, "Invalid versionString "s + _versionString);
}

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 != 1)
			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] != std::numeric_limits<unsigned>::max())
			{
				didCompare = true;
				cmp = static_cast<int>(_version.numbers[i]) - static_cast<int>(version.numbers[i]);
			}

		if (cmp == 0 && !_version.prerelease.empty() && didCompare)
			cmp = -1;

		switch (prefix)
		{
		case Token::Assign:
			return cmp == 0;
		case Token::LessThan:
			return cmp < 0;
		case Token::LessThanOrEqual:
			return cmp <= 0;
		case Token::GreaterThan:
			return cmp > 0;
		case Token::GreaterThanOrEqual:
			return cmp >= 0;
		default:
			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();

	if (m_tokens.empty())
		solThrow(SemVerError, "Empty version pragma.");

	try
	{
		while (true)
		{
			parseMatchExpression();
			if (m_pos >= m_tokens.size())
				break;
			if (currentToken() != Token::Or)
			{
				solThrow(
					SemVerError,
					"You can only combine version ranges using the || operator."
				);
			}
			nextToken();
		}
	}
	catch (SemVerError const& e)
	{
		reset();
		throw e;
	}

	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 token = currentToken();

	switch (token)
	{
	case Token::BitXor:
	case Token::BitNot:
	case Token::LessThan:
	case Token::LessThanOrEqual:
	case Token::GreaterThan:
	case Token::GreaterThanOrEqual:
	case Token::Assign:
		component.prefix = token;
		nextToken();
		break;
	default:
		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')
	{
		auto v = static_cast<unsigned>(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 + static_cast<unsigned>(c - '0') < v * 10)
				solThrow(SemVerError, "Integer too large to be used in a version number.");
			v = v * 10 + static_cast<unsigned>(c - '0');
			nextChar();
		}
		return v;
	}
	else if (c == char(-1))
		solThrow(SemVerError, "Expected version number but reached end of pragma.");
	else
		solThrow(
			SemVerError, fmt::format(
				"Expected the start of a version number but instead found character '{}'. "
				"Version number is invalid or the pragma is not terminated with a semicolon.",
				c
			)
		);
}

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 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;
}