/* SetFileType - set the file type of a file based upon its extension
*
* pFile pointer to file whose type will be determined
*/
void
SetFileType (
PFILE pFile
) {
pathbuf fext;
REGISTER int i;
extention (pFile->pName, fext);
for (i = 0; ftypetbl[i].ext; i++) {
if (!strcmp (ftypetbl[i].ext, (char *)&fext[1])) {
break;
}
}
FTYPE(pFile) = ftypetbl[i].ftype;
}
bool SWDynamicTree2D::updateProxy( tuint proxyID, const taabb2d& aabb )
{
if ( proxyID >= m_nodes.size() ) return false;
TreeNode& node = m_nodes[proxyID];
if ( node.aabb.contains( aabb ) ) return false;
removeLeaf( proxyID );
tvec2 extention( SW_AddedExtension, SW_AddedExtension );
node.aabb = aabb;
node.aabb.lower -= extention;
node.aabb.upper += extention;
insertLeaf( proxyID );
return true;
}
/*** fInitFileMac - Initialize macros associated with a file
*
* Sets the curfile family of macros, and attempts to read any extension-
* specific section from tools.ini.
*
* Input:
* pFileNew = File to set information for
*
* Output:
* Returns TRUE if TOOLS.INI section found, else FALSE
*
*************************************************************************/
flagType
fInitFileMac (
PFILE pFileNew
) {
char fbuf[ 512 ];
strcpy (fbuf, pFileNew->pName);
FmtAssign ("curFile:=\"%s\"", DoubleSlashes (fbuf));
filename (pFileNew->pName, fbuf);
FmtAssign ("curFileNam:=\"%s\"", fbuf);
if (!extention (pFileNew->pName, fbuf)) {
fbuf[0] = '.';
fbuf[1] = '\0';
}
FmtAssign ("curFileExt:=\"%s\"", fbuf);
return InitExt (fbuf);
}
int clang_main(int argc, char ** argv, SgSourceFile& sageFile) {
// 0 - Analyse Cmd Line
std::vector<std::string> inc_dirs_list;
std::vector<std::string> define_list;
std::vector<std::string> inc_list;
std::string input_file;
for (int i = 0; i < argc; i++) {
std::string current_arg(argv[i]);
if (current_arg.find("-I") == 0) {
if (current_arg.length() > 2) {
inc_dirs_list.push_back(current_arg.substr(2));
}
else {
i++;
if (i < argc)
inc_dirs_list.push_back(current_arg);
else
break;
}
}
else if (current_arg.find("-D") == 0) {
if (current_arg.length() > 2) {
define_list.push_back(current_arg.substr(2));
}
else {
i++;
if (i < argc)
define_list.push_back(current_arg);
else
break;
}
}
else if (current_arg.find("-c") == 0) {}
else if (current_arg.find("-o") == 0) {
if (current_arg.length() == 2) {
i++;
if (i >= argc) break;
}
}
else {
// TODO -include
#if DEBUG_ARGS
std::cerr << "argv[" << i << "] = " << current_arg << " is neither define or include dir. Use it as input file." << std::endl;
#endif
input_file = current_arg;
}
}
ClangToSageTranslator::Language language = ClangToSageTranslator::unknown;
size_t last_period = input_file.find_last_of(".");
std::string extention(input_file.substr(last_period + 1));
if (extention == "c") {
language = ClangToSageTranslator::C;
}
else if (extention == "C" || extention == "cxx" || extention == "cpp" || extention == "cc") {
language = ClangToSageTranslator::CPLUSPLUS;
}
else if (extention == "objc") {
language = ClangToSageTranslator::OBJC;
}
else if (extention == "cu") {
language = ClangToSageTranslator::CUDA;
}
else if (extention == "ocl" || extention == "cl") {
language = ClangToSageTranslator::OPENCL;
}
ROSE_ASSERT(language != ClangToSageTranslator::unknown);
const char * cxx_config_include_dirs_array [] = CXX_INCLUDE_STRING;
const char * c_config_include_dirs_array [] = C_INCLUDE_STRING;
std::vector<std::string> cxx_config_include_dirs (
cxx_config_include_dirs_array,
cxx_config_include_dirs_array + sizeof(cxx_config_include_dirs_array) / sizeof(const char*)
);
std::vector<std::string> c_config_include_dirs (
c_config_include_dirs_array,
c_config_include_dirs_array + sizeof(c_config_include_dirs_array) / sizeof(const char*)
);
std::string rose_include_path;
bool in_install_tree = roseInstallPrefix(rose_include_path);
if (in_install_tree) {
rose_include_path += "/include-staging/";
}
else {
rose_include_path = std::string(ROSE_AUTOMAKE_TOP_BUILDDIR) + "/include-staging/";
}
std::vector<std::string>::iterator it;
for (it = c_config_include_dirs.begin(); it != c_config_include_dirs.end(); it++)
if (it->length() > 0 && (*it)[0] != '/')
*it = rose_include_path + *it;
for (it = cxx_config_include_dirs.begin(); it != cxx_config_include_dirs.end(); it++)
if (it->length() > 0 && (*it)[0] != '/')
*it = rose_include_path + *it;
inc_dirs_list.push_back(rose_include_path + "clang/");
// FIXME add ROSE path to gcc headers...
switch (language) {
case ClangToSageTranslator::C:
inc_dirs_list.insert(inc_dirs_list.begin(), c_config_include_dirs.begin(), c_config_include_dirs.end());
inc_list.push_back("clang-builtin-c.h");
break;
case ClangToSageTranslator::CPLUSPLUS:
inc_dirs_list.insert(inc_dirs_list.begin(), cxx_config_include_dirs.begin(), cxx_config_include_dirs.end());
inc_list.push_back("clang-builtin-cpp.hpp");
break;
case ClangToSageTranslator::CUDA:
inc_dirs_list.insert(inc_dirs_list.begin(), cxx_config_include_dirs.begin(), cxx_config_include_dirs.end());
inc_list.push_back("clang-builtin-cuda.hpp");
break;
case ClangToSageTranslator::OPENCL:
// inc_dirs_list.insert(inc_dirs_list.begin(), c_config_include_dirs.begin(), c_config_include_dirs.end());
// FIXME get the path right
inc_list.push_back("clang-builtin-opencl.h");
break;
case ClangToSageTranslator::OBJC:
default:
ROSE_ASSERT(false);
}
// FIXME should be handle by Clang ?
define_list.push_back("__I__=_Complex_I");
unsigned cnt = define_list.size() + inc_dirs_list.size() + inc_list.size();
char ** args = new char*[cnt];
std::vector<std::string>::iterator it_str;
unsigned i = 0;
for (it_str = define_list.begin(); it_str != define_list.end(); it_str++) {
args[i] = new char[it_str->size() + 3];
args[i][0] = '-';
args[i][1] = 'D';
strcpy(&(args[i][2]), it_str->c_str());
#if DEBUG_ARGS
std::cerr << "args[" << i << "] = " << args[i] << std::endl;
#endif
i++;
}
for (it_str = inc_dirs_list.begin(); it_str != inc_dirs_list.end(); it_str++) {
args[i] = new char[it_str->size() + 3];
args[i][0] = '-';
args[i][1] = 'I';
strcpy(&(args[i][2]), it_str->c_str());
#if DEBUG_ARGS
std::cerr << "args[" << i << "] = " << args[i] << std::endl;
#endif
i++;
}
for (it_str = inc_list.begin(); it_str != inc_list.end(); it_str++) {
args[i] = new char[it_str->size() + 9];
args[i][0] = '-'; args[i][1] = 'i'; args[i][2] = 'n'; args[i][3] = 'c';
args[i][4] = 'l'; args[i][5] = 'u'; args[i][6] = 'd'; args[i][7] = 'e';
strcpy(&(args[i][8]), it_str->c_str());
#if DEBUG_ARGS
std::cerr << "args[" << i << "] = " << args[i] << std::endl;
#endif
i++;
}
// 2 - Create a compiler instance
clang::CompilerInstance * compiler_instance = new clang::CompilerInstance();
clang::TextDiagnosticPrinter * diag_printer = new clang::TextDiagnosticPrinter(llvm::errs(), clang::DiagnosticOptions());
compiler_instance->createDiagnostics(argc, argv, diag_printer, true, false);
clang::CompilerInvocation * invocation = new clang::CompilerInvocation();
clang::CompilerInvocation::CreateFromArgs(*invocation, args, &(args[cnt]), compiler_instance->getDiagnostics());
compiler_instance->setInvocation(invocation);
clang::LangOptions & lang_opts = compiler_instance->getLangOpts();
switch (language) {
case ClangToSageTranslator::C:
// compiler_instance->getInvocation().setLangDefaults(lang_opts, clang::IK_C, );
break;
case ClangToSageTranslator::CPLUSPLUS:
lang_opts.CPlusPlus = 1;
// compiler_instance->getInvocation().setLangDefaults(lang_opts, clang::IK_CXX, );
break;
case ClangToSageTranslator::CUDA:
lang_opts.CUDA = 1;
// lang_opts.CPlusPlus = 1;
// compiler_instance->getInvocation().setLangDefaults(lang_opts, clang::IK_CUDA, clang::LangStandard::lang_cuda);
break;
case ClangToSageTranslator::OPENCL:
lang_opts.OpenCL = 1;
// compiler_instance->getInvocation().setLangDefaults(lang_opts, clang::IK_OpenCL, clang::LangStandard::lang_opencl);
break;
case ClangToSageTranslator::OBJC:
ROSE_ASSERT(!"Objective-C is not supported by ROSE Compiler.");
// compiler_instance->getInvocation().setLangDefaults(lang_opts, clang::IK_, );
default:
ROSE_ASSERT(false);
}
clang::TargetOptions target_options;
target_options.Triple = llvm::sys::getHostTriple();
clang::TargetInfo * target_info = clang::TargetInfo::CreateTargetInfo(compiler_instance->getDiagnostics(), target_options);
compiler_instance->setTarget(target_info);
compiler_instance->createFileManager();
compiler_instance->createSourceManager(compiler_instance->getFileManager());
const clang::FileEntry * input_file_entry = compiler_instance->getFileManager().getFile(input_file);
compiler_instance->getSourceManager().createMainFileID(input_file_entry);
if (!compiler_instance->hasPreprocessor()) compiler_instance->createPreprocessor();
if (!compiler_instance->hasASTContext()) compiler_instance->createASTContext();
ClangToSageTranslator translator(compiler_instance, language);
compiler_instance->setASTConsumer(&translator);
if (!compiler_instance->hasSema()) compiler_instance->createSema(clang::TU_Complete, NULL);
ROSE_ASSERT (compiler_instance->hasDiagnostics());
ROSE_ASSERT (compiler_instance->hasTarget());
ROSE_ASSERT (compiler_instance->hasFileManager());
ROSE_ASSERT (compiler_instance->hasSourceManager());
ROSE_ASSERT (compiler_instance->hasPreprocessor());
ROSE_ASSERT (compiler_instance->hasASTContext());
ROSE_ASSERT (compiler_instance->hasSema());
// 3 - Translate
compiler_instance->getDiagnosticClient().BeginSourceFile(compiler_instance->getLangOpts(), &(compiler_instance->getPreprocessor()));
clang::ParseAST(compiler_instance->getPreprocessor(), &translator, compiler_instance->getASTContext());
compiler_instance->getDiagnosticClient().EndSourceFile();
SgGlobal * global_scope = translator.getGlobalScope();
// 4 - Attach to the file
if (sageFile.get_globalScope() != NULL) SageInterface::deleteAST(sageFile.get_globalScope());
sageFile.set_globalScope(global_scope);
global_scope->set_parent(&sageFile);
std::string file_name(input_file);
Sg_File_Info * start_fi = new Sg_File_Info(file_name, 0, 0);
Sg_File_Info * end_fi = new Sg_File_Info(file_name, 0, 0);
global_scope->set_startOfConstruct(start_fi);
global_scope->set_endOfConstruct(end_fi);
// 5 - Finish the AST (fixup phase)
finishSageAST(translator);
return 1;
}
