dexon-solidity - DEXON fork of Solidity (https://github.com/dexon-foundation/dsolidity)

diff options

Diffstat (limited to 'libsolidity/parsing/Parser.cpp')

-rw-r--r--

1 files changed, 2 insertions, 26 deletions

/* 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/>. */ /** * @author Christian <c@ethdev.com> * @author Gav Wood <g@ethdev.com> * @date 2014 * Full-stack compiler that converts a source code string to bytecode. */ #include <libsolidity/interface/CompilerStack.h> #include <libsolidity/interface/Version.h> #include <libsolidity/analysis/SemVerHandler.h> #include <libsolidity/ast/AST.h> #include <libsolidity/parsing/Scanner.h> #include <libsolidity/parsing/Parser.h> #include <libsolidity/analysis/GlobalContext.h> #include <libsolidity/analysis/NameAndTypeResolver.h> #include <libsolidity/analysis/TypeChecker.h> #include <libsolidity/analysis/DocStringAnalyser.h> #include <libsolidity/analysis/StaticAnalyzer.h> #include <libsolidity/analysis/PostTypeChecker.h> #include <libsolidity/analysis/SyntaxChecker.h> #include <libsolidity/codegen/Compiler.h> #include <libsolidity/formal/SMTChecker.h> #include <libsolidity/interface/ABI.h> #include <libsolidity/interface/Natspec.h> #include <libsolidity/interface/GasEstimator.h> #include <libevmasm/Exceptions.h> #include <libdevcore/SwarmHash.h> #include <libdevcore/JSON.h> #include <json/json.h> #include <boost/algorithm/string.hpp> using namespace std; using namespace dev; using namespace dev::solidity; void CompilerStack::setRemappings(vector<string> const& _remappings) { vector<Remapping> remappings; for (auto const& remapping: _remappings) { auto eq = find(remapping.begin(), remapping.end(), '='); if (eq == remapping.end()) continue; // ignore auto colon = find(remapping.begin(), eq, ':'); Remapping r; r.context = colon == eq ? string() : string(remapping.begin(), colon); r.prefix = colon == eq ? string(remapping.begin(), eq) : string(colon + 1, eq); r.target = string(eq + 1, remapping.end()); remappings.push_back(r); } swap(m_remappings, remappings); } void CompilerStack::reset(bool _keepSources) { if (_keepSources) { m_stackState = SourcesSet; for (auto sourcePair: m_sources) sourcePair.second.reset(); } else { m_stackState = Empty; m_sources.clear(); } m_libraries.clear(); m_optimize = false; m_optimizeRuns = 200; m_globalContext.reset(); m_scopes.clear(); m_sourceOrder.clear(); m_contracts.clear(); m_errorReporter.clear(); } bool CompilerStack::addSource(string const& _name, string const& _content, bool _isLibrary) { bool existed = m_sources.count(_name) != 0; reset(true); m_sources[_name].scanner = make_shared<Scanner>(CharStream(_content), _name); m_sources[_name].isLibrary = _isLibrary; m_stackState = SourcesSet; return existed; } bool CompilerStack::parse() { //reset if(m_stackState != SourcesSet) return false; m_errorReporter.clear(); ASTNode::resetID(); if (SemVerVersion{string(VersionString)}.isPrerelease()) m_errorReporter.warning("This is a pre-release compiler version, please do not use it in production."); vector<string> sourcesToParse; for (auto const& s: m_sources) sourcesToParse.push_back(s.first); for (size_t i = 0; i < sourcesToParse.size(); ++i) { string const& path = sourcesToParse[i]; Source& source = m_sources[path]; source.scanner->reset(); source.ast = Parser(m_errorReporter).parse(source.scanner); if (!source.ast) solAssert(!Error::containsOnlyWarnings(m_errorReporter.errors()), "Parser returned null but did not report error."); else { source.ast->annotation().path = path; for (auto const& newSource: loadMissingSources(*source.ast, path)) { string const& newPath = newSource.first; string const& newContents = newSource.second; m_sources[newPath].scanner = make_shared<Scanner>(CharStream(newContents), newPath); sourcesToParse.push_back(newPath); } } } if (Error::containsOnlyWarnings(m_errorReporter.errors())) { m_stackState = ParsingSuccessful; return true; } else return false; } bool CompilerStack::analyze() { if (m_stackState != ParsingSuccessful) return false; resolveImports(); bool noErrors = true; SyntaxChecker syntaxChecker(m_errorReporter); for (Source const* source: m_sourceOrder) if (!syntaxChecker.checkSyntax(*source->ast)) noErrors = false; DocStringAnalyser docStringAnalyser(m_errorReporter); for (Source const* source: m_sourceOrder) if (!docStringAnalyser.analyseDocStrings(*source->ast)) noErrors = false; m_globalContext = make_shared<GlobalContext>(); NameAndTypeResolver resolver(m_globalContext->declarations(), m_scopes, m_errorReporter); for (Source const* source: m_sourceOrder) if (!resolver.registerDeclarations(*source->ast)) return false; map<string, SourceUnit const*> sourceUnitsByName; for (auto& source: m_sources) sourceUnitsByName[source.first] = source.second.ast.get(); for (Source const* source: m_sourceOrder) if (!resolver.performImports(*source->ast, sourceUnitsByName)) return false; for (Source const* source: m_sourceOrder) for (ASTPointer<ASTNode> const& node: source->ast->nodes()) if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get())) { m_globalContext->setCurrentContract(*contract); if (!resolver.updateDeclaration(*m_globalContext->currentThis())) return false; if (!resolver.updateDeclaration(*m_globalContext->currentSuper())) return false; if (!resolver.resolveNamesAndTypes(*contract)) return false; contract->setDevDocumentation(Natspec::devDocumentation(*contract)); contract->setUserDocumentation(Natspec::userDocumentation(*contract)); // Note that we now reference contracts by their fully qualified names, and // thus contracts can only conflict if declared in the same source file. This // already causes a double-declaration error elsewhere, so we do not report // an error here and instead silently drop any additional contracts we find. if (m_contracts.find(contract->fullyQualifiedName()) == m_contracts.end()) m_contracts[contract->fullyQualifiedName()].contract = contract; } TypeChecker typeChecker(m_errorReporter); for (Source const* source: m_sourceOrder) for (ASTPointer<ASTNode> const& node: source->ast->nodes()) if (ContractDefinition* contract = dynamic_cast<ContractDefinition*>(node.get())) if (!typeChecker.checkTypeRequirements(*contract)) noErrors = false; if (noErrors) { PostTypeChecker postTypeChecker(m_errorReporter); for (Source const* source: m_sourceOrder) if (!postTypeChecker.check(*source->ast)) noErrors = false; } if (noErrors) { StaticAnalyzer staticAnalyzer(m_errorReporter); for (Source const* source: m_sourceOrder) if (!staticAnalyzer.analyze(*source->ast)) noErrors = false; } if (noErrors) { SMTChecker smtChecker(m_errorReporter, m_smtQuery); for (Source const* source: m_sourceOrder) smtChecker.analyze(*source->ast); } if (noErrors) { m_stackState = AnalysisSuccessful; return true; } else return false; } bool CompilerStack::parseAndAnalyze() { return parse() && analyze(); } bool CompilerStack::compile() { if (m_stackState < AnalysisSuccessful) if (!parseAndAnalyze()) return false; map<ContractDefinition const*, eth::Assembly const*> compiledContracts; for (Source const* source: m_sourceOrder) for (ASTPointer<ASTNode> const& node: source->ast->nodes()) if (auto contract = dynamic_cast<ContractDefinition const*>(node.get())) compileContract(*contract, compiledContracts); this->link(); m_stackState = CompilationSuccessful; return true; } void CompilerStack::link() { for (auto& contract: m_contracts) { contract.second.object.link(m_libraries); contract.second.runtimeObject.link(m_libraries); contract.second.cloneObject.link(m_libraries); } } vector<string> CompilerStack::contractNames() const { if (m_stackState < AnalysisSuccessful) BOOST_THROW_EXCEPTION(CompilerError() << errinfo_comment("Parsing was not successful.")); vector<string> contractNames; for (auto const& contract: m_contracts) contractNames.push_back(contract.first); return contractNames; } eth::AssemblyItems const* CompilerStack::assemblyItems(string const& _contractName) const { Contract const& currentContract = contract(_contractName); return currentContract.compiler ? &contract(_contractName).compiler->assemblyItems() : nullptr; } eth::AssemblyItems const* CompilerStack::runtimeAssemblyItems(string const& _contractName) const { Contract const& currentContract = contract(_contractName); return currentContract.compiler ? &contract(_contractName).compiler->runtimeAssemblyItems() : nullptr; } string const* CompilerStack::sourceMapping(string const& _contractName) const { Contract const& c = contract(_contractName); if (!c.sourceMapping) { if (auto items = assemblyItems(_contractName)) c.sourceMapping.reset(new string(computeSourceMapping(*items))); } return c.sourceMapping.get(); } string const* CompilerStack::runtimeSourceMapping(string const& _contractName) const { Contract const& c = contract(_contractName); if (!c.runtimeSourceMapping) { if (auto items = runtimeAssemblyItems(_contractName)) c.runtimeSourceMapping.reset(new string(computeSourceMapping(*items))); } return c.runtimeSourceMapping.get(); } std::string const CompilerStack::filesystemFriendlyName(string const& _contractName) const { // Look up the contract (by its fully-qualified name) Contract const& matchContract = m_contracts.at(_contractName); // Check to see if it could collide on name for (auto const& contract: m_contracts) { if (contract.second.contract->name() == matchContract.contract->name() && contract.second.contract != matchContract.contract) { // If it does, then return its fully-qualified name, made fs-friendly std::string friendlyName = boost::algorithm::replace_all_copy(_contractName, "/", "_");


context:
space:
mode: