symbolviewer.cxx

Go to the documentation of this file.

#include <cxxtls/symbolviewer.h>
#include <cxxtls/viewermanager.h>
#include <cxxtls/file.h>
#include <portable_io.h>   // for popen()
#include <cxxtls/options.h>
#include <stdlib.h>

using namespace std;

#ifdef _MSC_VER
#define SLASH '\\'
#else
#define SLASH '/'
#endif

namespace cxxtls
{
//---------------------------------------------------------------------------------


SymbolViewer::
SymbolViewer(ViewerManager *vm, std::string databaseFilename)
:  TreeViewer(vm)
,  databaseName_( (databaseFilename.empty() ? "TAGPP.tagpp" : databaseFilename.c_str() ) )
{
     using namespace CppTagDB;

    bool generateDirectly = false; // the database name is not a real file

    if(databaseName_.size() > 9)
    {
       

       char const *p = databaseName_.data();

       p += databaseName_.size()-9;

       if(memcmp(p, ".cpptagdb", 9) == 0)
       {
          generateDirectly = true; // we have something like:   /home/dir/fred.cpp.cpptagdb

          databaseName_ = databaseName_.substr(0, databaseName_.size()-9);
       }


    }

    if(!generateDirectly)
    {
        char const *etagsPath = getenv("ETAGSPATH");
        
        char const *sourcePath= getenv("SOURCEPATH");
        
        if(!FileName(databaseName_).exists())
        {
            FileName location(databaseName_);
        
            if(etagsPath)
                location = location.find_file_in_path(databaseName_, etagsPath);
        
            if(location == databaseName_)
            {
               if(sourcePath == 0)
               {
                  sourcePath=".:..:../..:../../..:../../../..";
               }
        
                location = location.find_file_in_path(databaseName_, sourcePath);
            }
        
            databaseName_ = location;
        
        }
    }

    TreeViewer *me = this;
    me->setApplicationName(string("SymbolViewer: ") + databaseFilename);

    me->setRootDir(databaseName_.dirname());

    int errorLine=0;

    if(generateDirectly)
    {
        FileName curdir = FileName::getcwd();   // save current directory for later return

        string cpptagdb_executable = "cpptagdb.exe";
      
        if(ProgramOptions::global_options_)
        {
           FileName myProgram = ProgramOptions::global_options_->argv[0];  // 0 is known to exist
      
           FileName myDir = myProgram.dirname();
      
           FileName exeFile = myDir;
           
           exeFile += SLASH;
           
           exeFile += cpptagdb_executable;
      
           if(exeFile.exists())
           {
              cpptagdb_executable = exeFile;
           }
      
        }

        static string quote("\"");

        
        string cmd = quote + cpptagdb_executable + quote;

        if(databaseName_.size() > 2
           && databaseName_[ databaseName_.size() - 1] == '!'
          )
        {
           // the databaseName_ is a directory reference -- 
           // instead of using the normal command, let us
           // find the names of files in the specified directory
           // that are expected to be C++ and generate the
           // tag information for all of them.

           string dirname = databaseName_.substr(0, databaseName_.size()-2); 
              // everything up to the trailing /!




#ifdef _MSC_VER

           chdir(dirname.c_str());

           string searchCmd(" dir ");
           string searchOption(" /s /b ");
           string fileTypes("*.h *.hpp *.hxx *.h++ *.c *.cpp *.cxx *.c++ | ");

           cmd = searchCmd + searchOption + fileTypes + quote + cpptagdb_executable + quote + " -stdin ";

#else
           string searchCmd("find ");
           string searchOption(" ");
           string fileTypes("\\( -name '*.h' -o -name '*.hpp' -o -name '*.hxx' -o -name '*.h++' -o -name '*.c' -o -name '*.cpp' -o -name '*.cxx' -o -name '*.c++' \\) | ");
           cmd = searchCmd + quote + dirname + quote + searchOption + fileTypes + quote + cpptagdb_executable + quote + " -stdin ";

#endif




        }
        else
        {
            cmd += " \"";
            cmd += databaseName_;
            cmd += "\"";

        }


        vm->close();


        FILE *f=popen(cmd.c_str(), "r");
        
        database_.populate(f, errorLine);

        pclose(f);

        int rv=chdir(curdir.c_str());  // return to current directory (dos in particualar)

        rv=rv; // ingore chdir return value gosh darn it!

        vm->open();


    }
    else
        database_.populate(databaseName_, errorLine);

    TreeViewerNode &topNode = this->topNode();
    topNode.setName(databaseName_);
    
    { // populate node tree

        TreeViewerNode &Symbols           = topNode.addChild("SYMBOLS");

       SymbolInfo::const_iterator first= database_.symbols_.children_.begin(),
                                  last = database_.symbols_.children_.end();

       while(first != last)
       {
          addChild(Symbols, first->second);

          ++first;
       }


        
    } // populate node tree

}

//-----------------------------------------------------------------------------------

void SymbolViewer::
addChild(TreeViewerNode &parent, CppTagDB::SymbolInfo const &symbol)
{
    using namespace CppTagDB;

    TreeViewerNode &child = parent.addChild(symbol.annotatedName(true));

    if(symbol.line_ != 0)
    {
        child.adoptInfo(  new SymbolViewerNodeInformation(symbol.file_,
                                                          symbol.line_
                                                          )
                        );

    }
    else
    {
       child.setHighlighted();
    }

    if(!symbol.children_.empty())
    {

    
        SymbolInfo::Children::const_iterator first = symbol.children_.begin(),
                                             last  = symbol.children_.end();

        while(first != last)
        {
           SymbolInfo::Children::value_type const &cur = *first++;

           addChild(child, cur.second);

        }

    }

}


//-----------------------------------------------------------------------------------

bool 
SymbolViewerNodeInformation::
operator() (ViewerManager*vm, CursorWindow::viewport *vp, int command, FileName const &rootDir)
{
    FileName fileName(filename_);

    if(!fileName.is_absolute_path())
    {
        fileName = rootDir + fileName;
    }


    Viewer* oldie = vm->find_viewer(fileName);

    if(oldie)
    {
      oldie->set_row_col_hint(lineNumber_-1,0);
      vm->activate(oldie);
    }
    else
    {

      Viewer* newbie = vm->edit(fileName);

      if(newbie)
      {
        newbie->set_row_col_hint(lineNumber_-1,0);

        vm->vsplit(newbie, fileName);

      }
      else
        vm->active_viewport()->beep();
    }

    return false; // don't exit the browser
}
   

//-----------------------------------------------------------------------------------

Viewer* 
SymbolViewer::
app(ViewerManager*vm, std::string &fullname)
{
   SymbolViewer *rv =new SymbolViewer(vm, fullname);  



   return rv;
}
//-----------------------------------------------------------------------------------

void
SymbolViewer::
helpHeader(std::list<std::string> &help_text)
{
   help_text.push_back( "Viewing Symbols" );
   help_text.push_back("");
   help_text.push_back("  This window contains a hierarchy of symbols read from");
   help_text.push_back("  file or directory (or subtree) by the cpptagdb.exe");
   help_text.push_back("  program.  It lists the locations at which symbols are");
   help_text.push_back("  defined in files (not just declared, but defined.)");
   help_text.push_back("");
   help_text.push_back("  Each symbol is identified by name and type:");
   help_text.push_back("");
   help_text.push_back("    type names (classes, typedefs) etc are postfixed with {}");
   help_text.push_back("");
   help_text.push_back("    enums and #defines are postfixed with #");
   help_text.push_back("");
   help_text.push_back("    variables are identified by @");
   help_text.push_back("");
   help_text.push_back("    functions are annotated with ()");
   help_text.push_back("");
   help_text.push_back("  Use the Enter key to show the actual source of the symbol.");
   help_text.push_back("");
   help_text.push_back("  Use the =/+ keys to open and close one level of hierarchy");
   help_text.push_back("");
   help_text.push_back("  See below for more key definitions");
}


//-----------------------------------------------------------------------------------


}; // namespace cxxtls