| /* |
| 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: CommandLineParser.cpp |
| * Author: alain |
| * |
| * Created on January 26, 2017, 9:47 PM |
| */ |
| #include <string> |
| #include <iostream> |
| #include <fstream> |
| #include <string> |
| #include <sstream> |
| #include <sys/types.h> |
| #include <sys/stat.h> |
| #include "CommandLineParser.hpp" |
| #include "../Utils/StringUtils.h" |
| #include "../Utils/FileUtils.h" |
| |
| #include "antlr4-runtime.h" |
| using namespace antlr4; |
| |
| #include "../API/PythonAPI.h" |
| |
| #include <ctime> |
| #include <thread> |
| |
| using namespace SURELOG; |
| |
| std::string defaultLogFileName = "surelog.log"; |
| std::string CommandLineParser::m_versionNumber = "0.05"; |
| |
| const std::vector<std::string> copyright = { |
| "Copyright (c) 2017-2019 ACE Cloud,", |
| "Authorized used only." |
| }; |
| |
| const std::vector<std::string> banner = { |
| "********************************************", |
| "* SURELOG System Verilog Compiler/Linter *", |
| "********************************************", |
| }; |
| |
| const std::vector<std::string> footer = { |
| "********************************************", |
| "* End SURELOG SVerilog Compiler/Linter *", |
| "********************************************", |
| }; |
| |
| const std::vector<std::string> helpText = { |
| " ------------ SURELOG HELP --------------", |
| "", |
| "STANDARD VERILOG COMMAND LINE:", |
| " -f <file> Accepts a file containing command line arguments", |
| " -v <file> Library file", |
| " -y <path> Library directory", |
| " +incdir+<dir>+... Specifies include paths", |
| " -Idir Specifies include paths", |
| " +libext+<extname>+... Specifies the library extensions", |
| " <file>.v Verilog File", |
| " <file>.sv System Verilog File", |
| " +liborder Lib Order option (ignored)", |
| " +librescan Lib Rescan option (ignored)", |
| " +libverbose Lib Verbose option (ignored)", |
| " +nolibcell No Lib Cell option (ignored)", |
| " +define+macro_name=definition+...", |
| " Defines a macro and optionally its value", |
| " -L <libName> Defines library compilation order", |
| " -map <mapFile> Specifies a library mapping file (multiple -map options supported)", |
| " -cfgfile <confiFile> Specifies a configuration file (multiple -cfgFile options supported)", |
| " -cfg <configName> Specifies a configuration to use (multiple -cfg options supported)", |
| "FLOWS OPTIONS:", |
| " -fileunit Compiles each Verilog file as an independent", |
| " compilation unit (under slpp_unit/ if -writepp used)", |
| " -diffcompunit Compiles both all files as a whole unit and", |
| " separate compilation units to perform diffs", |
| " -parse Parse/Compile/Elaborate the files after pre-processing step", |
| " -nocomp Turns off Compilation & Elaboration", |
| " -noelab Turns off Elaboration", |
| " -pythonlistener Enables the Parser Python Listener", |
| " -pythonlistenerfile <script.py> Specifies the AST python listener file", |
| " -pythonevalscriptperfile <script.py> Eval the Python script on each source file (Multithreaded)", |
| " -pythonevalscript <script.py> Eval the Python script at the design level", |
| " -nopython Turns off all Python features, including waivers", |
| " -strictpythoncheck Turns on strict Python checks", |
| // " -tbb Enables the Intel TBB Multithread library", |
| " -mt <nb_max_treads> 0 up to 512 max threads, 0 or 1 being single threaded,", |
| " if \"max\" is given, the program will use one thread", |
| " per core on the host", |
| " -split <line number> Split files or modules larger than specified line number for multi thread compilation", |
| " -timescale=<timescale> Specifies the overall timescale", |
| " -nobuiltin Do not parse SV builtin classes (array...)", |
| "", |
| "TRACES OPTIONS:", |
| " -d <int> Debug <level> 1-4, lib, ast, inst, incl", |
| " -nostdout Mutes Standard output", |
| " -verbose Gives verbose processing information", |
| " -profile Gives Profiling information", |
| " -l <file> Specifies log file, default is surelog.log under output dir", |
| "", |
| "OUTPUT OPTIONS:", |
| " -odir <dir> Specifies the output directory, default is ./", |
| " -writeppfile <file> Writes out Preprocessor output in file", |
| " (all compilation units will override this file)", |
| " -writepp Writes out Preprocessor output (all compilation", |
| " units will generate files under slpp_all/ or slpp_unit/)", |
| " -lineoffsetascomments Writes the preprocessor line offsets as comments as opposed as parser directives", |
| " -nocache Default allows to create a cache for include files, this option prevents it", |
| " -cache <dir> Specifies the cache directory, default is slpp_all/cache or slpp_unit/cache", |
| " -createcache Create cache for precompiled packages", |
| " -filterdirectives Filters out simple directives like", |
| " `default_nettype in pre-processor's output", |
| " -filterprotected Filters out protected regions in pre-processor's output", |
| " -filtercomments Filters out comments in pre-processor's output", |
| " -outputlineinfo Outputs SLline directives in pre-processor's output", |
| " -pploc Output message location in terms of post preprocessor location", |
| " -noinfo Filters out INFO messages", |
| " -nonote Filters out NOTE messages", |
| " -nowarning Filters out WARNING messages", |
| " -o <path> Turns on all compilation stages, produces all outputs under that path" |
| }; |
| |
| std::string |
| printStringArray (const std::vector<std::string>& array) |
| { |
| std::string report; |
| for (unsigned int i = 0; i < array.size (); i++) |
| { |
| report += array[i] + "\n"; |
| } |
| report += "\n"; |
| return report; |
| } |
| |
| const std::string CommandLineParser::currentDateTime() { |
| time_t now = time(0); |
| struct tm tstruct; |
| char buf[80]; |
| tstruct = *localtime(&now); |
| // Visit http://en.cppreference.com/w/cpp/chrono/c/strftime |
| // for more information about date/time format |
| strftime(buf, sizeof(buf), "%Y-%m-%d.%X", &tstruct); |
| |
| return buf; |
| } |
| |
| void |
| CommandLineParser::logBanner (int argc, const char ** argv) |
| { |
| std::string banners = printStringArray (banner); |
| std::string copyrights = printStringArray (copyright); |
| m_errors->printToLogFile (banners); |
| m_errors->printToLogFile (copyrights); |
| std::string version = "VERSION: " + m_versionNumber + + "\n" + |
| "BUILT : " + std::string(__DATE__) + "\n"; |
| std::string date = "DATE : " + currentDateTime() + "\n"; |
| std::string cmd = "COMMAND:"; |
| for (int i = 1; i < argc; i++) |
| { |
| cmd += std::string(" ") + argv[i]; |
| } |
| cmd += "\n\n"; |
| m_errors->printToLogFile (version); |
| m_errors->printToLogFile (date); |
| m_errors->printToLogFile (cmd); |
| } |
| |
| void CommandLineParser::printBanner() { |
| std::string banners = printStringArray (banner); |
| std::cout << banners; |
| } |
| |
| void CommandLineParser::printFooter() { |
| std::string footers = "\n"; |
| footers += printStringArray (footer); |
| std::cout << footers; |
| } |
| |
| void |
| CommandLineParser::logFooter () |
| { |
| std::string footers = "\n"; |
| footers += printStringArray (footer); |
| m_errors->printToLogFile (footers); |
| |
| } |
| |
| CommandLineParser::CommandLineParser (ErrorContainer* errors, SymbolTable* symbolTable, bool diff_comp_mode, bool fileUnit) : |
| m_writePpOutputFileId(0), m_writePpOutput(false), m_filterFileLine(true), m_debugLevel(0), m_errors(errors), m_symbolTable(symbolTable), m_lineOffsetsAsComments(false), |
| m_liborder(false), m_librescan(false), m_libverbose(false), m_nolibcell(false), m_muteStdout(false), m_verbose(false), m_fileunit(fileUnit), |
| m_filterSimpleDirectives(false), m_filterProtectedRegions(false), m_filterComments(false), m_parse(false), m_compile(false), m_elaborate(false), m_diff_comp_mode(diff_comp_mode), |
| m_help(false), m_cacheAllowed(true), m_nbMaxTreads(0), m_fullCompileDir(0), m_cacheDirId(0), m_note(true), m_info(true), m_warning(true), |
| m_pythonListener(false), m_debugAstModel(false), m_debugInstanceTree(false), m_debugLibraryDef(false), m_useTbb(false), m_pythonAllowed(true), m_nbLinesForFileSplitting(500), |
| m_pythonEvalScriptPerFile (false), m_pythonEvalScript (false), m_pythonEvalScriptPerFileId (0), m_pythonEvalScriptId (0), m_pythonListenerFileId(0), m_debugIncludeFileInfo(false), |
| m_createCache(false), m_profile(false), m_parseBuiltIn(true), m_ppOutputFileLocation(false), m_logFileSpecified(false) |
| { |
| m_errors->regiterCmdLine(this); |
| m_logFileId = m_symbolTable->registerSymbol(defaultLogFileName); |
| m_compileUnitDirectory = m_symbolTable->registerSymbol("slpp_unit/"); |
| m_compileAllDirectory = m_symbolTable->registerSymbol("slpp_all/"); |
| m_outputDir = m_symbolTable->registerSymbol("./"); |
| m_defaultLogFileId = m_symbolTable->registerSymbol(defaultLogFileName); |
| m_defaultCacheDirId = m_symbolTable->registerSymbol("cache/"); |
| m_precompiledDirId = m_symbolTable->registerSymbol("pkg"); |
| if (m_diff_comp_mode) |
| { |
| m_muteStdout = true; |
| m_verbose = false; |
| } |
| } |
| |
| CommandLineParser::CommandLineParser (const CommandLineParser& orig) { } |
| |
| CommandLineParser::~CommandLineParser () { } |
| |
| void CommandLineParser::splitPlusArg_(std::string s, std::string prefix, std::vector<SymbolId>& container) |
| { |
| std::istringstream f (s); |
| std::string tmp; |
| while (getline (f, tmp, '+')) |
| { |
| if (tmp.size () && (tmp != prefix)) |
| { |
| SymbolId id = m_symbolTable->registerSymbol (tmp); |
| container.push_back (id); |
| } |
| } |
| } |
| |
| void CommandLineParser::splitPlusArg_(std::string s, std::string prefix, std::map<SymbolId,std::string>& container) |
| { |
| std::istringstream f (s); |
| std::string tmp; |
| while (getline (f, tmp, '+')) |
| { |
| if (tmp.size () && (tmp != prefix)) |
| { |
| std::string def; |
| std::string value; |
| unsigned int loc = tmp.find("="); |
| if(loc == std::string::npos) |
| { |
| SymbolId id = m_symbolTable->registerSymbol (tmp); |
| container.insert(std::make_pair(id, std::string ())); |
| } |
| else |
| { |
| def = tmp.substr(0,loc); |
| value = tmp.substr(loc+1); |
| SymbolId id = m_symbolTable->registerSymbol (def); |
| container.insert(std::make_pair (id, value)); |
| } |
| } |
| } |
| } |
| |
| /* Custom parser for +arguments */ |
| bool CommandLineParser::plus_arguments_ (const std::string& s) |
| { |
| std::string incdir("+incdir+"); |
| std::string libext("+libext+"); |
| std::string define("+define+"); |
| if (s.size() == 0) |
| return false; |
| if (s.at (0) != '+') |
| return false; |
| if (s.compare (0, incdir.size(), incdir) == 0) |
| { |
| splitPlusArg_(s,"incdir", m_includePaths); |
| return true; |
| } |
| if (s.compare (0, libext.size(), libext) == 0) |
| { |
| splitPlusArg_(s,"libext", m_libraryExtensions); |
| return true; |
| } |
| if (s.compare (0, define.size(), define) == 0) |
| { |
| splitPlusArg_(s,"define", m_defineList); |
| return true; |
| } |
| return false; |
| } |
| |
| void |
| CommandLineParser::processArgs_ (std::vector<std::string>& args, std::vector<std::string>& container) |
| { |
| for (unsigned int i = 0; i < args.size (); i++) |
| { |
| if (args[i] == "-f") |
| { |
| std::string f = args[i + 1]; |
| SymbolId fId = m_symbolTable->registerSymbol (f); |
| std::ifstream ifs (f); |
| if (!ifs) |
| { |
| Location loc (fId); |
| Error err (ErrorDefinition::CMD_DASH_F_FILE_DOES_NOT_EXIST, loc); |
| m_errors->addError(err); |
| } |
| else |
| { |
| std::stringstream ss; |
| ss << ifs.rdbuf (); |
| ifs.close(); |
| std::vector<std::string> argsInFile; |
| StringUtils::tokenize (ss.str ()," \n\t\r",argsInFile); |
| processArgs_ (argsInFile, container); |
| } |
| i++; |
| } |
| else |
| { |
| container.push_back(args[i]); |
| } |
| } |
| } |
| |
| int |
| CommandLineParser::parseCommandLine (int argc, const char ** argv) |
| { |
| |
| std::string exe_name = argv[0]; |
| std::string exe_path = FileUtils::getPathName (exe_name); |
| m_precompiledDirId = m_symbolTable->registerSymbol(exe_path + "pkg/"); |
| std::string built_in_verilog = exe_path + "../sv/builtin.sv"; |
| std::vector<std::string> all_arguments; |
| std::vector<std::string> cmd_line; |
| for (int i = 1; i < argc; i++) |
| { |
| cmd_line.push_back (argv[i]); |
| |
| if (!strcmp(argv[i],"-l")) |
| { |
| if (i < argc - 1) |
| { |
| m_logFileId = m_symbolTable->registerSymbol (argv[i + 1]); |
| m_logFileSpecified = true; |
| } |
| } |
| |
| } |
| processArgs_ (cmd_line, all_arguments); |
| for (unsigned int i = 0; i < all_arguments.size (); i++) |
| { |
| if (all_arguments[i] == "-help" || all_arguments[i] == "-h") |
| { |
| m_help = true; |
| std::string help = printStringArray(helpText); |
| m_errors->init(); |
| logBanner (argc, argv); |
| printBanner(); |
| std::cout << help; |
| m_errors->printToLogFile (help); |
| return true; |
| } |
| if (all_arguments[i] == "-nobuiltin") |
| { |
| m_parseBuiltIn = false; |
| } |
| } |
| if (m_parseBuiltIn) |
| { |
| m_sourceFiles.push_back (m_symbolTable->registerSymbol (built_in_verilog)); |
| } |
| for (unsigned int i = 0; i < all_arguments.size (); i++) |
| { |
| if (all_arguments[i] == "-fileunit") |
| { |
| if (m_diff_comp_mode == false) // Controlled by constructor |
| m_fileunit = true; |
| } |
| else if (all_arguments[i] == "-mutestdout") |
| { |
| m_muteStdout = true; |
| } |
| else if (all_arguments[i] == "-nopython") |
| { |
| m_pythonAllowed = false; |
| } |
| } |
| |
| for (unsigned int i = 0; i < all_arguments.size (); i++) |
| { |
| if (all_arguments[i] == "-odir" || all_arguments[i] == "-o") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_ODIR, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_outputDir = m_symbolTable->registerSymbol (all_arguments[i]); |
| } |
| } |
| bool status = prepareCompilation_ (argc, argv); |
| if (!status) |
| return status; |
| |
| for (unsigned int i = 0; i < all_arguments.size (); i++) |
| { |
| if (plus_arguments_ (all_arguments[i])) |
| { |
| } |
| else if (all_arguments[i] == "-d") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_DEBUG_MISSING_LEVEL, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| if (all_arguments[i] == "ast") |
| { |
| m_debugAstModel = true; |
| } |
| else if (all_arguments[i] == "inst") |
| { |
| m_debugInstanceTree = true; |
| } |
| else if (all_arguments[i] == "lib") |
| { |
| m_debugLibraryDef = true; |
| } |
| else if (all_arguments[i] == "incl") |
| { |
| m_debugIncludeFileInfo = true; |
| } |
| else |
| { |
| int debugLevel = atoi (all_arguments[i].c_str ()); |
| if (debugLevel < 0 || debugLevel > 4) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_DEBUG_INCORRECT_LEVEL, loc); |
| m_errors->addError (err); |
| } |
| else |
| { |
| m_debugLevel = debugLevel; |
| } |
| } |
| } |
| else if (strstr(all_arguments[i].c_str(),"-timescale=")) |
| { |
| std::string timescale; |
| timescale = all_arguments[i].substr(11, std::string::npos); |
| if (timescale == "") |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_TIMESCALE_MISSING_SETTING, loc); |
| m_errors->addError (err); |
| break; |
| } |
| m_timescale = timescale; |
| } |
| else if (strstr(all_arguments[i].c_str(),"-I")) |
| { |
| std::string include; |
| include = all_arguments[i].substr(2, std::string::npos); |
| if (include == "") |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_INCLUDE_PATH_DOES_NOT_EXIST, loc); |
| m_errors->addError (err); |
| break; |
| } |
| m_includePaths.push_back(getSymbolTable ()->registerSymbol (include)); |
| } |
| else if (all_arguments[i] == "-split") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_SPLIT_FILE_MISSING_SIZE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_nbLinesForFileSplitting = atoi (all_arguments[i].c_str ()); |
| } |
| else if (all_arguments[i] == "-mt") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_MT_MISSING_LEVEL, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| unsigned int maxMT = 0; |
| if (all_arguments[i] == "max") |
| { |
| unsigned int concurentThreadsSupported = std::thread::hardware_concurrency(); |
| maxMT = concurentThreadsSupported; |
| |
| } |
| else |
| { |
| maxMT = atoi (all_arguments[i].c_str ()); |
| } |
| if (maxMT < 0 || maxMT > 512) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_MT_INCORRECT_LEVEL, loc); |
| m_errors->addError (err); |
| } |
| else |
| { |
| if (m_diff_comp_mode) |
| { |
| unsigned int concurentThreadsSupported = std::thread::hardware_concurrency(); |
| if (maxMT > (concurentThreadsSupported / 2)) |
| maxMT = (concurentThreadsSupported / 2); |
| } |
| |
| if (maxMT == 0) |
| m_nbMaxTreads = maxMT; |
| else |
| { |
| m_nbMaxTreads = maxMT; |
| if (m_nbMaxTreads < 2) |
| m_nbMaxTreads = 2; |
| Location loc (getSymbolTable ()->registerSymbol (std::to_string(m_nbMaxTreads))); |
| Error err (ErrorDefinition::CMD_NUMBER_THREADS, loc); |
| m_errors->addError (err); |
| } |
| } |
| } |
| else if (all_arguments[i] == "-strictpythoncheck") |
| { |
| PythonAPI::setStrictMode (true); |
| |
| } |
| else if (all_arguments[i] == "-tbb") |
| { |
| m_useTbb = true; |
| |
| } |
| else if (all_arguments[i] == "-createcache") |
| { |
| m_createCache = true; |
| } |
| else if (all_arguments[i] == "-lineoffsetascomments") |
| { |
| m_lineOffsetsAsComments = true; |
| } |
| else if (all_arguments[i] == "-v") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_LIBRARY_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_libraryFiles.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-y") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_LIBRARY_PATH_MISSING_PATH, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_libraryPaths.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-l") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_LOG_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_logFileId = m_symbolTable->registerSymbol (all_arguments[i]); |
| m_logFileSpecified = true; |
| } |
| else if (all_arguments[i] == "-L") |
| { |
| i++; |
| m_orderedLibraries.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-map") |
| { |
| i++; |
| m_libraryMapFiles.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-cfgfile") |
| { |
| i++; |
| m_configFiles.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-cfg") |
| { |
| i++; |
| m_useConfigs.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| else if (all_arguments[i] == "-writeppfile") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_writePpOutputFileId = m_symbolTable->registerSymbol (all_arguments[i]); |
| } |
| else if (all_arguments[i] == "-cache") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_cacheDirId = m_symbolTable->registerSymbol (all_arguments[i]); |
| } |
| else if (all_arguments[i] == "-writepp") |
| { |
| m_writePpOutput = true; |
| } |
| else if (all_arguments[i] == "-noinfo") |
| { |
| m_info = false; |
| } |
| else if (all_arguments[i] == "-nonote") |
| { |
| m_note = false; |
| } |
| else if (all_arguments[i] == "-nowarning") |
| { |
| m_warning = false; |
| } |
| else if (all_arguments[i] == "-profile") |
| { |
| m_profile = true; |
| } |
| else if (all_arguments[i] == "-nobuiltin") |
| { |
| m_parseBuiltIn = false; |
| } |
| else if (all_arguments[i] == "-outputlineinfo") |
| { |
| m_filterFileLine = false; |
| } |
| else if (all_arguments[i] == "+liborder") |
| { |
| m_liborder = true; |
| } |
| else if (all_arguments[i] == "+librescan") |
| { |
| m_librescan = true; |
| } |
| else if (all_arguments[i] == "+libverbose") |
| { |
| m_libverbose = true; |
| } |
| else if (all_arguments[i] == "+nolibcell") |
| { |
| m_nolibcell = true; |
| } |
| else if (all_arguments[i] == "-fileunit") |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_SEPARATE_COMPILATION_UNIT_ON, loc); |
| m_errors->addError (err); |
| } |
| else if (all_arguments[i] == "-diffcompunit") |
| { |
| if (m_fileunit) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_SEPARATE_COMPILATION_UNIT_ON, loc); |
| m_errors->addError (err); |
| } |
| } |
| else if (all_arguments[i] == "-odir") |
| { |
| i++; |
| } |
| else if (all_arguments[i] == "-o") |
| { |
| i++; |
| m_writePpOutput = true; |
| m_parse = true; |
| } |
| else if (all_arguments[i] == "-nostdout") |
| { |
| m_muteStdout = true; |
| } |
| else if (all_arguments[i] == "-verbose") |
| { |
| m_verbose = true; |
| } |
| else if (all_arguments[i] == "-filterdirectives") |
| { |
| m_filterSimpleDirectives = true; |
| } |
| else if (all_arguments[i] == "-filterprotected") |
| { |
| m_filterProtectedRegions = true; |
| } |
| else if (all_arguments[i] == "-filtercomments") |
| { |
| m_filterComments = true; |
| } |
| else if (all_arguments[i] == "-parse") |
| { |
| m_writePpOutput = true; |
| m_parse = true; |
| m_compile = true; |
| m_elaborate = true; |
| } |
| else if (all_arguments[i] == "-nocomp") |
| { |
| m_compile = false; |
| m_elaborate = false; |
| } |
| else if (all_arguments[i] == "-noelab") |
| { |
| m_elaborate = false; |
| } |
| else if (all_arguments[i] == "-pploc") |
| { |
| m_ppOutputFileLocation = true; |
| } |
| else if (all_arguments[i] == "-pythonlistener") |
| { |
| m_writePpOutput = true; |
| m_parse = true; |
| m_compile = true; |
| m_elaborate = true; |
| m_pythonListener = true; |
| if (!PythonAPI::isListenerLoaded()) { |
| Location loc(0); |
| Error err (ErrorDefinition::PY_NO_PYTHON_LISTENER_FOUND, loc); |
| m_errors->addError (err); |
| } |
| if(!m_pythonAllowed) |
| std::cout << "ERROR: No Python allowed, check your arguments!\n"; |
| } |
| else if (all_arguments[i] == "-nopython") |
| { |
| m_pythonAllowed = false; |
| } |
| else if (all_arguments[i] == "-pythonevalscriptperfile") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_writePpOutput = true; |
| m_parse = true; |
| m_compile = true; |
| m_elaborate = true; |
| m_pythonEvalScriptPerFile = true; |
| m_pythonEvalScriptPerFileId = m_symbolTable->registerSymbol (all_arguments[i]); |
| if(m_pythonAllowed) |
| PythonAPI::loadScript (all_arguments[i], true); |
| else |
| std::cout << "ERROR: No Python allowed, check your arguments!\n"; |
| } |
| else if (all_arguments[i] == "-pythonlistenerfile") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_writePpOutput = true; |
| m_parse = true; |
| m_compile = true; |
| m_elaborate = true; |
| m_pythonListener = true; |
| m_pythonListenerFileId = m_symbolTable->registerSymbol (all_arguments[i]); |
| PythonAPI::setListenerScript (all_arguments[i]); |
| } |
| else if (all_arguments[i] == "-pythonevalscript") |
| { |
| if (i == all_arguments.size () - 1) |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PP_FILE_MISSING_FILE, loc); |
| m_errors->addError (err); |
| break; |
| } |
| i++; |
| m_writePpOutput = true; |
| m_parse = true; |
| m_compile = true; |
| m_elaborate = true; |
| m_pythonEvalScript = true; |
| m_pythonEvalScriptId = m_symbolTable->registerSymbol (all_arguments[i]); |
| if(m_pythonAllowed) |
| PythonAPI::loadScript (all_arguments[i], true); |
| else |
| std::cout << "ERROR: No Python allowed, check your arguments!\n"; |
| } |
| else if (all_arguments[i] == "-nocache") |
| { |
| m_cacheAllowed = false; |
| } |
| else if (all_arguments[i].size () && all_arguments[i].at (0) == '+') |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_PLUS_ARG_IGNORED, loc); |
| m_errors->addError (err); |
| } |
| else if (all_arguments[i].size () && all_arguments[i].at (0) == '-') |
| { |
| Location loc (getSymbolTable ()->registerSymbol (all_arguments[i])); |
| Error err (ErrorDefinition::CMD_MINUS_ARG_IGNORED, loc); |
| m_errors->addError (err); |
| } |
| else |
| { |
| if (all_arguments[i] != "") |
| m_sourceFiles.push_back (m_symbolTable->registerSymbol (all_arguments[i])); |
| } |
| } |
| |
| status = checkCommandLine_ (); |
| return status; |
| } |
| |
| bool |
| CommandLineParser::checkCommandLine_ () |
| { |
| bool noError = true; |
| for (auto fid : m_sourceFiles) |
| { |
| if (!FileUtils::fileExists (m_symbolTable->getSymbol (fid))) |
| { |
| Location loc (fid); |
| Error err (ErrorDefinition::CMD_VERILOG_FILE_DOES_NOT_EXIST, loc); |
| m_errors->addError (err); |
| noError = false; |
| } |
| } |
| for (auto fid : m_libraryPaths) |
| { |
| if (!FileUtils::fileExists (m_symbolTable->getSymbol (fid))) |
| { |
| Location loc (fid); |
| Error err (ErrorDefinition::CMD_LIBRARY_PATH_DOES_NOT_EXIST, loc); |
| m_errors->addError (err); |
| } |
| } |
| for (auto fid : m_libraryFiles) |
| { |
| if (!FileUtils::fileExists (m_symbolTable->getSymbol (fid))) |
| { |
| Location loc (fid); |
| Error err (ErrorDefinition::CMD_LIBRARY_FILE_DOES_NOT_EXIST, loc); |
| m_errors->addError (err); |
| noError = false; |
| } |
| } |
| for (auto fid : m_includePaths) |
| { |
| if (!FileUtils::fileExists (m_symbolTable->getSymbol (fid))) |
| { |
| Location loc (fid); |
| Error err (ErrorDefinition::CMD_INCLUDE_PATH_DOES_NOT_EXIST, loc); |
| m_errors->addError (err); |
| } |
| } |
| if (!m_errors->printMessages (m_muteStdout)) |
| { |
| noError = false; |
| } |
| |
| return noError; |
| } |
| |
| bool |
| CommandLineParser::prepareCompilation_ (int argc, const char ** argv) |
| { |
| bool noError = true; |
| std::string odir = m_symbolTable->getSymbol (m_outputDir); |
| if (odir.size ()) |
| { |
| if (odir[odir.size () - 1] != '/') |
| { |
| odir += '/'; |
| } |
| } |
| |
| odir += m_symbolTable->getSymbol ((fileunit () ? m_compileUnitDirectory : m_compileAllDirectory)); |
| m_fullCompileDir = m_symbolTable->registerSymbol (odir); |
| |
| if (!m_logFileSpecified) |
| m_logFileId = m_symbolTable->registerSymbol (odir + defaultLogFileName); |
| |
| std::string cachedir; |
| if (m_cacheAllowed) |
| { |
| if (m_cacheDirId == 0) |
| { |
| cachedir = odir + m_symbolTable->getSymbol (m_defaultCacheDirId); |
| m_cacheDirId = m_symbolTable->registerSymbol (cachedir); |
| } |
| else |
| { |
| cachedir = m_symbolTable->getSymbol (m_cacheDirId); |
| } |
| } |
| |
| int status = FileUtils::mkDir (odir.c_str ()); |
| if (status != 0) |
| { |
| Location loc (m_fullCompileDir); |
| Error err (ErrorDefinition::CMD_PP_CANNOT_CREATE_OUTPUT_DIR, loc); |
| m_errors->addError (err); |
| noError = false; |
| } |
| |
| m_errors->init(); |
| logBanner (argc, argv); |
| if (!m_muteStdout) |
| { |
| printBanner(); |
| } |
| Location loc (m_logFileId); |
| Error err (ErrorDefinition::CMD_CREATING_LOG_FILE, loc); |
| m_errors->addError (err); |
| |
| if (m_cacheAllowed) |
| { |
| status = FileUtils::mkDir (cachedir.c_str ()); |
| if (status != 0) |
| { |
| Location loc (m_cacheDirId); |
| Error err (ErrorDefinition::CMD_PP_CANNOT_CREATE_CACHE_DIR, loc); |
| m_errors->addError (err); |
| noError = false; |
| } |
| } |
| |
| |
| if (m_errors->hasFatalErrors()) |
| { |
| noError = false; |
| } |
| |
| return noError; |
| } |
| |
