/*
    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 <http://www.gnu.org/licenses/>.
*/
/**
 * @author Christian <c@ethdev.com>
 * @date 2014
 * Solidity abstract syntax tree.
 */

#include <algorithm>
#include <boost/range/adaptor/reversed.hpp>
#include <libsolidity/Utils.h>
#include <libsolidity/AST.h>
#include <libsolidity/ASTVisitor.h>
#include <libsolidity/Exceptions.h>
#include <libsolidity/AST_accept.h>

#include <libdevcore/SHA3.h>

using namespace std;

namespace dev
{
namespace solidity
{

TypeError ASTNode::createTypeError(string const& _description) const
{
	return TypeError() << errinfo_sourceLocation(getLocation()) << errinfo_comment(_description);
}

TypePointer ContractDefinition::getType(ContractDefinition const* _currentContract) const
{
	return make_shared<TypeType>(make_shared<ContractType>(*this), _currentContract);
}

void ContractDefinition::checkTypeRequirements()
{
	for (ASTPointer<InheritanceSpecifier> const& baseSpecifier: getBaseContracts())
		baseSpecifier->checkTypeRequirements();

	checkDuplicateFunctions();
	checkIllegalOverrides();
	checkAbstractFunctions();
	checkAbstractConstructors();

	FunctionDefinition const* constructor = getConstructor();
	if (constructor && !constructor->getReturnParameters().empty())
		BOOST_THROW_EXCEPTION(constructor->getReturnParameterList()->createTypeError(
									"Non-empty \"returns\" directive for constructor."));

	FunctionDefinition const* fallbackFunction = nullptr;
	for (ASTPointer<FunctionDefinition> const& function: getDefinedFunctions())
	{
		if (function->getName().empty())
		{
			if (fallbackFunction)
				BOOST_THROW_EXCEPTION(DeclarationError() << errinfo_comment("Only one fallback function is allowed."));
			else
			{
				fallbackFunction = function.get();
				if (!fallbackFunction->getParameters().empty())
					BOOST_THROW_EXCEPTION(fallbackFunction->getParameterList().createTypeError("Fallback function cannot take parameters."));
			}
		}
		if (!function->isFullyImplemented())
			setFullyImplemented(false);
	}
	for (ASTPointer<ModifierDefinition> const& modifier: getFunctionModifiers())
		modifier->checkTypeRequirements();

	for (ASTPointer<FunctionDefinition> const& function: getDefinedFunctions())
		function->checkTypeRequirements();

	for (ASTPointer<VariableDeclaration> const& variable: m_stateVariables)
		variable->checkTypeRequirements();

	checkExternalTypeClashes();
	// check for hash collisions in function signatures
	set<FixedHash<4>> hashes;
	for (auto const& it: getInterfaceFunctionList())
	{
		FixedHash<4> const& hash = it.first;
		if (hashes.count(hash))
			BOOST_THROW_EXCEPTION(createTypeError(
				string("Function signature hash collision for ") + it.second->externalSignature()
			));
		hashes.insert(hash);
	}
}

map<FixedHash<4>, FunctionTypePointer> ContractDefinition::getInterfaceFunctions() const
{
	auto exportedFunctionList = getInterfaceFunctionList();

	map<FixedHash<4>, FunctionTypePointer> exportedFunctions;
	for (auto const& it: exportedFunctionList)
		exportedFunctions.insert(it);

	solAssert(exportedFunctionList.size() == exportedFunctions.size(),
			  "Hash collision at Function Definition Hash calculation");

	return exportedFunctions;
}

FunctionDefinition const* ContractDefinition::getConstructor() const
{
	for (ASTPointer<FunctionDefinition> const& f: m_definedFunctions)
		if (f->isConstructor())
			return f.get();
	return nullptr;
}

FunctionDefinition const* ContractDefinition::getFallbackFunction() const
{
	for (ContractDefinition const* contract: getLinearizedBaseContracts())
		for (ASTPointer<FunctionDefinition> const& f: contract->getDefinedFunctions())
			if (f->getName().empty())
				return f.get();
	return nullptr;
}

void ContractDefinition::checkDuplicateFunctions() const
{
	/// Checks that two functions with the same name defined in this contract have different
	/// argument types and that there is at most one constructor.
	map<string, vector<FunctionDefinition const*>> functions;
	for (ASTPointer<FunctionDefinition> const& function: getDefinedFunctions())
		functions[function->getName()].push_back(function.get());

	if (functions[getName()].size() > 1)
	{
		SecondarySourceLocation ssl;
		auto it = functions[getName()].begin();
		++it;
		for (; it != functions[getName()].end(); ++it)
			ssl.append("Another declaration is here:", (*it)->getLocation());

		BOOST_THROW_EXCEPTION(
			DeclarationError() <<
			errinfo_sourceLocation(functions[getName()].front()->getLocation()) <<
			errinfo_comment("More than one constructor defined.") <<
			errinfo_secondarySourceLocation(ssl)
		);
	}
	for (auto const& it: functions)
	{
		vector<FunctionDefinition const*> const& overloads = it.second;
		for (size_t i = 0; i < overloads.size(); ++i)
			for (size_t j = i + 1; j < overloads.size(); ++j)
				if (FunctionType(*overloads[i]).hasEqualArgumentTypes(FunctionType(*overloads[j])))
					BOOST_THROW_EXCEPTION(
						DeclarationError() <<
						errinfo_sourceLocation(overloads[j]->getLocation()) <<
						errinfo_comment("Function with same name and arguments defined twice.") <<
						errinfo_secondarySourceLocation(SecondarySourceLocation().append(
							"Other declaration is here:", overloads[i]->getLocation()))
					);
	}
}

void ContractDefinition::checkAbstractFunctions()
{
	map<string, bool> functions;

	// Search from base to derived
	for (ContractDefinition const* contract: boost::adaptors::reverse(getLinearizedBaseContracts()))
		for (ASTPointer<FunctionDefinition> const& function: contract->getDefinedFunctions())
		{
			string const& name = function->getName();
			if (!function->isFullyImplemented() && functions.count(name) && functions[name])
				BOOST_THROW_EXCEPTION(function->createTypeError("Redeclaring an already implemented function as abstract"));
			functions[name] = function->isFullyImplemented();
		}

	for (auto const& it: functions)
		if (!it.second)
		{
			setFullyImplemented(false);
			break;
		}
}

void ContractDefinition::checkAbstractConstructors()
{
	set<ContractDefinition const*> argumentsNeeded;
	// check that we get arguments for all base constructors that need it.
	// If not mark the contract as abstract (not fully implemented)

	vector<ContractDefinition const*> const& bases = getLinearizedBaseContracts();
	for (ContractDefinition const* contract: bases)
		if (FunctionDefinition const* constructor = contract->getConstructor())
			if (contract != this && !constructor->getParameters().empty())
				argumentsNeeded.insert(contract);

	for (ContractDefinition const* contract: bases)
	{
		if (FunctionDefinition const* constructor = contract->getConstructor())
			for (auto const& modifier: constructor->getModifiers())
			{
				auto baseContract = dynamic_cast<ContractDefinition const*>(
					&modifier->getName()->getReferencedDeclaration()
				);
				if (baseContract)
					argumentsNeeded.erase(baseContract);
			}


		for (ASTPointer<InheritanceSpecifier> const& base: contract->getBaseContracts())
		{
			auto baseContract = dynamic_cast<ContractDefinition const*>(
				&base->getName()->getReferencedDeclaration()
			);
			solAssert(baseContract, "");
			if (!base->getArguments().empty())
				argumentsNeeded.erase(baseContract);
		}
	}
	if (!argumentsNeeded.empty())
		setFullyImplemented(false);
}

void ContractDefinition::checkIllegalOverrides() const
{
	// TODO unify this at a later point. for this we need to put the constness and the access specifier
	// into the types
	map<string, vector<FunctionDefinition const*>> functions;
	map<string, ModifierDefinition const*> modifiers;

	// We search from derived to base, so the stored item causes the error.
	for (ContractDefinition const* contract: getLinearizedBaseContracts())
	{
		for (ASTPointer<FunctionDefinition> const& function: contract->getDefinedFunctions())
		{
			if (function->isConstructor())
				continue; // constructors can neither be overridden nor override anything
			string const& name = function->getName();
			if (modifiers.count(name))
				BOOST_THROW_EXCEPTION(modifiers[name]->createTypeError("Override changes function to modifier."));
			FunctionType functionType(*function);
			// function should not change the return type
			for (FunctionDefinition const* overriding: functions[name])
			{
				FunctionType overridingType(*overriding);
				if (!overridingType.hasEqualArgumentTypes(functionType))
					continue;
				if (
					overriding->getVisibility() != function->getVisibility() ||
					overriding->isDeclaredConst() != function->isDeclaredConst() ||
					overridingType != functionType
				)
					BOOST_THROW_EXCEPTION(overriding->createTypeError("Override changes extended function signature."));
			}
			functions[name].push_back(function.get());
		}
		for (ASTPointer<ModifierDefinition> const& modifier: contract->getFunctionModifiers())
		{
			string const& name = modifier->getName();
			ModifierDefinition const*& override = modifiers[name];
			if (!override)
				override = modifier.get();
			else if (ModifierType(*override) != ModifierType(*modifier))
				BOOST_THROW_EXCEPTION(override->createTypeError("Override changes modifier signature."));
			if (!functions[name].empty())
				BOOST_THROW_EXCEPTION(override->createTypeError("Override changes modifier to function."));
		}
	}
}

void ContractDefinition::checkExternalTypeClashes() const
{
	map<string, vector<pair<Declaration const*, shared_ptr<FunctionType>>>> externalDeclarations;
	for (ContractDefinition const* contract: getLinearizedBaseContracts())
	{
		for (ASTPointer<FunctionDefinition> const& f: contract->getDefinedFunctions())
			if (f->isPartOfExternalInterface())
			{
				auto functionType = make_shared<FunctionType>(*f);
				externalDeclarations[functionType->externalSignature(f->getName())].push_back(
					make_pair(f.get(), functionType)
				);
			}
		for (ASTPointer<VariableDeclaration> const& v: contract->getStateVariables())
			if (v->isPartOfExternalInterface())
			{
				auto functionType = make_shared<FunctionType>(*v);
				externalDeclarations[functionType->externalSignature(v->getName())].push_back(
					make_pair(v.get(), functionType)
				);
			}
	}
	for (auto const& it: externalDeclarations)
		for (size_t i = 0; i < it.second.size(); ++i)
			for (size_t j = i + 1; j < it.second.size(); ++j)
				if (!it.second[i].second->hasEqualArgumentTypes(*it.second[j].second))
					BOOST_THROW_EXCEPTION(it.second[j].first->createTypeError(
						"Function overload clash during conversion to external types for arguments."
					));
}

vector<ASTPointer<EventDefinition>> const& ContractDefinition::getInterfaceEvents() const
{
	if (!m_interfaceEvents)
	{
		set<string> eventsSeen;
		m_interfaceEvents.reset(new vector<ASTPointer<EventDefinition>>());
		for (ContractDefinition const* contract: getLinearizedBaseContracts())
			for (ASTPointer<EventDefinition> const& e: contract->getEvents())
				if (eventsSeen.count(e->getName()) == 0)
				{
					eventsSeen.insert(e->getName());
					m_interfaceEvents->push_back(e);
				}
	}
	return *m_interfaceEvents;
}

vector<pair<FixedHash<4>, FunctionTypePointer>> const& ContractDefinition::getInterfaceFunctionList() const
{
	if (!m_interfaceFunctionList)
	{
		set<string> functionsSeen;
		set<string> signaturesSeen;
		m_interfaceFunctionList.reset(new vector<pair<FixedHash<4>, FunctionTypePointer>>());
		for (ContractDefinition const* contract: getLinearizedBaseContracts())
		{
			for (ASTPointer<FunctionDefinition> const& f: contract->getDefinedFunctions())
			{
				string functionSignature = f->externalSignature();
				if (f->isPartOfExternalInterface() && signaturesSeen.count(functionSignature) == 0)
				{
					functionsSeen.insert(f->getName());
					signaturesSeen.insert(functionSignature);
					FixedHash<4> hash(dev::sha3(functionSignature));
					m_interfaceFunctionList->push_back(make_pair(hash, make_shared<FunctionType>(*f, false)));
				}
			}

			for (ASTPointer<VariableDeclaration> const& v: contract->getStateVariables())
				if (functionsSeen.count(v->getName()) == 0 && v->isPartOfExternalInterface())
				{
					FunctionType ftype(*v);
					solAssert(v->getType().get(), "");
					functionsSeen.insert(v->getName());
					FixedHash<4> hash(dev::sha3(ftype.externalSignature(v->getName())));
					m_interfaceFunctionList->push_back(make_pair(hash, make_shared<FunctionType>(*v)));
				}
		}
	}
	return *m_interfaceFunctionList;
}

vector<Declaration const*> const& ContractDefinition::getInheritableMembers() const
{
	if (!m_inheritableMembers)
	{
		set<string> memberSeen;
		m_inheritableMembers.reset(new vector<Declaration const*>());
		auto addInheritableMember = [&](Declaration const* _decl)
		{
			if (memberSeen.count(_decl->getName()) == 0 && _decl->isVisibleInDerivedContracts())
			{
				memberSeen.insert(_decl->getName());
				m_inheritableMembers->push_back(_decl);
			}
		};

		for (ASTPointer<FunctionDefinition> const& f: getDefinedFunctions())
			addInheritableMember(f.get());

		for (ASTPointer<VariableDeclaration> const& v: getStateVariables())
			addInheritableMember(v.get());

		for (ASTPointer<StructDefinition> const& s: getDefinedStructs())
			addInheritableMember(s.get());
	}
	return *m_inheritableMembers;
}

TypePointer EnumValue::getType(ContractDefinition const*) const
{
	EnumDefinition const* parentDef = dynamic_cast<EnumDefinition const*>(getScope());
	solAssert(parentDef, "Enclosing Scope of EnumValue was not set");
	return make_shared<EnumType>(*parentDef);
}

void InheritanceSpecifier::checkTypeRequirements()
{
	m_baseName->checkTypeRequirements(nullptr);
	for (ASTPointer<Expression> const& argument: m_arguments)
		argument->checkTypeRequirements(nullptr);

	ContractDefinition const* base = dynamic_cast<ContractDefinition const*>(&m_baseName->getReferencedDeclaration());
	solAssert(base, "Base contract not available.");
	TypePointers parameterTypes = ContractType(*base).getConstructorType()->getParameterTypes();
	if (!m_arguments.empty() && parameterTypes.size() != m_arguments.size())
		BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for constructor call."));
	for (size_t i = 0; i < m_arguments.size(); ++i)
		if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i]))
			BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError(
				"Invalid type for argument in constructor call. "
				"Invalid implicit conversion from " +
				m_arguments[i]->getType()->toString() +
				" to " +
				parameterTypes[i]->toString() +
				" requested."
			));
}

TypePointer StructDefinition::getType(ContractDefinition const*) const
{
	return make_shared<TypeType>(make_shared<StructType>(*this));
}

void StructDefinition::checkMemberTypes() const
{
	for (ASTPointer<VariableDeclaration> const& member: getMembers())
		if (!member->getType()->canBeStored())
			BOOST_THROW_EXCEPTION(member->createTypeError("Type cannot be used in struct."));
}

void StructDefinition::checkRecursion() const
{
	set<StructDefinition const*> definitionsSeen;
	vector<StructDefinition const*> queue = {this};
	while (!queue.empty())
	{
		StructDefinition const* def = queue.back();
		queue.pop_back();
		if (definitionsSeen.count(def))
			BOOST_THROW_EXCEPTION(ParserError() << errinfo_sourceLocation(def->getLocation())
												<< errinfo_comment("Recursive struct definition."));
		definitionsSeen.insert(def);
		for (ASTPointer<VariableDeclaration> const& member: def->getMembers())
			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()));
			}
	}
}

TypePointer EnumDefinition::getType(ContractDefinition const*) const
{
	return make_shared<TypeType>(make_shared<EnumType>(*this));
}

TypePointer FunctionDefinition::getType(ContractDefinition const*) const
{
	return make_shared<FunctionType>(*this);
}

