ExternalVendorCode/trick
1
0
Fork 0
mirror of https://github.com/nasa/trick.git synced 2024-12-21 14:07:51 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
b3f03e3fc4
trick/trick_source/codegen/Interface_Code_Gen/HeaderSearchDirs.cpp
Derek Bankieris 1dbeb3e2d4 Fix io code for classes with excluded parents 
Check the return value of CXXRecordVisitor::TraverseCXXRecordDecl and
don't add information from excluded parents.
Add a parameter to PrintAttributes::isHeaderExcluded to toggle exlusion
of TRICK_EXT_LIB_DIRS paths. When traversing a CXX record, we don't
actually want to skip these paths since their io code should exist in
the Trickified library.
Fix memory leak.

Refs #435
2017-05-24 10:51:27 -05:00

378 lines
13 KiB
C++
Raw Blame History

#include <iostream>
#include <sstream>
#include <fstream>
#include <stdio.h>
#include <errno.h>
#include <limits.h>
#include <stdlib.h>
#include <libgen.h>
#include "clang/Basic/TargetInfo.h"
#include "clang/Frontend/Utils.h"
#include "HeaderSearchDirs.hh"
#include "Utilities.hh"
HeaderSearchDirs::HeaderSearchDirs(clang::HeaderSearch & in_hs ,
clang::HeaderSearchOptions & in_hso ,
clang::Preprocessor & in_pp ,
bool in_sim_services ) :
hs(in_hs) ,
hso(in_hso) ,
pp(in_pp) ,
sim_services(in_sim_services) {} ;
void HeaderSearchDirs::AddCompilerBuiltInSearchDirs () {
FILE * fp ;
char * lineptr = NULL ;
char line[1024] ;
size_t n = 0 ;
ssize_t num_read ;
const bool IsUserSupplied = false;
const bool IsFramework = false;
const bool IsSysRootRelative = true;
// Add clang specific include directory first. Only required on linux systems. :(
// This is so that ICG will find clang friendly headers first. gcc headers cause
// all kinds of problems. On macs all headers are clang friendly.
#if __linux
std::stringstream icg_dir ;
icg_dir << LLVM_HOME << "/lib/clang/" ;
icg_dir << LIBCLANG_MAJOR << "." << LIBCLANG_MINOR ;
#ifdef LIBCLANG_PATCHLEVEL
icg_dir << "." << LIBCLANG_PATCHLEVEL ;
#endif
icg_dir << "/include" ;
char * resolved_path = realpath(icg_dir.str().c_str(), NULL ) ;
if ( resolved_path != NULL ) {
hso.AddPath(resolved_path , clang::frontend::System, IsFramework, IsSysRootRelative);
}
#endif
fp = popen("${TRICK_HOME}/bin/trick-gte TRICK_CPPC" , "r") ;
fgets(line , sizeof(line) , fp) ;
pclose(fp) ;
std::string trick_cppc = std::string(line) ;
std::string command ;
trick_cppc.erase(trick_cppc.find_last_not_of(" \n\r\t")+1) ;
//std::cout << "TRICK_CPPC = " << trick_cppc << std::endl ;
command = std::string("echo | ") + trick_cppc + std::string(" -v -xc++ -E - 2>&1") ;
//std::cout << "command = " << command << std::endl ;
fp = popen(command.c_str() , "r") ;
bool dir_line = false ;
while (fgets( line , sizeof(line) , fp ) != NULL ) {
if ( !strncmp( line, "End of search list.", 19 )) {
break ;
} else if ( dir_line == true ) {
//std::cout << "lineptr = " << lineptr << std::endl ;
char * resolved_path = NULL ;
std::string dir = std::string(line) ;
dir.erase(dir.find_last_not_of(" \n\r\t\f\v") + 1) ;
dir.erase(0, dir.find_first_not_of(" ")) ;
if ( (n = dir.find(" (framework")) != std::string::npos ) {
dir.erase(n) ;
}
resolved_path = almostRealPath(dir.c_str()) ;
//std::cout << "dir = " << dir << std::endl ;
if ( resolved_path != NULL ) {
//std::cout << "gcc resolved_path = " << resolved_path << std::endl ;
hso.AddPath(resolved_path , clang::frontend::System, IsFramework, IsSysRootRelative);
free(resolved_path) ;
}
} else if ( !strncmp( line, "#include <...>", 14 )) {
dir_line = true ;
}
}
pclose(fp) ;
// Homebrew on Macs puts everything in /usr/local/Cellar.
hso.AddPath("/usr/local/Cellar" , clang::frontend::System, IsFramework, IsSysRootRelative);
// Fink on Macs puts everything in /sw.
hso.AddPath("/sw" , clang::frontend::System, IsFramework, IsSysRootRelative);
}
void HeaderSearchDirs::AddUserSearchDirs ( std::vector<std::string> & include_dirs ) {
//std::cout << "num include dirs " << include_dirs.size() << std::endl ;
int ii ;
for ( ii = 0 ; ii < include_dirs.size() ; ii++ ) {
//std::cout << "include dirs " << include_dirs[ii] << std::endl ;
char * resolved_path = almostRealPath(include_dirs[ii].c_str()) ;
if ( resolved_path != NULL ) {
//std::cout << "adding resolved_path = " << resolved_path << std::endl ;
hso.AddPath(resolved_path , clang::frontend::Angled, false, true);
// Add the path as a system path as well for those included files that are erroneously in <>
}
}
}
void HeaderSearchDirs::AddTrickSearchDirs () {
char * trick_home = getenv("TRICK_HOME") ;
if ( trick_home != NULL ) {
std::string temp_dir = std::string(trick_home) + "/include/trick" ;
char * resolved_path = almostRealPath(temp_dir.c_str() ) ;
hso.AddPath(resolved_path , clang::frontend::Quoted, false, true);
//trick_include_dir = std::string(resolved_path) ;
free(resolved_path) ;
temp_dir = std::string(trick_home) + "/include/er7_utils" ;
resolved_path = almostRealPath(temp_dir.c_str() ) ;
hso.AddPath(resolved_path , clang::frontend::Quoted, false, true);
free(resolved_path) ;
temp_dir = std::string(trick_home) + "/trick_source" ;
resolved_path = almostRealPath(temp_dir.c_str() ) ;
hso.AddPath(resolved_path , clang::frontend::Quoted, false, true);
trick_source_dir = std::string(resolved_path) ;
free(resolved_path) ;
temp_dir = std::string(trick_home) + "/include" ;
resolved_path = almostRealPath(temp_dir.c_str() ) ;
trick_include_dir = std::string(resolved_path) ;
}
}
void HeaderSearchDirs::AddDirsAndFiles(std::string env_var, std::vector<std::string> & var_list) {
char * env_var_contents = getenv(env_var.c_str()) ;
if( env_var_contents != NULL ) {
std::string s = std::string(env_var_contents) ;
std::stringstream ss(s);
std::string item;
while(std::getline(ss, item, ':')) {
item = trim(item) ;
if ( ! item.empty() ) {
char * resolved_path = realpath(item.c_str(), NULL) ;
if ( resolved_path ) {
std::ifstream file_or_dir(resolved_path) ;
file_or_dir.seekg(0, std::ios::end) ;
if ( !file_or_dir.good()) {
var_list.push_back(std::string(resolved_path) + "/");
} else {
var_list.push_back(std::string(resolved_path));
}
free(resolved_path);
} else {
std::cout << bold(color(WARNING, "Warning")) << " Cannot find " <<
env_var << " path " << quote(bold(item)) << std::endl ;
}
}
}
}
}
void HeaderSearchDirs::ApplyHeaderSearchOptions () {
clang::ApplyHeaderSearchOptions( hs , hso , pp.getLangOpts() , pp.getTargetInfo().getTriple() ) ;
clang::HeaderSearch::search_dir_iterator sdi ;
/*
for ( sdi = hs.quoted_dir_begin() ; sdi != hs.quoted_dir_end() ; sdi++ ) {
std::cout << "quoted dir " << (*sdi).getName() << std::endl ;
}
for ( sdi = hs.angled_dir_begin() ; sdi != hs.angled_dir_end() ; sdi++ ) {
std::cout << "angled dir " << (*sdi).getName() << std::endl ;
}
for ( sdi = hs.system_dir_begin() ; sdi != hs.system_dir_end() ; sdi++ ) {
std::cout << "system dir " << (*sdi).getName() << std::endl ;
}
*/
}
void HeaderSearchDirs::addSearchDirs ( std::vector<std::string> & include_dirs ) {
AddUserSearchDirs( include_dirs ) ;
AddTrickSearchDirs() ;
AddCompilerBuiltInSearchDirs() ;
ApplyHeaderSearchOptions() ;
AddDirsAndFiles("TRICK_ICG_EXCLUDE", icg_exclude_dirs) ;
AddDirsAndFiles("TRICK_EXCLUDE", exclude_dirs) ;
AddDirsAndFiles("TRICK_EXT_LIB_DIRS", ext_lib_dirs) ;
AddDirsAndFiles("TRICK_ICG_NOCOMMENT", icg_nocomment_dirs) ;
char * compat15_contents = getenv("TRICK_ICG_COMPAT15") ;
if ( compat15_contents != NULL ) {
std::string s(compat15_contents) ;
if ( s.length() > 0 ) {
s += std::string(":./S_source.hh") ;
setenv("TRICK_ICG_COMPAT15",s.c_str(),1) ;
}
}
AddDirsAndFiles("TRICK_ICG_COMPAT15", compat15_dirs) ;
}
bool HeaderSearchDirs::isPathInUserDir (const std::string& in_dir ) {
clang::HeaderSearch::search_dir_iterator sdi ;
for ( sdi = hs.system_dir_begin() ; sdi != hs.system_dir_end() ; sdi++ ) {
std::string curr_dir = (*sdi).getName() ;
if ( ! in_dir.compare(0, curr_dir.size(), curr_dir)) {
return false ;
}
}
if ( ! sim_services and
(! in_dir.compare(0, trick_source_dir.size(), trick_source_dir) or
! in_dir.compare(0, trick_include_dir.size(), trick_include_dir)) ) {
return false ;
}
return true ;
}
bool HeaderSearchDirs::isPathInUserOrTrickDir (const std::string& in_dir ) {
clang::HeaderSearch::search_dir_iterator sdi ;
for ( sdi = hs.system_dir_begin() ; sdi != hs.system_dir_end() ; sdi++ ) {
std::string curr_dir = (*sdi).getName() ;
if ( ! in_dir.compare(0, curr_dir.size(), curr_dir)) {
return false ;
}
}
return true ;
}
bool HeaderSearchDirs::isPathInExclude (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = exclude_dirs.begin() ; vit != exclude_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return true ;
}
}
return false ;
}
bool HeaderSearchDirs::isPathInICGExclude (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = icg_exclude_dirs.begin() ; vit != icg_exclude_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return true ;
}
}
return false ;
}
bool HeaderSearchDirs::isPathInExtLib (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = ext_lib_dirs.begin() ; vit != ext_lib_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return true ;
}
}
return false ;
}
bool HeaderSearchDirs::isPathInICGNoComment (const std::string& in_file ) {
char * resolved_path = almostRealPath(in_file.c_str() ) ;
if ( resolved_path != NULL ) {
std::string dir = std::string(dirname(resolved_path)) + "/";
if ( icg_nocomment_files.find(dir) == icg_nocomment_files.end() ) {
icg_nocomment_files[dir] = false ;
std::vector<std::string>::iterator vit ;
for ( vit = icg_nocomment_dirs.begin() ; vit != icg_nocomment_dirs.end() ; vit++ ) {
if ( ! dir.compare(0, (*vit).size(), (*vit))) {
icg_nocomment_files[dir] = true ;
break ;
}
}
}
free(resolved_path) ;
return icg_nocomment_files[dir] ;
}
return false ;
}
bool HeaderSearchDirs::isPathInCompat15 (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = compat15_dirs.begin() ; vit != compat15_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return true ;
}
}
if ( trick_icg_present.find(in_dir) != trick_icg_present.end() ) {
return true ;
}
return false ;
}
std::string HeaderSearchDirs::getPathInExclude (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = exclude_dirs.begin() ; vit != exclude_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return (*vit) ;
}
}
return std::string() ;
}
std::string HeaderSearchDirs::getPathInICGExclude (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = icg_exclude_dirs.begin() ; vit != icg_exclude_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return (*vit) ;
}
}
return std::string() ;
}
std::string HeaderSearchDirs::getPathInExtLib (const std::string& in_dir ) {
std::vector<std::string>::iterator vit ;
for ( vit = ext_lib_dirs.begin() ; vit != ext_lib_dirs.end() ; vit++ ) {
if ( ! in_dir.compare(0, (*vit).size(), (*vit))) {
return (*vit) ;
}
}
return std::string() ;
}
void HeaderSearchDirs::addDefines ( std::vector<std::string> & defines ) {
// Add -D command line arguments as well as "#define TRICK_ICG" to the preprocessor
unsigned int ii ;
std::string predefines("#define TRICK_ICG\n") ;
predefines += "#define __STRICT_ANSI__\n" ;
for ( ii = 0 ; ii < defines.size() ; ii++ ) {
size_t found = defines[ii].find("=") ;
if ( found != defines[ii].npos ) {
defines[ii].replace( found , 1 , " " ) ;
} else {
defines[ii] += " 1" ;
}
predefines += std::string("#define ") + defines[ii] + "\n" ;
}
pp.setPredefines(pp.getPredefines() + "\n" + predefines) ;
}
void HeaderSearchDirs::addTrickICGFoundFile ( std::string file_name ) {
char * rp = almostRealPath(file_name.c_str()) ;
if ( rp != NULL ) {
trick_icg_present.insert(rp) ;
free(rp) ;
}
}
Reference in New Issue View Git Blame Copy Permalink