c_definitions.h

Go to the documentation of this file.

#ifndef C_DEFINITION_FINDER_H_INCLUDED_
#define C_DEFINITION_FINDER_H_INCLUDED_

#include "rose.h"

#include "rose_nodes.h"

namespace risc {

namespace tools {

class CDefinitions {

public:

  static SgFunctionDeclaration* get_printf()
  {
    initialize();
    return printf_;
  }

  static SgFunctionDeclaration* get_fprintf()
  {
    initialize();
    return fprintf_;
  }

  static SgFunctionDeclaration* get_main()
  {
    initialize();
    return main_;
  }

  static SgTypedefDeclaration* get_file()
  {
    initialize();
    return file_;
  }

  static SgTypedefDeclaration* get_std_string()
  {
    initialize();
    return std_string_;
  }

private:
  static SgFunctionDeclaration *printf_;
  static SgFunctionDeclaration *fprintf_;
  static SgFunctionDeclaration *main_;
  static SgTypedefDeclaration *std_string_;
  static SgTypedefDeclaration *file_;

  static bool is_initialized_;

  static void initialize()
  {
    if(CDefinitions::is_initialized_ == true) {
      return;
    }

    // Search for function declarations
    const std::vector<SgNode*> &func_decls = RoseNodes::get_func_decls();
    for(std::vector<SgNode*>::const_iterator
        iter  = func_decls.begin();
        iter != func_decls.end();
        iter++) {

      SgFunctionDeclaration *func_decl = isSgFunctionDeclaration(*iter);
      std::string qualified_name = func_decl->get_qualified_name();

      if(qualified_name == "::printf") {
        printf_ = func_decl;
        continue;
      }

      if(qualified_name == "::fprintf") {
        fprintf_ = func_decl;
        continue;
      }

      // The main is hidden in the SystemC library. So, we will not find it.
      //if(qualified_name == "::main") {
      //  fprintf_ = func_decl;
      //  continue;
      //}
    }

    // search for typedefs
    const std::vector<SgNode*> &typedef_decls = RoseNodes::get_typedef_decl();
    for(std::vector<SgNode*>::const_iterator
        iter  = typedef_decls.begin();
        iter != typedef_decls.end();
        iter++) {

      SgTypedefDeclaration *typedef_decl = isSgTypedefDeclaration(*iter);
      std::string qualified_name = typedef_decl->get_qualified_name();

      if(qualified_name == "::std::string") {
        std_string_ = typedef_decl;
        continue;
      }

      if(qualified_name == "::FILE") {
        file_ = typedef_decl;
        continue;
      }
    }

  #if 0
    std::cout << "main_ " << main_ << std::endl;
    std::cout << "printf_ " << printf_ << std::endl;
    std::cout << "fprintf_ " << fprintf_ << std::endl;
    std::cout << "file_ " << file_ << std::endl;
    std::cout << "std_string_ " << std_string_ << std::endl;
  #endif

    CDefinitions::is_initialized_ = true;
  }
};

}; // end of namespace tools

}; // end of namespace risc

#endif /* C_DEFINITION_FINDER_H_INCLUDED_ */

/* ex: set softtabstop=2 tabstop=2 shiftwidth=2 expandtab: */