void FunctionDefinition::checkTypeRequirements()
{
	for (ASTPointer<VariableDeclaration> const& var: getParameters() + getReturnParameters())
	{
		if (!var->getType()->canLiveOutsideStorage())
			BOOST_THROW_EXCEPTION(var->createTypeError("Type is required to live outside storage."));
		if (getVisibility() >= Visibility::Public && !(var->getType()->externalType()))
			BOOST_THROW_EXCEPTION(var->createTypeError("Internal type is not allowed for public and external functions."));
	}
	for (ASTPointer<ModifierInvocation> const& modifier: m_functionModifiers)
		modifier->checkTypeRequirements(isConstructor() ?
			dynamic_cast<ContractDefinition const&>(*getScope()).getLinearizedBaseContracts() :
			vector<ContractDefinition const*>());
	if (m_body)
		m_body->checkTypeRequirements();
}

string FunctionDefinition::externalSignature() const
{
	return FunctionType(*this).externalSignature(getName());
}

bool VariableDeclaration::isLValue() const
{
	// External function parameters and constant declared variables are Read-Only
	return !isExternalCallableParameter() && !m_isConstant;
}

void VariableDeclaration::checkTypeRequirements()
{
	// Variables can be declared without type (with "var"), in which case the first assignment
	// sets the type.
	// Note that assignments before the first declaration are legal because of the special scoping
	// rules inherited from JavaScript.
	if (m_isConstant)
	{
		if (!dynamic_cast<ContractDefinition const*>(getScope()))
			BOOST_THROW_EXCEPTION(createTypeError("Illegal use of \"constant\" specifier."));
		if ((m_type && !m_type->isValueType()) || !m_value)
			BOOST_THROW_EXCEPTION(createTypeError("Unitialized \"constant\" variable."));
	}
	if (m_type)
	{
		if (m_value)
			m_value->expectType(*m_type);
	}
	else
	{
		if (!m_value)
			// This feature might be extended in the future.
			BOOST_THROW_EXCEPTION(createTypeError("Assignment necessary for type detection."));
		m_value->checkTypeRequirements(nullptr);

		TypePointer const& type = m_value->getType();
		if (
			type->getCategory() == Type::Category::IntegerConstant &&
			!dynamic_pointer_cast<IntegerConstantType const>(type)->getIntegerType()
		)
			BOOST_THROW_EXCEPTION(m_value->createTypeError("Invalid integer constant " + type->toString() + "."));
		else if (type->getCategory() == Type::Category::Void)
			BOOST_THROW_EXCEPTION(createTypeError("Variable cannot have void type."));
		m_type = type->mobileType();
	}
	if (m_isStateVariable && getVisibility() >= Visibility::Public && !FunctionType(*this).externalType())
		BOOST_THROW_EXCEPTION(createTypeError("Internal type is not allowed for public state variables."));
}

bool VariableDeclaration::isCallableParameter() const
{
	auto const* callable = dynamic_cast<CallableDeclaration const*>(getScope());
	if (!callable)
		return false;
	for (auto const& variable: callable->getParameters())
		if (variable.get() == this)
			return true;
	if (callable->getReturnParameterList())
		for (auto const& variable: callable->getReturnParameterList()->getParameters())
			if (variable.get() == this)
				return true;
	return false;
}

bool VariableDeclaration::isExternalCallableParameter() const
{
	auto const* callable = dynamic_cast<CallableDeclaration const*>(getScope());
	if (!callable || callable->getVisibility() != Declaration::Visibility::External)
		return false;
	for (auto const& variable: callable->getParameters())
		if (variable.get() == this)
			return true;
	return false;
}

TypePointer ModifierDefinition::getType(ContractDefinition const*) const
{
	return make_shared<ModifierType>(*this);
}

void ModifierDefinition::checkTypeRequirements()
{
	m_body->checkTypeRequirements();
}

void ModifierInvocation::checkTypeRequirements(vector<ContractDefinition const*> const& _bases)
{
	TypePointers argumentTypes;
	for (ASTPointer<Expression> const& argument: m_arguments)
	{
		argument->checkTypeRequirements(nullptr);
		argumentTypes.push_back(argument->getType());
	}
	m_modifierName->checkTypeRequirements(&argumentTypes);

	auto const* declaration = &m_modifierName->getReferencedDeclaration();
	vector<ASTPointer<VariableDeclaration>> emptyParameterList;
	vector<ASTPointer<VariableDeclaration>> const* parameters = nullptr;
	if (auto modifier = dynamic_cast<ModifierDefinition const*>(declaration))
		parameters = &modifier->getParameters();
	else
		// check parameters for Base constructors
		for (ContractDefinition const* base: _bases)
			if (declaration == base)
			{
				if (auto referencedConstructor = base->getConstructor())
					parameters = &referencedConstructor->getParameters();
				else
					parameters = &emptyParameterList;
				break;
			}
	if (!parameters)
		BOOST_THROW_EXCEPTION(createTypeError("Referenced declaration is neither modifier nor base class."));
	if (parameters->size() != m_arguments.size())
		BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for modifier invocation."));
	for (size_t i = 0; i < m_arguments.size(); ++i)
		if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*(*parameters)[i]->getType()))
			BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError(
				"Invalid type for argument in modifier invocation. "
				"Invalid implicit conversion from " +
				m_arguments[i]->getType()->toString() +
				" to " +
				(*parameters)[i]->getType()->toString() +
				" requested."
			));
}

void EventDefinition::checkTypeRequirements()
{
	int numIndexed = 0;
	for (ASTPointer<VariableDeclaration> const& var: getParameters())
	{
		if (var->isIndexed())
			numIndexed++;
		if (!var->getType()->canLiveOutsideStorage())
			BOOST_THROW_EXCEPTION(var->createTypeError("Type is required to live outside storage."));
		if (!var->getType()->externalType())
			BOOST_THROW_EXCEPTION(var->createTypeError("Internal type is not allowed as event parameter type."));
	}
	if (numIndexed > 3)
		BOOST_THROW_EXCEPTION(createTypeError("More than 3 indexed arguments for event."));
}

void Block::checkTypeRequirements()
{
	for (shared_ptr<Statement> const& statement: m_statements)
		statement->checkTypeRequirements();
}

void IfStatement::checkTypeRequirements()
{
	m_condition->expectType(BoolType());
	m_trueBody->checkTypeRequirements();
	if (m_falseBody)
		m_falseBody->checkTypeRequirements();
}

void WhileStatement::checkTypeRequirements()
{
	m_condition->expectType(BoolType());
	m_body->checkTypeRequirements();
}

void ForStatement::checkTypeRequirements()
{
	if (m_initExpression)
		m_initExpression->checkTypeRequirements();
	if (m_condExpression)
		m_condExpression->expectType(BoolType());
	if (m_loopExpression)
		m_loopExpression->checkTypeRequirements();
	m_body->checkTypeRequirements();
}

void Return::checkTypeRequirements()
{
	if (!m_expression)
		return;
	if (!m_returnParameters)
		BOOST_THROW_EXCEPTION(createTypeError("Return arguments not allowed."));
	if (m_returnParameters->getParameters().size() != 1)
		BOOST_THROW_EXCEPTION(createTypeError("Different number of arguments in return statement "
											  "than in returns declaration."));
	// this could later be changed such that the paramaters type is an anonymous struct type,
	// but for now, we only allow one return parameter
	m_expression->expectType(*m_returnParameters->getParameters().front()->getType());
}

void VariableDeclarationStatement::checkTypeRequirements()
{
	m_variable->checkTypeRequirements();
}

void Assignment::checkTypeRequirements(TypePointers const*)
{
	m_leftHandSide->checkTypeRequirements(nullptr);
	m_leftHandSide->requireLValue();
	if (m_leftHandSide->getType()->getCategory() == Type::Category::Mapping)
		BOOST_THROW_EXCEPTION(createTypeError("Mappings cannot be assigned to."));
	m_type = m_leftHandSide->getType();
	if (m_assigmentOperator == Token::Assign)
		m_rightHandSide->expectType(*m_type);
	else
	{
		// compound assignment
		m_rightHandSide->checkTypeRequirements(nullptr);
		TypePointer resultType = m_type->binaryOperatorResult(Token::AssignmentToBinaryOp(m_assigmentOperator),
															  m_rightHandSide->getType());
		if (!resultType || *resultType != *m_type)
			BOOST_THROW_EXCEPTION(createTypeError("Operator " + string(Token::toString(m_assigmentOperator)) +
												  " not compatible with types " +
												  m_type->toString() + " and " +
												  m_rightHandSide->getType()->toString()));
	}
}

void ExpressionStatement::checkTypeRequirements()
{
	m_expression->checkTypeRequirements(nullptr);
	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."));
}

void Expression::expectType(Type const& _expectedType)
{
	checkTypeRequirements(nullptr);
	Type const& type = *getType();
	if (!type.isImplicitlyConvertibleTo(_expectedType))
		BOOST_THROW_EXCEPTION(createTypeError(
			"Type " +
			type.toString() +
			" is not implicitly convertible to expected type " +
			_expectedType.toString() +
			"."
		)
		);
}

void Expression::requireLValue()
{
	if (!isLValue())
		BOOST_THROW_EXCEPTION(createTypeError("Expression has to be an lvalue."));
	m_lvalueRequested = true;
}

void UnaryOperation::checkTypeRequirements(TypePointers const*)
{
	// Inc, Dec, Add, Sub, Not, BitNot, Delete
	m_subExpression->checkTypeRequirements(nullptr);
	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)
		BOOST_THROW_EXCEPTION(createTypeError("Unary operator not compatible with type."));
}

void BinaryOperation::checkTypeRequirements(TypePointers const*)
{
	m_left->checkTypeRequirements(nullptr);
	m_right->checkTypeRequirements(nullptr);
	m_commonType = m_left->getType()->binaryOperatorResult(m_operator, m_right->getType());
	if (!m_commonType)
		BOOST_THROW_EXCEPTION(createTypeError("Operator " + string(Token::toString(m_operator)) +
											  " not compatible with types " +
											  m_left->getType()->toString() + " and " +
											  m_right->getType()->toString()));
	m_type = Token::isCompareOp(m_operator) ? make_shared<BoolType>() : m_commonType;
}

