| /* |
| Copyright 2019 Alain Dargelas |
| |
| Licensed under the Apache License, Version 2.0 (the "License"); |
| you may not use this file except in compliance with the License. |
| You may obtain a copy of the License at |
| |
| http://www.apache.org/licenses/LICENSE-2.0 |
| |
| Unless required by applicable law or agreed to in writing, software |
| distributed under the License is distributed on an "AS IS" BASIS, |
| WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| See the License for the specific language governing permissions and |
| limitations under the License. |
| */ |
| |
| /* |
| * File: ParseFile.cpp |
| * Author: alain |
| * |
| * Created on February 24, 2017, 10:03 PM |
| */ |
| |
| #include "SymbolTable.h" |
| #include "../CommandLine/CommandLineParser.hpp" |
| #include "../ErrorReporting/ErrorContainer.h" |
| #include "CompilationUnit.h" |
| #include "PreprocessFile.h" |
| #include "CompileSourceFile.h" |
| #include "Compiler.h" |
| #include "ParseFile.h" |
| #include "AntlrParserHandler.h" |
| #include <cstdlib> |
| #include <iostream> |
| #include "antlr4-runtime.h" |
| #include "atn/ParserATNSimulator.h" |
| |
| using namespace std; |
| using namespace antlr4; |
| using namespace SURELOG; |
| |
| #include "../parser/SV3_1aLexer.h" |
| #include "../parser/SV3_1aParser.h" |
| #include "../parser/SV3_1aParserBaseListener.h" |
| #include "SV3_1aTreeShapeListener.h" |
| #include "../API/SV3_1aPythonListener.h" |
| using namespace antlr4; |
| #include "../Utils/ParseUtils.h" |
| #include "../Utils/FileUtils.h" |
| #include "../Cache/ParseCache.h" |
| #include "AntlrParserErrorListener.h" |
| #include "../Package/Precompiled.h" |
| #include "../Utils/StringUtils.h" |
| #include "../Utils/Timer.h" |
| ParseFile::ParseFile (SymbolId fileId, SymbolTable* symbolTable, ErrorContainer* errors) : |
| m_fileId (fileId), m_ppFileId(0), m_compileSourceFile(NULL), m_compilationUnit(NULL), m_library(NULL), m_antlrParserHandler(NULL), m_listener(NULL), |
| m_usingCachedVersion(false), m_keepParserHandler(false), m_fileContent(NULL), debug_AstModel(false), m_parent(NULL), m_offsetLine(0), m_symbolTable(symbolTable), m_errors(errors) { |
| debug_AstModel = true; |
| } |
| |
| ParseFile::ParseFile (SymbolId fileId, CompileSourceFile* csf, CompilationUnit* compilationUnit, Library* library, SymbolId ppFileId, bool keepParserHandler) : |
| m_fileId (fileId), m_ppFileId(ppFileId), m_compileSourceFile(csf), m_compilationUnit(compilationUnit), m_library(library), m_antlrParserHandler(NULL), m_listener(NULL), |
| m_usingCachedVersion(false), m_keepParserHandler(keepParserHandler), m_fileContent(NULL), debug_AstModel(false), m_parent(NULL), m_offsetLine(0), m_symbolTable(NULL), m_errors(NULL) { |
| debug_AstModel = m_compileSourceFile->getCommandLineParser ()->getDebugAstModel(); |
| } |
| |
| ParseFile::ParseFile(CompileSourceFile* compileSourceFile, ParseFile* parent, SymbolId chunkFileId, unsigned int offsetLine) : m_fileId (parent->m_fileId), m_ppFileId(chunkFileId), |
| m_compileSourceFile(compileSourceFile), m_compilationUnit(parent->m_compilationUnit), m_library(parent->m_library), m_antlrParserHandler(NULL), m_listener(NULL), |
| m_usingCachedVersion(false), m_keepParserHandler(parent->m_keepParserHandler), m_fileContent(parent->m_fileContent), |
| debug_AstModel(false), m_parent(parent), m_offsetLine(offsetLine), m_symbolTable(NULL), m_errors(NULL) { |
| parent->m_children.push_back(this); |
| } |
| |
| ParseFile::~ParseFile () |
| { |
| if (!m_keepParserHandler) |
| delete m_antlrParserHandler; |
| } |
| |
| SymbolTable* ParseFile::getSymbolTable() { |
| return m_symbolTable ? m_symbolTable : m_compileSourceFile->getSymbolTable(); |
| } |
| |
| ErrorContainer* ParseFile::getErrorContainer() { |
| return m_errors ? m_errors : m_compileSourceFile->getErrorContainer(); |
| } |
| |
| SymbolId ParseFile::registerSymbol(const std::string symbol) { |
| return getCompileSourceFile()->getSymbolTable()->registerSymbol(symbol); |
| } |
| |
| SymbolId ParseFile::getId(const std::string symbol) { |
| return getCompileSourceFile()->getSymbolTable()->getId(symbol); |
| } |
| |
| const std::string ParseFile::getSymbol(SymbolId id) { |
| return getCompileSourceFile()->getSymbolTable()->getSymbol(id); |
| } |
| |
| const std::string ParseFile::getFileName(unsigned int line) { |
| return getSymbol(getFileId(line)); |
| } |
| |
| void |
| ParseFile::addError (Error& error) |
| { |
| getCompileSourceFile()->getErrorContainer ()->addError (error); |
| } |
| |
| SymbolId |
| ParseFile::getFileId (unsigned int line) |
| { |
| if (!getCompileSourceFile()) |
| return m_fileId; |
| PreprocessFile* pp = getCompileSourceFile()->getPreprocessor (); |
| auto& infos = pp->getIncludeFileInfo (); |
| if (line == 0) |
| return m_fileId; |
| if (infos.size()) |
| { |
| |
| bool inRange = false; |
| unsigned int indexOpeningRange = 0; |
| for (unsigned int i =infos.size()-1; i >= 0; i--) |
| { |
| //if (!inRange) |
| // { |
| if ((line >= infos[i].m_originalLine) && (infos[i].m_type == 2)) |
| { |
| SymbolId fileId = getSymbolTable()->registerSymbol (pp->getSymbol (infos[i].m_sectionFile)); |
| return (fileId); |
| } |
| // } |
| if (infos[i].m_type == 2) |
| { |
| if (!inRange) |
| { |
| inRange = true; |
| indexOpeningRange = infos[i].m_indexOpening; |
| } |
| } |
| else |
| { |
| if (inRange) |
| { |
| if (i == indexOpeningRange) |
| inRange = false; |
| } |
| } |
| if ((line >= infos[i].m_originalLine) && (infos[i].m_type == 1) && (line < infos[infos[i].m_indexClosing].m_originalLine)) |
| { |
| SymbolId fileId = getSymbolTable()->registerSymbol (pp->getSymbol (infos[i].m_sectionFile)); |
| return (fileId); |
| } |
| if (i == 0) |
| break; |
| } |
| return m_fileId; |
| } |
| else |
| { |
| return m_fileId; |
| } |
| } |
| |
| unsigned int |
| ParseFile::getLineNb (unsigned int line) |
| { |
| if (!getCompileSourceFile()) |
| return line; |
| PreprocessFile* pp = getCompileSourceFile()->getPreprocessor (); |
| auto& infos = pp->getIncludeFileInfo (); |
| if (line == 0) |
| return 1; |
| |
| if (infos.size()) |
| { |
| |
| bool inRange = false; |
| unsigned int indexOpeningRange = 0; |
| for (unsigned int i =infos.size()-1; i >= 0; i--) |
| { |
| // if (!inRange) |
| // { |
| if ((line >= infos[i].m_originalLine) && (infos[i].m_type == 2)) |
| { |
| return (infos[i].m_sectionStartLine + (line - infos[i].m_originalLine)); |
| } |
| // } |
| if (infos[i].m_type == 2) |
| { |
| if (!inRange) |
| { |
| inRange = true; |
| indexOpeningRange = infos[i].m_indexOpening; |
| } |
| } |
| else |
| { |
| if (inRange) |
| { |
| if (i == indexOpeningRange) |
| inRange = false; |
| } |
| } |
| if ((line >= infos[i].m_originalLine) && (infos[i].m_type == 1) && (line < infos[infos[i].m_indexClosing].m_originalLine)) |
| { |
| return (infos[i].m_sectionStartLine + (line - infos[i].m_originalLine)); |
| } |
| |
| if (i == 0) |
| break; |
| } |
| return line; |
| } |
| else |
| { |
| return line; |
| } |
| } |
| |
| |
| bool ParseFile::parseOneFile_ (std::string fileName, unsigned int lineOffset) |
| { |
| Timer tmr; |
| AntlrParserHandler* antlrParserHandler = new AntlrParserHandler (); |
| m_antlrParserHandler = antlrParserHandler; |
| std::ifstream stream; |
| stream.open (fileName); |
| if (!stream.good ()) |
| { |
| SymbolId fileId = registerSymbol (fileName); |
| Location ppfile (fileId); |
| Error err (ErrorDefinition::PA_CANNOT_OPEN_FILE, ppfile); |
| addError (err); |
| return false; |
| } |
| |
| antlrParserHandler->m_inputStream = new ANTLRInputStream (stream); |
| antlrParserHandler->m_errorListener = new AntlrParserErrorListener (this, false, lineOffset, fileName); |
| antlrParserHandler->m_lexer = new SV3_1aLexer (antlrParserHandler->m_inputStream); |
| antlrParserHandler->m_lexer->removeErrorListeners (); |
| antlrParserHandler->m_lexer->addErrorListener (antlrParserHandler->m_errorListener); |
| antlrParserHandler->m_tokens = new CommonTokenStream (antlrParserHandler->m_lexer); |
| antlrParserHandler->m_tokens->fill (); |
| |
| if (getCompileSourceFile ()->getCommandLineParser ()->profile ()) |
| { |
| //m_profileInfo += "Tokenizer: " + std::to_string (tmr.elapsed_rounded ()) + " " + fileName + "\n"; |
| tmr.reset (); |
| } |
| |
| antlrParserHandler->m_parser = new SV3_1aParser (antlrParserHandler->m_tokens); |
| |
| m_antlrParserHandler->m_parser->getInterpreter<atn::ParserATNSimulator>()->setPredictionMode (atn::PredictionMode::SLL); |
| m_antlrParserHandler->m_parser->setErrorHandler (std::make_shared<BailErrorStrategy>()); |
| m_antlrParserHandler->m_parser->removeErrorListeners (); |
| |
| try |
| { |
| m_antlrParserHandler->m_tree = m_antlrParserHandler->m_parser->top_level_rule (); |
| |
| if (getCompileSourceFile()->getCommandLineParser ()->profile ()) |
| { |
| m_profileInfo += "SSL Parsing: " + StringUtils::to_string(tmr.elapsed_rounded()) + " " + fileName + "\n"; |
| tmr.reset(); |
| } |
| } |
| catch (ParseCancellationException& pex) |
| { |
| |
| m_antlrParserHandler->m_tokens->reset (); |
| m_antlrParserHandler->m_parser->reset (); |
| |
| m_antlrParserHandler->m_parser->setErrorHandler (std::make_shared<DefaultErrorStrategy>()); |
| antlrParserHandler->m_parser->removeErrorListeners (); |
| antlrParserHandler->m_parser->addErrorListener (antlrParserHandler->m_errorListener); |
| antlrParserHandler->m_parser->getInterpreter<atn::ParserATNSimulator>()->setPredictionMode (atn::PredictionMode::LL); |
| antlrParserHandler->m_tree = antlrParserHandler->m_parser->top_level_rule (); |
| |
| if (getCompileSourceFile()->getCommandLineParser ()->profile ()) |
| { |
| m_profileInfo += "LL Parsing: " + StringUtils::to_string(tmr.elapsed_rounded()) + " " + fileName + "\n"; |
| tmr.reset(); |
| } |
| |
| } |
| stream.close (); |
| return true; |
| } |
| |
| |
| std::string ParseFile::getProfileInfo() { |
| std::string profile; |
| profile = m_profileInfo; |
| for (unsigned int i = 0; i < m_children.size (); i++) |
| profile += m_children[i]->m_profileInfo; |
| |
| return profile; |
| } |
| |
| bool ParseFile::parse() { |
| |
| Precompiled* prec = Precompiled::getSingleton (); |
| std::string root = this->getPpFileName (); |
| root = StringUtils::getRootFileName (root); |
| bool precompiled = false; |
| if (prec->isFilePrecompiled (root)) |
| precompiled = true; |
| |
| |
| if (m_children.size () == 0) |
| { |
| ParseCache cache (this); |
| |
| if (cache.restore ()) |
| { |
| m_usingCachedVersion = true; |
| if (debug_AstModel && !precompiled) |
| std::cout << m_fileContent->printObjects (); |
| return true; |
| } |
| } |
| else |
| { |
| bool ok = true; |
| for (unsigned int i = 0; i < m_children.size (); i++) |
| { |
| ParseCache cache (m_children[i]); |
| |
| if (cache.restore ()) |
| { |
| m_children[i]->m_fileContent->setParent(m_fileContent); |
| m_usingCachedVersion = true; |
| if (debug_AstModel && !precompiled) |
| std::cout << m_children[i]->m_fileContent->printObjects (); |
| } |
| else |
| { |
| ok = false; |
| } |
| |
| } |
| if (ok) |
| { |
| return true; |
| } |
| } |
| |
| // This is not a parent Parser object |
| if (m_children.size() == 0) |
| { |
| //std::cout << std::endl << "Parsing " << getSymbol(m_ppFileId) << " Line: " << m_offsetLine << std::endl << std::flush; |
| |
| parseOneFile_(getSymbol(m_ppFileId), m_offsetLine); |
| |
| //m_listener = new SV3_1aTreeShapeListener (this, m_antlrParserHandler->m_tokens, m_offsetLine); |
| //tree::ParseTreeWalker::DEFAULT.walk (m_listener, m_antlrParserHandler->m_tree); |
| //std::cout << std::endl << "End Parsing " << getSymbol(m_ppFileId) << " Line: " << m_offsetLine << std::endl << std::flush; |
| |
| } |
| |
| |
| // This is either a parent Parser object of this Parser object has no parent |
| if ((m_children.size () != 0) || (m_parent == NULL)) |
| { |
| |
| if ((m_parent == NULL) && (m_children.size () == 0)) |
| { |
| Timer tmr; |
| |
| m_listener = new SV3_1aTreeShapeListener (this, m_antlrParserHandler->m_tokens, m_offsetLine); |
| tree::ParseTreeWalker::DEFAULT.walk (m_listener, m_antlrParserHandler->m_tree); |
| |
| if (debug_AstModel && !precompiled) |
| std::cout << m_fileContent->printObjects (); |
| |
| if (getCompileSourceFile ()->getCommandLineParser ()->profile ()) |
| { |
| //m_profileInfo += "AST Walking: " + std::to_string (tmr.elapsed_rounded ()) + "\n"; |
| tmr.reset (); |
| } |
| |
| ParseCache cache (this); |
| if (!cache.save ()) |
| { |
| return false; |
| } |
| |
| } |
| |
| if (m_children.size () != 0) |
| { |
| |
| for (unsigned int i = 0; i < m_children.size (); i++) |
| { |
| if (m_children[i]->m_antlrParserHandler) |
| { |
| // Only visit the chunks that got re-parsed |
| // TODO: Incrementally regenerate the FileContent |
| m_children[i]->m_fileContent->setParent(m_fileContent); |
| m_children[i]->m_listener = new SV3_1aTreeShapeListener (m_children[i], m_children[i]->m_antlrParserHandler->m_tokens, |
| m_children[i]->m_offsetLine); |
| |
| Timer tmr; |
| tree::ParseTreeWalker::DEFAULT.walk (m_children[i]->m_listener, m_children[i]->m_antlrParserHandler->m_tree); |
| |
| if (getCompileSourceFile ()->getCommandLineParser ()->profile ()) |
| { |
| //m_profileInfo += "For file " + getSymbol (m_children[i]->m_ppFileId) + ", AST Walking took" + std::to_string (tmr.elapsed_rounded ()) + "\n"; |
| tmr.reset (); |
| } |
| |
| if (debug_AstModel && !precompiled) |
| std::cout << m_children[i]->m_fileContent->printObjects (); |
| |
| ParseCache cache (m_children[i]); |
| if (!cache.save ()) |
| { |
| return false; |
| } |
| |
| } |
| } |
| |
| } |
| } |
| return true; |
| } |
| |
| |
| |
