solidity/libsolidity/analysis/NameAndTypeResolver.cpp

643 lines
19 KiB
C++
Raw Normal View History

2014-10-13 15:13:48 +00:00
/*
2014-10-16 12:08:54 +00:00
This file is part of cpp-ethereum.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
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.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
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.
2014-10-13 15:13:48 +00:00
2014-10-16 12:08:54 +00:00
You should have received a copy of the GNU General Public License
along with cpp-ethereum. If not, see <http://www.gnu.org/licenses/>.
2014-10-13 15:13:48 +00:00
*/
/**
* @author Christian <c@ethdev.com>
* @date 2014
* Parser part that determines the declarations corresponding to names and the types of expressions.
*/
2015-10-20 22:21:52 +00:00
#include <libsolidity/analysis/NameAndTypeResolver.h>
#include <libsolidity/ast/AST.h>
#include <libsolidity/analysis/TypeChecker.h>
#include <libsolidity/interface/Exceptions.h>
2014-10-13 13:07:21 +00:00
2014-10-24 17:06:30 +00:00
using namespace std;
2014-10-16 12:08:54 +00:00
namespace dev
{
namespace solidity
{
2014-10-13 13:07:21 +00:00
NameAndTypeResolver::NameAndTypeResolver(
vector<Declaration const*> const& _globals,
ErrorList& _errors
) :
m_errors(_errors)
{
2015-12-05 02:09:47 +00:00
if (!m_scopes[nullptr])
m_scopes[nullptr].reset(new DeclarationContainer());
2014-12-06 01:32:51 +00:00
for (Declaration const* declaration: _globals)
m_scopes[nullptr]->registerDeclaration(*declaration);
}
bool NameAndTypeResolver::registerDeclarations(SourceUnit& _sourceUnit)
{
2015-12-15 14:46:03 +00:00
if (!m_scopes[&_sourceUnit])
// By importing, it is possible that the container already exists.
m_scopes[&_sourceUnit].reset(new DeclarationContainer(nullptr, m_scopes[nullptr].get()));
2015-12-05 02:09:47 +00:00
m_currentScope = m_scopes[&_sourceUnit].get();
// The helper registers all declarations in m_scopes as a side-effect of its construction.
try
{
DeclarationRegistrationHelper registrar(m_scopes, _sourceUnit, m_errors);
2015-12-15 14:46:03 +00:00
_sourceUnit.annotation().exportedSymbols = m_scopes[&_sourceUnit]->declarations();
}
2015-11-26 13:47:28 +00:00
catch (FatalError const&)
{
if (m_errors.empty())
throw; // Something is weird here, rather throw again.
return false;
}
return true;
}
2015-12-05 02:09:47 +00:00
bool NameAndTypeResolver::performImports(SourceUnit& _sourceUnit, map<string, SourceUnit const*> const& _sourceUnits)
{
DeclarationContainer& target = *m_scopes.at(&_sourceUnit);
bool error = false;
for (auto const& node: _sourceUnit.nodes())
if (auto imp = dynamic_cast<ImportDirective const*>(node.get()))
{
2015-12-09 16:35:20 +00:00
string const& path = imp->annotation().absolutePath;
if (!_sourceUnits.count(path))
2015-12-05 02:09:47 +00:00
{
2016-01-11 12:55:58 +00:00
reportDeclarationError(
imp->location(),
"Import \"" + path + "\" (referenced as \"" + imp->path() + "\") not found."
2015-12-09 16:35:20 +00:00
);
2015-12-05 02:09:47 +00:00
error = true;
2016-01-11 12:55:58 +00:00
continue;
2015-12-05 02:09:47 +00:00
}
2016-01-11 12:55:58 +00:00
auto scope = m_scopes.find(_sourceUnits.at(path));
solAssert(scope != end(m_scopes), "");
if (!imp->symbolAliases().empty())
for (auto const& alias: imp->symbolAliases())
{
auto declarations = scope->second->resolveName(alias.first->name(), false);
if (declarations.empty())
{
reportDeclarationError(
imp->location(),
"Declaration \"" +
alias.first->name() +
"\" not found in \"" +
path +
"\" (referenced as \"" +
imp->path() +
"\")."
);
error = true;
}
else
for (Declaration const* declaration: declarations)
{
ASTString const* name = alias.second ? alias.second.get() : &declaration->name();
if (!target.registerDeclaration(*declaration, name))
{
reportDeclarationError(
imp->location(),
"Identifier \"" + *name + "\" already declared."
);
error = true;
}
}
}
2015-12-15 14:46:03 +00:00
else if (imp->name().empty())
2015-12-05 02:09:47 +00:00
for (auto const& nameAndDeclaration: scope->second->declarations())
for (auto const& declaration: nameAndDeclaration.second)
2016-01-11 12:55:58 +00:00
if (!target.registerDeclaration(*declaration, &nameAndDeclaration.first))
{
reportDeclarationError(
imp->location(),
"Identifier \"" + nameAndDeclaration.first + "\" already declared."
);
error = true;
}
2015-12-05 02:09:47 +00:00
}
return !error;
}
bool NameAndTypeResolver::resolveNamesAndTypes(ContractDefinition& _contract)
2014-10-13 13:07:21 +00:00
{
try
{
2015-12-05 02:09:47 +00:00
m_currentScope = m_scopes[_contract.scope()].get();
solAssert(!!m_currentScope, "");
2015-11-19 17:02:04 +00:00
ReferencesResolver resolver(m_errors, *this, nullptr);
bool success = true;
for (ASTPointer<InheritanceSpecifier> const& baseContract: _contract.baseContracts())
if (!resolver.resolve(*baseContract))
success = false;
m_currentScope = m_scopes[&_contract].get();
if (success)
2015-10-26 16:31:35 +00:00
{
linearizeBaseContracts(_contract);
2015-12-14 17:01:40 +00:00
vector<ContractDefinition const*> properBases(
2015-10-26 16:31:35 +00:00
++_contract.annotation().linearizedBaseContracts.begin(),
_contract.annotation().linearizedBaseContracts.end()
);
for (ContractDefinition const* base: properBases)
importInheritedScope(*base);
}
// these can contain code, only resolve parameters for now
for (ASTPointer<ASTNode> const& node: _contract.subNodes())
{
m_currentScope = m_scopes[m_scopes.count(node.get()) ? node.get() : &_contract].get();
if (!resolver.resolve(*node))
success = false;
}
2015-11-06 16:22:46 +00:00
if (!success)
return false;
m_currentScope = m_scopes[&_contract].get();
// now resolve references inside the code
for (ModifierDefinition const* modifier: _contract.functionModifiers())
{
m_currentScope = m_scopes[modifier].get();
2015-11-19 17:02:04 +00:00
ReferencesResolver resolver(m_errors, *this, nullptr, true);
if (!resolver.resolve(*modifier))
success = false;
}
2015-11-06 16:22:46 +00:00
for (FunctionDefinition const* function: _contract.definedFunctions())
{
m_currentScope = m_scopes[function].get();
2015-11-06 19:56:14 +00:00
if (!ReferencesResolver(
2015-10-27 12:16:33 +00:00
m_errors,
*this,
function->returnParameterList().get(),
true
2015-11-06 16:22:46 +00:00
).resolve(*function))
success = false;
}
2015-11-04 13:49:54 +00:00
if (!success)
return false;
}
2015-11-26 13:47:28 +00:00
catch (FatalError const&)
{
2015-11-04 13:49:54 +00:00
if (m_errors.empty())
throw; // Something is weird here, rather throw again.
return false;
}
return true;
2014-10-13 13:07:21 +00:00
}
bool NameAndTypeResolver::updateDeclaration(Declaration const& _declaration)
{
try
{
2015-12-05 02:09:47 +00:00
m_scopes[nullptr]->registerDeclaration(_declaration, nullptr, false, true);
solAssert(_declaration.scope() == nullptr, "Updated declaration outside global scope.");
}
2015-11-26 13:47:28 +00:00
catch (FatalError const&)
{
if (m_errors.empty())
throw; // Something is weird here, rather throw again.
return false;
}
return true;
}
2015-12-05 02:09:47 +00:00
vector<Declaration const*> NameAndTypeResolver::resolveName(ASTString const& _name, ASTNode const* _scope) const
2014-10-13 13:07:21 +00:00
{
auto iterator = m_scopes.find(_scope);
if (iterator == end(m_scopes))
return vector<Declaration const*>({});
return iterator->second->resolveName(_name, false);
2014-10-13 13:07:21 +00:00
}
2015-10-06 12:43:09 +00:00
vector<Declaration const*> NameAndTypeResolver::nameFromCurrentScope(ASTString const& _name, bool _recursive) const
2014-10-13 13:07:21 +00:00
{
return m_currentScope->resolveName(_name, _recursive);
}
2015-10-06 12:43:09 +00:00
Declaration const* NameAndTypeResolver::pathFromCurrentScope(vector<ASTString> const& _path, bool _recursive) const
2015-10-06 10:35:10 +00:00
{
solAssert(!_path.empty(), "");
vector<Declaration const*> candidates = m_currentScope->resolveName(_path.front(), _recursive);
for (size_t i = 1; i < _path.size() && candidates.size() == 1; i++)
{
if (!m_scopes.count(candidates.front()))
return nullptr;
candidates = m_scopes.at(candidates.front())->resolveName(_path[i], false);
2015-10-06 10:35:10 +00:00
}
if (candidates.size() == 1)
return candidates.front();
else
return nullptr;
}
2015-05-08 14:07:25 +00:00
vector<Declaration const*> NameAndTypeResolver::cleanedDeclarations(
2015-05-07 16:12:58 +00:00
Identifier const& _identifier,
vector<Declaration const*> const& _declarations
)
{
2015-05-08 14:07:25 +00:00
solAssert(_declarations.size() > 1, "");
vector<Declaration const*> uniqueFunctions;
2015-05-07 16:12:58 +00:00
for (auto it = _declarations.begin(); it != _declarations.end(); ++it)
{
solAssert(*it, "");
// the declaration is functionDefinition while declarations > 1
FunctionDefinition const& functionDefinition = dynamic_cast<FunctionDefinition const&>(**it);
FunctionType functionType(functionDefinition);
2015-08-31 16:44:29 +00:00
for (auto parameter: functionType.parameterTypes() + functionType.returnParameterTypes())
if (!parameter)
reportFatalDeclarationError(_identifier.location(), "Function type can not be used in this context");
if (uniqueFunctions.end() == find_if(
uniqueFunctions.begin(),
uniqueFunctions.end(),
[&](Declaration const* d)
{
2015-05-08 14:07:25 +00:00
FunctionType newFunctionType(dynamic_cast<FunctionDefinition const&>(*d));
return functionType.hasEqualArgumentTypes(newFunctionType);
}
))
uniqueFunctions.push_back(*it);
}
return uniqueFunctions;
}
void NameAndTypeResolver::importInheritedScope(ContractDefinition const& _base)
{
auto iterator = m_scopes.find(&_base);
solAssert(iterator != end(m_scopes), "");
for (auto const& nameAndDeclaration: iterator->second->declarations())
2015-03-01 03:34:39 +00:00
for (auto const& declaration: nameAndDeclaration.second)
// Import if it was declared in the base, is not the constructor and is visible in derived classes
2015-08-31 16:44:29 +00:00
if (declaration->scope() == &_base && declaration->isVisibleInDerivedContracts())
2015-03-01 03:34:39 +00:00
m_currentScope->registerDeclaration(*declaration);
}
void NameAndTypeResolver::linearizeBaseContracts(ContractDefinition& _contract)
{
// order in the lists is from derived to base
// list of lists to linearize, the last element is the list of direct bases
list<list<ContractDefinition const*>> input(1, list<ContractDefinition const*>{});
2015-08-31 16:44:29 +00:00
for (ASTPointer<InheritanceSpecifier> const& baseSpecifier: _contract.baseContracts())
{
UserDefinedTypeName const& baseName = baseSpecifier->name();
auto base = dynamic_cast<ContractDefinition const*>(baseName.annotation().referencedDeclaration);
if (!base)
reportFatalTypeError(baseName.createTypeError("Contract expected."));
// "push_front" has the effect that bases mentioned later can overwrite members of bases
// mentioned earlier
input.back().push_front(base);
vector<ContractDefinition const*> const& basesBases = base->annotation().linearizedBaseContracts;
if (basesBases.empty())
reportFatalTypeError(baseName.createTypeError("Definition of base has to precede definition of derived contract"));
input.push_front(list<ContractDefinition const*>(basesBases.begin(), basesBases.end()));
}
input.back().push_front(&_contract);
vector<ContractDefinition const*> result = cThreeMerge(input);
if (result.empty())
reportFatalTypeError(_contract.createTypeError("Linearization of inheritance graph impossible"));
_contract.annotation().linearizedBaseContracts = result;
2015-10-07 13:57:17 +00:00
_contract.annotation().contractDependencies.insert(result.begin() + 1, result.end());
}
template <class _T>
vector<_T const*> NameAndTypeResolver::cThreeMerge(list<list<_T const*>>& _toMerge)
{
// returns true iff _candidate appears only as last element of the lists
auto appearsOnlyAtHead = [&](_T const* _candidate) -> bool
{
for (list<_T const*> const& bases: _toMerge)
{
solAssert(!bases.empty(), "");
if (find(++bases.begin(), bases.end(), _candidate) != bases.end())
return false;
}
return true;
};
// returns the next candidate to append to the linearized list or nullptr on failure
auto nextCandidate = [&]() -> _T const*
{
for (list<_T const*> const& bases: _toMerge)
{
solAssert(!bases.empty(), "");
if (appearsOnlyAtHead(bases.front()))
return bases.front();
}
return nullptr;
};
// removes the given contract from all lists
auto removeCandidate = [&](_T const* _candidate)
{
for (auto it = _toMerge.begin(); it != _toMerge.end();)
{
it->remove(_candidate);
if (it->empty())
it = _toMerge.erase(it);
else
++it;
}
};
_toMerge.remove_if([](list<_T const*> const& _bases) { return _bases.empty(); });
vector<_T const*> result;
while (!_toMerge.empty())
{
_T const* candidate = nextCandidate();
if (!candidate)
return vector<_T const*>();
result.push_back(candidate);
removeCandidate(candidate);
}
return result;
}
void NameAndTypeResolver::reportDeclarationError(
SourceLocation _sourceLoction,
string const& _description,
2015-10-15 14:08:02 +00:00
SourceLocation _secondarySourceLocation,
string const& _secondaryDescription
)
{
auto err = make_shared<Error>(Error::Type::DeclarationError); // todo remove Error?
*err <<
2015-10-15 14:08:02 +00:00
errinfo_sourceLocation(_sourceLoction) <<
errinfo_comment(_description) <<
errinfo_secondarySourceLocation(
SecondarySourceLocation().append(_secondaryDescription, _secondarySourceLocation)
);
m_errors.push_back(err);
}
2015-10-15 14:13:52 +00:00
void NameAndTypeResolver::reportDeclarationError(SourceLocation _sourceLocation, string const& _description)
2015-10-15 14:08:02 +00:00
{
auto err = make_shared<Error>(Error::Type::DeclarationError); // todo remove Error?
2015-10-15 14:13:52 +00:00
*err << errinfo_sourceLocation(_sourceLocation) << errinfo_comment(_description);
m_errors.push_back(err);
}
void NameAndTypeResolver::reportFatalDeclarationError(
2015-10-15 14:13:52 +00:00
SourceLocation _sourceLocation,
string const& _description
)
{
2015-10-15 14:13:52 +00:00
reportDeclarationError(_sourceLocation, _description);
2015-10-15 12:36:23 +00:00
BOOST_THROW_EXCEPTION(FatalError());
}
2015-10-15 14:51:01 +00:00
void NameAndTypeResolver::reportTypeError(Error const& _e)
{
m_errors.push_back(make_shared<Error>(_e));
}
2015-10-15 14:51:01 +00:00
void NameAndTypeResolver::reportFatalTypeError(Error const& _e)
{
reportTypeError(_e);
2015-10-15 12:36:23 +00:00
BOOST_THROW_EXCEPTION(FatalError());
}
DeclarationRegistrationHelper::DeclarationRegistrationHelper(
2015-12-15 14:46:03 +00:00
map<ASTNode const*, shared_ptr<DeclarationContainer>>& _scopes,
ASTNode& _astRoot,
ErrorList& _errors
):
m_scopes(_scopes),
2015-12-05 02:09:47 +00:00
m_currentScope(&_astRoot),
m_errors(_errors)
{
2015-12-05 02:09:47 +00:00
solAssert(!!m_scopes.at(m_currentScope), "");
_astRoot.accept(*this);
}
2015-12-15 14:46:03 +00:00
bool DeclarationRegistrationHelper::visit(ImportDirective& _import)
{
SourceUnit const* importee = _import.annotation().sourceUnit;
solAssert(!!importee, "");
if (!m_scopes[importee])
m_scopes[importee].reset(new DeclarationContainer(nullptr, m_scopes[nullptr].get()));
m_scopes[&_import] = m_scopes[importee];
registerDeclaration(_import, false);
return true;
}
bool DeclarationRegistrationHelper::visit(ContractDefinition& _contract)
{
registerDeclaration(_contract, true);
_contract.annotation().canonicalName = currentCanonicalName();
return true;
}
void DeclarationRegistrationHelper::endVisit(ContractDefinition&)
{
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(StructDefinition& _struct)
{
registerDeclaration(_struct, true);
_struct.annotation().canonicalName = currentCanonicalName();
return true;
}
void DeclarationRegistrationHelper::endVisit(StructDefinition&)
{
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(EnumDefinition& _enum)
{
registerDeclaration(_enum, true);
_enum.annotation().canonicalName = currentCanonicalName();
return true;
}
void DeclarationRegistrationHelper::endVisit(EnumDefinition&)
{
closeCurrentScope();
}
2015-02-14 02:06:50 +00:00
bool DeclarationRegistrationHelper::visit(EnumValue& _value)
{
registerDeclaration(_value, false);
return true;
}
bool DeclarationRegistrationHelper::visit(FunctionDefinition& _function)
{
registerDeclaration(_function, true);
m_currentFunction = &_function;
return true;
}
void DeclarationRegistrationHelper::endVisit(FunctionDefinition&)
{
m_currentFunction = nullptr;
closeCurrentScope();
}
bool DeclarationRegistrationHelper::visit(ModifierDefinition& _modifier)
{
registerDeclaration(_modifier, true);
m_currentFunction = &_modifier;
return true;
}
void DeclarationRegistrationHelper::endVisit(ModifierDefinition&)
{
m_currentFunction = nullptr;
closeCurrentScope();
}
void DeclarationRegistrationHelper::endVisit(VariableDeclarationStatement& _variableDeclarationStatement)
{
// Register the local variables with the function
// This does not fit here perfectly, but it saves us another AST visit.
solAssert(m_currentFunction, "Variable declaration without function.");
for (ASTPointer<VariableDeclaration> const& var: _variableDeclarationStatement.declarations())
if (var)
m_currentFunction->addLocalVariable(*var);
}
bool DeclarationRegistrationHelper::visit(VariableDeclaration& _declaration)
2014-10-13 13:07:21 +00:00
{
registerDeclaration(_declaration, false);
return true;
}
2015-01-29 13:35:28 +00:00
bool DeclarationRegistrationHelper::visit(EventDefinition& _event)
{
2015-01-31 15:50:33 +00:00
registerDeclaration(_event, true);
2015-01-29 13:35:28 +00:00
return true;
}
2015-01-31 15:50:33 +00:00
void DeclarationRegistrationHelper::endVisit(EventDefinition&)
{
closeCurrentScope();
}
2014-12-06 01:32:51 +00:00
void DeclarationRegistrationHelper::enterNewSubScope(Declaration const& _declaration)
{
2015-12-15 14:46:03 +00:00
map<ASTNode const*, shared_ptr<DeclarationContainer>>::iterator iter;
2014-10-13 13:07:21 +00:00
bool newlyAdded;
2015-12-15 14:46:03 +00:00
shared_ptr<DeclarationContainer> container(new DeclarationContainer(m_currentScope, m_scopes[m_currentScope].get()));
tie(iter, newlyAdded) = m_scopes.emplace(&_declaration, move(container));
solAssert(newlyAdded, "Unable to add new scope.");
2014-12-01 14:22:45 +00:00
m_currentScope = &_declaration;
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::closeCurrentScope()
2014-10-13 13:07:21 +00:00
{
solAssert(m_currentScope, "Closed non-existing scope.");
2015-12-05 02:09:47 +00:00
m_currentScope = m_scopes[m_currentScope]->enclosingNode();
2014-10-13 13:07:21 +00:00
}
void DeclarationRegistrationHelper::registerDeclaration(Declaration& _declaration, bool _opensScope)
{
2015-12-05 02:09:47 +00:00
if (!m_scopes[m_currentScope]->registerDeclaration(_declaration, nullptr, !_declaration.isVisibleInContract()))
{
2015-05-04 12:46:52 +00:00
SourceLocation firstDeclarationLocation;
SourceLocation secondDeclarationLocation;
Declaration const* conflictingDeclaration = m_scopes[m_currentScope]->conflictingDeclaration(_declaration);
2015-05-04 13:46:46 +00:00
solAssert(conflictingDeclaration, "");
2015-05-04 12:46:52 +00:00
2015-08-31 16:44:29 +00:00
if (_declaration.location().start < conflictingDeclaration->location().start)
2015-05-04 12:46:52 +00:00
{
2015-08-31 16:44:29 +00:00
firstDeclarationLocation = _declaration.location();
secondDeclarationLocation = conflictingDeclaration->location();
2015-05-04 12:46:52 +00:00
}
else
{
2015-08-31 16:44:29 +00:00
firstDeclarationLocation = conflictingDeclaration->location();
secondDeclarationLocation = _declaration.location();
2015-05-04 12:46:52 +00:00
}
2015-05-04 13:46:46 +00:00
declarationError(
secondDeclarationLocation,
"Identifier already declared.",
firstDeclarationLocation,
"The previous declaration is here:"
2015-05-04 15:30:28 +00:00
);
}
2014-12-01 14:22:45 +00:00
_declaration.setScope(m_currentScope);
if (_opensScope)
enterNewSubScope(_declaration);
}
string DeclarationRegistrationHelper::currentCanonicalName() const
{
string ret;
for (
2015-12-05 02:09:47 +00:00
ASTNode const* scope = m_currentScope;
scope != nullptr;
2015-12-05 02:09:47 +00:00
scope = m_scopes[scope]->enclosingNode()
)
{
2015-12-05 02:09:47 +00:00
if (auto decl = dynamic_cast<Declaration const*>(scope))
{
if (!ret.empty())
ret = "." + ret;
ret = decl->name() + ret;
}
}
return ret;
}
void DeclarationRegistrationHelper::declarationError(
2015-10-15 14:13:52 +00:00
SourceLocation _sourceLocation,
string const& _description,
2015-10-15 14:08:02 +00:00
SourceLocation _secondarySourceLocation,
string const& _secondaryDescription
)
{
auto err = make_shared<Error>(Error::Type::DeclarationError);
*err <<
2015-10-15 14:13:52 +00:00
errinfo_sourceLocation(_sourceLocation) <<
2015-10-15 14:08:02 +00:00
errinfo_comment(_description) <<
errinfo_secondarySourceLocation(
SecondarySourceLocation().append(_secondaryDescription, _secondarySourceLocation)
);
m_errors.push_back(err);
}
2015-10-15 14:13:52 +00:00
void DeclarationRegistrationHelper::declarationError(SourceLocation _sourceLocation, string const& _description)
2015-10-15 14:08:02 +00:00
{
auto err = make_shared<Error>(Error::Type::DeclarationError);
2015-10-15 14:13:52 +00:00
*err << errinfo_sourceLocation(_sourceLocation) << errinfo_comment(_description);
m_errors.push_back(err);
}
void DeclarationRegistrationHelper::fatalDeclarationError(
2015-10-15 14:13:52 +00:00
SourceLocation _sourceLocation,
string const& _description
)
{
2015-10-15 14:13:52 +00:00
declarationError(_sourceLocation, _description);
2015-10-15 12:36:23 +00:00
BOOST_THROW_EXCEPTION(FatalError());
}
2014-10-16 12:08:54 +00:00
}
}