void FunctionCall::checkTypeRequirements(TypePointers const*)
{
	bool isPositionalCall = m_names.empty();

	// we need to check arguments' type first as they will be forwarded to
	// m_expression->checkTypeRequirements
	TypePointers argumentTypes;
	for (ASTPointer<Expression> const& argument: m_arguments)
	{
		argument->checkTypeRequirements(nullptr);
		// only store them for positional calls
		if (isPositionalCall)
			argumentTypes.push_back(argument->getType());
	}

	m_expression->checkTypeRequirements(isPositionalCall ? &argumentTypes : nullptr);

	Type const* expressionType = m_expression->getType().get();
	if (isTypeConversion())
	{
		TypeType const& type = dynamic_cast<TypeType const&>(*expressionType);
		//@todo for structs, we have to check the number of arguments to be equal to the
		// number of non-mapping members
		if (m_arguments.size() != 1)
			BOOST_THROW_EXCEPTION(createTypeError("Exactly one argument expected for explicit type conversion."));
		if (!isPositionalCall)
			BOOST_THROW_EXCEPTION(createTypeError("Type conversion cannot allow named arguments."));
		if (!m_arguments.front()->getType()->isExplicitlyConvertibleTo(*type.getActualType()))
			BOOST_THROW_EXCEPTION(createTypeError("Explicit type conversion not allowed."));
		m_type = type.getActualType();
	}
	else if (FunctionType const* functionType = dynamic_cast<FunctionType const*>(expressionType))
	{
		//@todo would be nice to create a struct type from the arguments
		// and then ask if that is implicitly convertible to the struct represented by the
		// function parameters
		TypePointers const& parameterTypes = functionType->getParameterTypes();
		if (!functionType->takesArbitraryParameters() && parameterTypes.size() != m_arguments.size())
			BOOST_THROW_EXCEPTION(createTypeError("Wrong argument count for function call."));

		if (isPositionalCall)
		{
			// call by positional arguments
			for (size_t i = 0; i < m_arguments.size(); ++i)
				if (
					!functionType->takesArbitraryParameters() &&
					!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[i])
				)
					BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError(
						"Invalid type for argument in function call. "
						"Invalid implicit conversion from " +
						m_arguments[i]->getType()->toString() +
						" to " +
						parameterTypes[i]->toString() +
						" requested."
					));
		}
		else
		{
			// call by named arguments
			if (functionType->takesArbitraryParameters())
				BOOST_THROW_EXCEPTION(createTypeError("Named arguments cannnot be used for functions "
													  "that take arbitrary parameters."));
			auto const& parameterNames = functionType->getParameterNames();
			if (parameterNames.size() != m_names.size())
				BOOST_THROW_EXCEPTION(createTypeError("Some argument names are missing."));

			// check duplicate names
			for (size_t i = 0; i < m_names.size(); i++)
				for (size_t j = i + 1; j < m_names.size(); j++)
					if (*m_names[i] == *m_names[j])
						BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError("Duplicate named argument."));

			for (size_t i = 0; i < m_names.size(); i++) {
				bool found = false;
				for (size_t j = 0; j < parameterNames.size(); j++) {
					if (parameterNames[j] == *m_names[i]) {
						// check type convertible
						if (!m_arguments[i]->getType()->isImplicitlyConvertibleTo(*parameterTypes[j]))
							BOOST_THROW_EXCEPTION(m_arguments[i]->createTypeError(
								"Invalid type for argument in function call. "
								"Invalid implicit conversion from " +
								m_arguments[i]->getType()->toString() +
								" to " +
								parameterTypes[i]->toString() +
								" requested."
							));

						found = true;
						break;
					}
				}
				if (!found)
					BOOST_THROW_EXCEPTION(createTypeError("Named argument does not match function declaration."));
			}
		}

		// @todo actually the return type should be an anonymous struct,
		// but we change it to the type of the first return value until we have structs
		if (functionType->getReturnParameterTypes().empty())
			m_type = make_shared<VoidType>();
		else
			m_type = functionType->getReturnParameterTypes().front();
	}
	else
		BOOST_THROW_EXCEPTION(createTypeError("Type is not callable."));
}

bool FunctionCall::isTypeConversion() const
{
	return m_expression->getType()->getCategory() == Type::Category::TypeType;
}

void NewExpression::checkTypeRequirements(TypePointers const*)
{
	m_contractName->checkTypeRequirements(nullptr);
	m_contract = dynamic_cast<ContractDefinition const*>(&m_contractName->getReferencedDeclaration());
	if (!m_contract)
		BOOST_THROW_EXCEPTION(createTypeError("Identifier is not a contract."));
	if (!m_contract->isFullyImplemented())
		BOOST_THROW_EXCEPTION(createTypeError("Trying to create an instance of an abstract contract."));
	shared_ptr<ContractType const> contractType = make_shared<ContractType>(*m_contract);
	TypePointers const& parameterTypes = contractType->getConstructorType()->getParameterTypes();
	m_type = make_shared<FunctionType>(
		parameterTypes,
		TypePointers{contractType},
		strings(),
		strings(),
		FunctionType::Location::Creation);
}

void MemberAccess::checkTypeRequirements(TypePointers const* _argumentTypes)
{
	m_expression->checkTypeRequirements(nullptr);
	Type const& type = *m_expression->getType();

	MemberList::MemberMap possibleMembers = type.getMembers().membersByName(*m_memberName);
	if (possibleMembers.size() > 1 && _argumentTypes)
	{
		// do override resolution
		for (auto it = possibleMembers.begin(); it != possibleMembers.end();)
			if (
				it->type->getCategory() == Type::Category::Function &&
				!dynamic_cast<FunctionType const&>(*it->type).canTakeArguments(*_argumentTypes)
			)
				it = possibleMembers.erase(it);
			else
				++it;
	}
	if (possibleMembers.size() == 0)
		BOOST_THROW_EXCEPTION(createTypeError(
			"Member \"" + *m_memberName + "\" not found or not visible "
			"after argument-dependent lookup in " + type.toString()
		));
	else if (possibleMembers.size() > 1)
		BOOST_THROW_EXCEPTION(createTypeError(
			"Member \"" + *m_memberName + "\" not unique "
			"after argument-dependent lookup in " + type.toString()
		));

	m_referencedDeclaration = possibleMembers.front().declaration;
	m_type = possibleMembers.front().type;
	if (type.getCategory() == Type::Category::Struct)
		m_isLValue = true;
	else if (type.getCategory() == Type::Category::Array)
	{
		auto const& arrayType(dynamic_cast<ArrayType const&>(type));
		m_isLValue = (*m_memberName == "length" &&
			arrayType.location() != ReferenceType::Location::CallData && arrayType.isDynamicallySized());
	}
	else
		m_isLValue = false;
}

void IndexAccess::checkTypeRequirements(TypePointers const*)
{
	m_base->checkTypeRequirements(nullptr);
	switch (m_base->getType()->getCategory())
	{
	case Type::Category::Array:
	{
		ArrayType const& type = dynamic_cast<ArrayType const&>(*m_base->getType());
		if (!m_index)
			BOOST_THROW_EXCEPTION(createTypeError("Index expression cannot be omitted."));
		if (type.isString())
			BOOST_THROW_EXCEPTION(createTypeError("Index access for string is not possible."));
		m_index->expectType(IntegerType(256));
		if (type.isByteArray())
			m_type = make_shared<FixedBytesType>(1);
		else
			m_type = type.getBaseType();
		m_isLValue = type.location() != ReferenceType::Location::CallData;
		break;
	}
	case Type::Category::Mapping:
	{
		MappingType const& type = dynamic_cast<MappingType const&>(*m_base->getType());
		if (!m_index)
			BOOST_THROW_EXCEPTION(createTypeError("Index expression cannot be omitted."));
		m_index->expectType(*type.getKeyType());
		m_type = type.getValueType();
		m_isLValue = true;
		break;
	}
	case Type::Category::TypeType:
	{
		TypeType const& type = dynamic_cast<TypeType const&>(*m_base->getType());
		if (!m_index)
			m_type = make_shared<TypeType>(make_shared<ArrayType>(ReferenceType::Location::Memory, type.getActualType()));
		else
		{
			m_index->checkTypeRequirements(nullptr);
			auto length = dynamic_cast<IntegerConstantType const*>(m_index->getType().get());
			if (!length)
				BOOST_THROW_EXCEPTION(m_index->createTypeError("Integer constant expected."));
			m_type = make_shared<TypeType>(make_shared<ArrayType>(
				ReferenceType::Location::Memory, type.getActualType(), length->literalValue(nullptr)));
		}
		break;
	}
	default:
		BOOST_THROW_EXCEPTION(m_base->createTypeError(
			"Indexed expression has to be a type, mapping or array (is " + m_base->getType()->toString() + ")"));
	}
}

void Identifier::checkTypeRequirements(TypePointers const* _argumentTypes)
{
	if (!m_referencedDeclaration)
	{
		if (!_argumentTypes)
			BOOST_THROW_EXCEPTION(createTypeError("Unable to determine overloaded type."));
		overloadResolution(*_argumentTypes);
	}
	solAssert(!!m_referencedDeclaration, "Referenced declaration is null after overload resolution.");
	m_isLValue = m_referencedDeclaration->isLValue();
	m_type = m_referencedDeclaration->getType(m_currentContract);
	if (!m_type)
		BOOST_THROW_EXCEPTION(createTypeError("Declaration referenced before type could be determined."));
}

Declaration const& Identifier::getReferencedDeclaration() const
{
	solAssert(!!m_referencedDeclaration, "Identifier not resolved.");
	return *m_referencedDeclaration;
}

void Identifier::overloadResolution(TypePointers const& _argumentTypes)
{
	solAssert(!m_referencedDeclaration, "Referenced declaration should be null before overload resolution.");
	solAssert(!m_overloadedDeclarations.empty(), "No candidates for overload resolution found.");

	vector<Declaration const*> possibles;
	if (m_overloadedDeclarations.size() == 1)
		m_referencedDeclaration = *m_overloadedDeclarations.begin();

	for (Declaration const* declaration: m_overloadedDeclarations)
	{
		TypePointer const& function = declaration->getType();
		auto const* functionType = dynamic_cast<FunctionType const*>(function.get());
		if (functionType && functionType->canTakeArguments(_argumentTypes))
			possibles.push_back(declaration);
	}
	if (possibles.size() == 1)
		m_referencedDeclaration = possibles.front();
	else if (possibles.empty())
		BOOST_THROW_EXCEPTION(createTypeError("No matching declaration found after argument-dependent lookup."));
	else
		BOOST_THROW_EXCEPTION(createTypeError("No unique declaration found after argument-dependent lookup."));
}

void ElementaryTypeNameExpression::checkTypeRequirements(TypePointers const*)
{
	m_type = make_shared<TypeType>(Type::fromElementaryTypeName(m_typeToken));
}

void Literal::checkTypeRequirements(TypePointers const*)
{
	m_type = Type::forLiteral(*this);
	if (!m_type)
		BOOST_THROW_EXCEPTION(createTypeError("Invalid literal value."));
}

}
}
-01-31 12:09:09 +0800'>2000-01-31</span></td><td>6</td><td><span class='deletions'>-0</span>/<span class='insertions'>+49</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=dee51b846eb7e72d9aa8985ecdbb76b766515d0c'>Unbreak for -current</a></td><td>Chris Piazza</td><td><span title='2000-01-31 11:43:43 +0800'>2000-01-31</span></td><td>2</td><td><span class='deletions'>-1</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=89e1eec692f45170065a9e2736e61fa62785d10b'>LIB_DEPENDS on SDL.1.0.0 instead of SDL.0. This allows it to compile,</a></td><td>Kris Kennaway</td><td><span title='2000-01-31 11:22:03 +0800'>2000-01-31</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=9f3fd548e09bc8f6933058cfb6293d6184e11f50'>Standardize my e-mail as reg@FreeBSD.org.</a></td><td>Jeremy Lea</td><td><span title='2000-01-30 06:11:15 +0800'>2000-01-30</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=00573bc60673679b327df0ef95d053453d25aef6'>make this install correctly</a></td><td>Michael Haro</td><td><span title='2000-01-30 04:03:49 +0800'>2000-01-30</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+22</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=cafcf6491fc4d81013860c4e9edb192c148d5168'>Add gnomechess.</a></td><td>Jeremy Lea</td><td><span title='2000-01-29 18:18:28 +0800'>2000-01-29</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=5e7f475c0cdaad77c2f340145bf8e9417867675a'>Initial import of GNOME Chess 0.2.4.</a></td><td>Jeremy Lea</td><td><span title='2000-01-29 18:15:08 +0800'>2000-01-29</span></td><td>8</td><td><span class='deletions'>-0</span>/<span class='insertions'>+131</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=d35f457702077ec27dda67f288dc193d37782957'>Adding xbaby version 1.2.</a></td><td>Steve Price</td><td><span title='2000-01-29 13:08:07 +0800'>2000-01-29</span></td><td>6</td><td><span class='deletions'>-0</span>/<span class='insertions'>+32</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=13bdc8afbd896c2b21d21e68fefd76fefa1ab6f1'>Adding xlifegame version 1.0.</a></td><td>Steve Price</td><td><span title='2000-01-29 13:06:05 +0800'>2000-01-29</span></td><td>6</td><td><span class='deletions'>-0</span>/<span class='insertions'>+28</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=823c104ee534fb9bae38f890462a9ab8734e034c'>Fix WWW in DESCR</a></td><td>Seiichirou Hiraoka</td><td><span title='2000-01-28 09:56:46 +0800'>2000-01-28</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=430ae55a49dff8084116ad770f72fe9b024b3db6'>Fix the new compiler problem as reported by bento.</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-28 08:45:32 +0800'>2000-01-28</span></td><td>3</td><td><span class='deletions'>-3</span>/<span class='insertions'>+54</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=b4490c98739cb5f97f3639f006f58f5b75c0cce5'>Update to Xpuyopuyo 3.1.  This release includes network play :)</a></td><td>Brian Feldman</td><td><span title='2000-01-28 01:24:41 +0800'>2000-01-28</span></td><td>3</td><td><span class='deletions'>-69</span>/<span class='insertions'>+4</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=b7de9234154ac733923c55bf1782ffb0480ebee4'>Fix MD5 checksum (found by bento):</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-25 08:39:46 +0800'>2000-01-25</span></td><td>2</td><td><span class='deletions'>-5</span>/<span class='insertions'>+5</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=3f9dfff96116af9781cd945a9f71ced0691f6fd7'>- Update to version 2.1a</a></td><td>Steve Price</td><td><span title='2000-01-24 14:02:10 +0800'>2000-01-24</span></td><td>4</td><td><span class='deletions'>-15</span>/<span class='insertions'>+23</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=289b6f579d5eba304c73885178144f2814452776'>- Add primary site to MASTER_SITES</a></td><td>Steve Price</td><td><span title='2000-01-24 14:01:01 +0800'>2000-01-24</span></td><td>4</td><td><span class='deletions'>-17</span>/<span class='insertions'>+23</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=0435dbb6b44c0a0c348f6ecd107fca5e05b54f27'>- Support CC/CFLAGS properly</a></td><td>Steve Price</td><td><span title='2000-01-24 13:59:29 +0800'>2000-01-24</span></td><td>2</td><td><span class='deletions'>-3</span>/<span class='insertions'>+47</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=2192ea6b700e9ad556643dc11f596900f4e8eb74'>Sort pkg/PLIST.</a></td><td>Steve Price</td><td><span title='2000-01-24 13:42:48 +0800'>2000-01-24</span></td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=aaa10906cec87200acf0720b98f0475991028c38'>Update to version 3.3.0.</a></td><td>Steve Price</td><td><span title='2000-01-24 13:40:46 +0800'>2000-01-24</span></td><td>58</td><td><span class='deletions'>-1392</span>/<span class='insertions'>+1561</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=983a791f7199dbc86dae5e4b8a44df8cbf72b555'>Activate speak</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-24 11:35:53 +0800'>2000-01-24</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=0625abb3f098e8aa8ffb9123d09364a393b235a3'>Speak is a program which generates random management gibberish speak</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-24 11:32:48 +0800'>2000-01-24</span></td><td>5</td><td><span class='deletions'>-0</span>/<span class='insertions'>+29</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=553bbd3676334c507bb541dfd60e0e57e91b2510'>support IPv6.</a></td><td>Munechika SUMIKAWA</td><td><span title='2000-01-24 09:35:42 +0800'>2000-01-24</span></td><td>3</td><td><span class='deletions'>-10</span>/<span class='insertions'>+30</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=98b5c37ae013ee1d684dc65738a1d8492f45c4d9'>Rechange strncpy to strlcpy.</a></td><td>Yukihiro Nakai</td><td><span title='2000-01-23 16:00:14 +0800'>2000-01-23</span></td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=9ef74882d1b4d3c7e984b787027d05b52a93cbd8'>Activate xinvaders3d</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-23 11:05:18 +0800'>2000-01-23</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=a0f8d175eac11aa22a0bb3e3c93d897ccd904af4'>3D Vector-graphics Space Invaders clone for X</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-23 11:04:22 +0800'>2000-01-23</span></td><td>7</td><td><span class='deletions'>-0</span>/<span class='insertions'>+65</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=ca47feacb18616c09c8a48c47262ef5921c1a8f2'>Change NO_PACKAGE to NO_CDROM. Thomas Biskup (author) confirms that it's</a></td><td>Michael Haro</td><td><span title='2000-01-23 08:59:59 +0800'>2000-01-23</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=8cd7b32a825f53fef818924f3dd3a0492f97d018'>Support IPv6.</a></td><td>Munechika SUMIKAWA</td><td><span title='2000-01-23 03:05:57 +0800'>2000-01-23</span></td><td>3</td><td><span class='deletions'>-23</span>/<span class='insertions'>+23</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=044fe0d8a22849514107c0302251f03f434a9688'>Fix and updates from KATO Tsuguru.</a></td><td>Yukihiro Nakai</td><td><span title='2000-01-22 19:46:45 +0800'>2000-01-22</span></td><td>37</td><td><span class='deletions'>-132</span>/<span class='insertions'>+202</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=e9780e98f173614be8b2d1fbf74ca7b29369ed65'>Fix the ports.</a></td><td>Yukihiro Nakai</td><td><span title='2000-01-22 19:18:59 +0800'>2000-01-22</span></td><td>3</td><td><span class='deletions'>-9</span>/<span class='insertions'>+9</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=be02932f7680bce97b46b1b9bd1a1f2cda67b7f6'>Distfile was moved.</a></td><td>Michael Haro</td><td><span title='2000-01-22 17:16:22 +0800'>2000-01-22</span></td><td>1</td><td><span class='deletions'>-2</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=22676bade853826d224aa97cb96b8c1de930c89b'>- Use MASTER_SITE_SUNSITE to MASTER_SITES</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-22 11:27:14 +0800'>2000-01-22</span></td><td>5</td><td><span class='deletions'>-6</span>/<span class='insertions'>+37</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=3253c03e13b4fc3b0ddcfb6aa5d92338e540f7a0'>Add WWW</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-21 08:51:06 +0800'>2000-01-21</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=b53c9780761bca0126e8306b0772cabef72e3d03'>Remove empty lines in PLIST and fix WWW syntax</a></td><td>Chris Piazza</td><td><span title='2000-01-20 08:22:47 +0800'>2000-01-20</span></td><td>3</td><td><span class='deletions'>-3</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=209c3691634f58119ea21345637e2f016419964d'>Use byacc instead of bison.</a></td><td>Satoshi Asami</td><td><span title='2000-01-20 02:04:36 +0800'>2000-01-20</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+9</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=9039bedd890cfbaaa2eca53c721fb6aa76050001'>* Resolve conflict between the port's 'clock' variable and -current's</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-19 21:28:26 +0800'>2000-01-19</span></td><td>2</td><td><span class='deletions'>-1</span>/<span class='insertions'>+108</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=7352f59965c9503ad78bd3ecac97233997a2fa29'>Upgrade to 3.20.</a></td><td>Thomas Gellekum</td><td><span title='2000-01-19 18:43:07 +0800'>2000-01-19</span></td><td>3</td><td><span class='deletions'>-5</span>/<span class='insertions'>+197</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=5fc7ae9e5e2eec351a0370f7651bcddc368d22c6'>Don't include bsd.port.pre.mk twice.</a></td><td>Satoshi Asami</td><td><span title='2000-01-17 20:05:19 +0800'>2000-01-17</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=913a8a7ca35a532d235b6da28bda9de16e27b434'>Update to version 1.4.7</a></td><td>Jim Mock</td><td><span title='2000-01-15 08:55:06 +0800'>2000-01-15</span></td><td>4</td><td><span class='deletions'>-47</span>/<span class='insertions'>+28</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=62ba44547e273757953b1892c3b962a85cf0528f'>Activate QuakeForge.</a></td><td>Brian Feldman</td><td><span title='2000-01-12 13:49:38 +0800'>2000-01-12</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=05df27301600e96d434ff17f2413f81a6a5b9b18'>This is a port of the iD GPLd Quake source code release.  It supports</a></td><td>Brian Feldman</td><td><span title='2000-01-12 13:47:13 +0800'>2000-01-12</span></td><td>6</td><td><span class='deletions'>-0</span>/<span class='insertions'>+720</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=4a5c9bf38c83b893a7ce6c2cff01992ec9173ddc'>Upgrade to 17.6.</a></td><td>Matthew Hunt</td><td><span title='2000-01-12 08:00:27 +0800'>2000-01-12</span></td><td>2</td><td><span class='deletions'>-5</span>/<span class='insertions'>+5</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=75c35020bdf8bfeeddf9f5bdb2cef972185d9bee'>USE_XLIB and depend on libGL.. duh</a></td><td>Chris Piazza</td><td><span title='2000-01-09 18:00:46 +0800'>2000-01-09</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+3</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=674e46d35e2ec003d32af0f58a4afde5f546db83'>Unbreak for newgcc</a></td><td>Chris Piazza</td><td><span title='2000-01-09 17:53:13 +0800'>2000-01-09</span></td><td>4</td><td><span class='deletions'>-0</span>/<span class='insertions'>+41</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=f3bb51fe149eb4dcba2ba68188f04ab091eeaaf3'>Depends on Xpm.4</a></td><td>Chris Piazza</td><td><span title='2000-01-09 17:46:20 +0800'>2000-01-09</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+2</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=2406dbb80b9720c6eb50bd64cb3352d9dc222bc1'>Unbreak for newgcc</a></td><td>Chris Piazza</td><td><span title='2000-01-09 17:19:54 +0800'>2000-01-09</span></td><td>5</td><td><span class='deletions'>-0</span>/<span class='insertions'>+64</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=86fdc9cadaa5fbf26dfc0f4cd341319b915f4c5b'>Fix for new compiler and respect CC/CXX/CXXFLAGS/CFLAGS</a></td><td>Chris Piazza</td><td><span title='2000-01-09 16:01:00 +0800'>2000-01-09</span></td><td>3</td><td><span class='deletions'>-9</span>/<span class='insertions'>+57</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=c7a3be66fa14b8523b6d9e349a1a4865f39a7639'>Update to 4.0.5</a></td><td>Ade Lovett</td><td><span title='2000-01-08 09:39:41 +0800'>2000-01-08</span></td><td>2</td><td><span class='deletions'>-4</span>/<span class='insertions'>+4</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=6b0ea0d8a6c1d3de4789bd3074a4f9b6c08195c2'>Change MAINTAINER address from nacai@iname.com</a></td><td>Yukihiro Nakai</td><td><span title='2000-01-07 10:27:48 +0800'>2000-01-07</span></td><td>15</td><td><span class='deletions'>-15</span>/<span class='insertions'>+15</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=a6844f7b83f896de2505c830c8bb90b677dd75c7'>Change MAINTAINER to ade@FreeBSD.org .</a></td><td>Yukihiro Nakai</td><td><span title='2000-01-07 10:07:00 +0800'>2000-01-07</span></td><td>3</td><td><span class='deletions'>-3</span>/<span class='insertions'>+3</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=309fba0a61e248aa2eefa43bd89e3a68c36674ae'>Update port to 1.4.0</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-07 03:59:01 +0800'>2000-01-07</span></td><td>7</td><td><span class='deletions'>-1004</span>/<span class='insertions'>+1182</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=6bca316376bbb3fe7d546e8ae228674f66869fda'>Update to version 3.2.3</a></td><td>Chris Piazza</td><td><span title='2000-01-05 11:06:12 +0800'>2000-01-05</span></td><td>16</td><td><span class='deletions'>-16</span>/<span class='insertions'>+64</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=deeae26872d58d967053d044746c081779e58263'>Add rubix port.</a></td><td>Chris Piazza</td><td><span title='2000-01-04 04:17:40 +0800'>2000-01-04</span></td><td>10</td><td><span class='deletions'>-0</span>/<span class='insertions'>+163</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=fc772f9f8930debf8e42cd471dcba675b6e7e820'>Really add xoj back to head.  (The previous one went to the vendor branch....)</a></td><td>Satoshi Asami</td><td><span title='2000-01-03 17:45:37 +0800'>2000-01-03</span></td><td>7</td><td><span class='deletions'>-0</span>/<span class='insertions'>+57</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=2467e277b43d6f82ec413bee2deaa828afb61311'>Activate gno3dtet</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-02 22:24:54 +0800'>2000-01-02</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=0ac9b9ea6207554c8d85221f773b48f1194fc726'>Gno3DTet is a funky 3D-ified version of T*tris for GNOME</a></td><td>Chris D. Faulhaber</td><td><span title='2000-01-02 22:23:42 +0800'>2000-01-02</span></td><td>6</td><td><span class='deletions'>-0</span>/<span class='insertions'>+61</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=7c74ea6870809f789b2e7f4fa0cf32c9f2a4334c'>Don't divide by zero when starting with no wins/losses.</a></td><td>Warner Losh</td><td><span title='1999-12-29 08:46:46 +0800'>1999-12-29</span></td><td>1</td><td><span class='deletions'>-0</span>/<span class='insertions'>+16</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=8cd82c0318f4118d539fed1d18d8efe346274688'>General comment cleanups.</a></td><td>Tim Vanderhoek</td><td><span title='1999-12-29 00:30:10 +0800'>1999-12-29</span></td><td>4</td><td><span class='deletions'>-4</span>/<span class='insertions'>+4</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=ebb17dd591ff424d5afc6d18bf4bea2f62059c58'>Correct NEWGCC requirement (NEW_GCC -&gt; USE_NEWGCC)</a></td><td>Chris D. Faulhaber</td><td><span title='1999-12-28 20:29:02 +0800'>1999-12-28</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=a85ec5feb60797b7ab8c7281b4a1808c84643c11'>Update port to 0.1.4</a></td><td>Chris D. Faulhaber</td><td><span title='1999-12-28 07:15:21 +0800'>1999-12-28</span></td><td>7</td><td><span class='deletions'>-15</span>/<span class='insertions'>+43</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=f9effde49490f0e6cc5bfdec71f56b1b6c974e0c'>Add http:// to WWW. It's possible to reach this site</a></td><td>Alexey Zelkin</td><td><span title='1999-12-27 23:17:50 +0800'>1999-12-27</span></td><td>1</td><td><span class='deletions'>-1</span>/<span class='insertions'>+1</span></td></tr>
<tr><td class='commitgraph'>* </td><td><a href='/~lantw44/cgit/freebsd-ports/commit/games?id=419d22e7d79dc4dfc997da0fa8013891c9119adc'>Master site has changed.</a></td><td>Munechika SUMIKAWA</td><td><span title='1999-12-27 13:22:54 +0800'>1999-12-27</span>