cpptagdb.cxx

Go to the documentation of this file.

//
// Copyright 2012, Lowell Boggs Jr.
//
// This file or directory, containing source code for a computer program,
// is Copyrighted by Lowell Boggs, Jr.  987 Regency Drive, Lewisville
// TX (USA), 75067.  You may use, copy, modify, and distribute this
// source file without charge or obligation so long as you agree to
// the following:
//
//  1.  You must indemnify Lowell Boggs against any and all financial
//      obligations caused by its use, misuse, function, or malfunction.
//      Further, you acknowledge that there is no warranty of any kind,
//      whatsoever.
//
//  2.  You agree not to attempt to patent any portion of this original
//      work -- though you may attempt to patent your own extensions to
//      it if you so choose.
//
//  3.  You keep this copyright notice with the file and all copies
//      of the file and do not change it anyway except language translation.
//
// You are responsible for enforcing your own compliance with these
// conditions and may not use this source file if you cannot agree to the
// above terms and conditions.

#include <cxxtls/strtool.h>
#include <BIscan/BIscan.h>
#include <cxxtls/cpptagdb.h>
#include <errno.h>
#include <cxxtls/file.h>
#include <cxxtls/foreach.h>


using namespace std;

namespace cxxtls
{
namespace CppTagDB
{


void 
SymbolInfo::
output(std::ostream &s, std::string indent) const
       {
          // s << file_ << ':' << line_ << ' ' << type_ << ' ' << fullname_;

          s << indent << annotatedName(true) << "\t\t" << file_ << ':' << line_;
          
          const_iterator first= children_.begin(),
                         last = children_.end();


          if(first != last)
          {
              indent += "      ";
          }

          while(first != last)
          {
             s << '\n';

             first->second.output(s, indent);
   
             ++first;
   
          }
   
       }


SymbolInfo::Type 
SymbolInfo::
computeTypeId(std::string const &typeName)
       {
            using namespace std;

            Type scopeType = unknownType;

            static string function_id("function");
            static string class_id("class");
            static string struct_id("struct");
            static string enum_id("enum");
            static string enumeration_id("enumeration");
            static string typedef_id("typename");
            static string namespace_id("namespace");
            static string used_id("used");
            static string variable_id("variable");
            static string union_id("union");
            static string define_id("define");

            if(typeName.empty())
              return scopeType;

            char firstLetter = typeName[0];

            if(firstLetter == 'd' &&  define_id == typeName)
               scopeType = Enumeration;
            else
            if(firstLetter == 'e' &&  enum_id == typeName)
               scopeType = Enum;
            else
            if(firstLetter == 'e' &&  enumeration_id == typeName)
               scopeType = Enumeration;
            else
            if(firstLetter == 'f' &&  function_id == typeName)
               scopeType = Function;
            else
            if(firstLetter == 's' &&  struct_id == typeName)
               scopeType = Class;
            else
            if(firstLetter == 'u' &&  union_id == typeName)
               scopeType = Class;
            else
            if(firstLetter == 'c' &&  class_id == typeName)
               scopeType = Class;
            else
            if(firstLetter == 't' &&  typedef_id == typeName)
               scopeType = Typedef;
            else
            if(firstLetter == 'n' &&  namespace_id == typeName)
               scopeType = Namespace;
            else
            if(firstLetter == 'u' &&  used_id == typeName)
               scopeType = Used;
            else
            if(firstLetter == 'v' &&  variable_id == typeName)
               scopeType = Variable;

            return scopeType;

       }


char SymbolInfo::typeChar() const 
       {
          switch(typeId_)
          {
             case   Function:    return 'f';
             case   Variable:    return 'v';
             case   Class:       return 'c';
             case   Enum:        return 'e';
             case   Enumeration: return '#'; 
             case   Typedef:     return 't';
             case   Namespace:   return 'n';
             case   FileScope:   return 'F';
             case   Used:        return 'u';
             case   Define:      return 'd';
    
             default: break;
    
          }
    
          return '?';
       }


std::string 
SymbolInfo::
annotatedName(bool member) const 
       {

          using namespace std;

          string const *name = &fullname_;

          if(member)
             name = &member_;

          switch(typeId_)
          {
             case   Function:    return *name + " ()";
             case   Variable:    return *name + "  @";
             case   Class:       return *name + " {}";
             case   Enum:        return *name + "  %";
             case   Enumeration: return *name + "  #"; 
             case   Typedef:     return *name + " {}";
             case   Namespace:   return *name + " {}";
             case   FileScope:   return *name + "  /";
          
             default: break;
          
          }

          if( name->empty() )
             return "::";
          
          return *name;

       }

int 
Info::
populate(std::string const &filename, int &failedLine)
    {
        FILE *f = fopen(filename.c_str(), "r");

        if(!f)
           return -1;

        int rc = populate(f, failedLine);

        fclose(f);

        return rc;
    }



int 
Info::
populate(FILE *f, int &failedLine)
    {

        if(!f)
           return -1;

        using namespace std;

        failedLine=0;

        char buffer[10000];

        errno = 0;

        string filename;


        while(fgets(buffer, sizeof(buffer)-1, f))
        {
           ++failedLine;

           buffer[ strlen(buffer)-1] = 0; // remove training \n


           if(buffer[0] == '+')
           {
              filename = buffer+1;

              directories_.insert( FileName(filename).dirname() );

              size_t sep = filename.find_last_of("/\\");

              if(sep >= filename.size())
                 files_.insert( pair<string,string>(filename,filename));
              else
              {
                 pair<string,string> entry;

                 entry.second = filename;
                 entry.first  = filename.substr(sep+1, filename.size() - sep - 1);

                 files_.insert(entry);




              }
           }
           else
           if(buffer[0] == '-')
           {

              if( populateSymbol(filename, buffer+1) )
                 return -2;
           }
            
        }

        if(errno)
           return -1;

        return 0;
    }


void 
Info::
findMatchingFiles(string const &fileNodeName, vector<string> &output) const
{
    pair<FilesMap::const_iterator, FilesMap::const_iterator> range;

    range = files_.equal_range(fileNodeName);

    while(range.first != range.second)
    {
       output.push_back(range.first->second);
       ++range.first;
    }


}

void 
Info::
findRelativeFiles(string const &fileNodeName, vector<string> &output) const
{

   CXXTLS_FOREACH(FileName cur, directories_)
   {
      cur += fileNodeName;


      if(cur.exists())
      {
         output.push_back(cur);
      }
   }
   

}


void 
Info::
findMatchingMembers(string const &memberName, vector<SymbolInfo const*> &output, bool caseSensitive) const
{
    if(caseSensitive)
    {
        pair<MembersMap::const_iterator, MembersMap::const_iterator> range;
        
        range = members_.equal_range(memberName);
        
        while(range.first != range.second)
        {
           SymbolInfo const* cur = range.first->second;

           if(cur->line_ != 0)
           {
               output.push_back(cur);
           }
           ++range.first;
        }
    }
    else
    {
        // case insensitive comparison

        pair<MembersMap::const_iterator, MembersMap::const_iterator> range;
        
        range.first   = members_.begin();
        range.second  = members_.end();
        
        while(range.first != range.second)
        {
           if(StrTool::compareInsensitive(memberName, range.first->first) == 0)
             {
               SymbolInfo const* cur = range.first->second;

               if(cur->line_ != 0)
               {
                   output.push_back(cur);
               }
             }

           ++range.first;
        }

    }
}


std::ostream &
operator<< (std::ostream &s, Info const &me)
    {
       SymbolInfo::const_iterator first= me.symbols_.children_.begin(),
                                  last = me.symbols_.children_.end();

       while(first != last)
       {
          s << first->second << std::endl;

          ++first;
       }


       return s;
    }

int 
Info::
populateSymbol(std::string const &filename, std::string const &info)
    {
        using namespace std;

        string type;
        string name;
        string operatorTypeOrLineNumber;
        string lineNumber;
        int    line=0;

        BIscan::stream(info) >> type >> name >> operatorTypeOrLineNumber >> lineNumber;

        if(lineNumber.empty())
        {
           BIscan::stream(operatorTypeOrLineNumber) >> line;
        }
        else
        {
           char c = operatorTypeOrLineNumber[0];

           if( isalnum(c) || c == '_')
           {
              name += ' ';
           }
           
           name += operatorTypeOrLineNumber;

           BIscan::stream(lineNumber) >> line;
        }


        vector<string> component;

        size_t components = StrTool::splitOnString(name, component, "::");

        if(components == 0)
        {
          return -1;
        }

        // make sure parent object exists

        SymbolInfo *parent = &symbols_;

        string fullParentName;

        for(size_t i = 0; i < components-1; ++i)
        {
           string const &compName = component[i];

           fullParentName += "::";
           fullParentName += compName;

           SymbolInfo parentInfo(fullParentName, compName, "namespace", "", 0);  // parent's should exist, so
                                                                                 // if they don't, we shouldn't
                                                                                 // force a name, type, and line
                                                                                 // number here.

           SymbolInfo::iterator where;
           
           where = parent->children_.find(compName);

           if(where != parent->children_.end())
           {
              // parent exists, like it should

              parent = &where->second;

           }
           else
           {
              where = parent->children_.insert( SymbolInfo::Children::value_type(compName, parentInfo));

              parent = &where->second;

              members_.insert( MembersMap::value_type( compName, &where->second ) );
                                

           }

        }

        // insert this new child symbol under its parent

        if(!type.empty() && type[0] == 'n')
        {
            //
            //  don't add duplicate namespaces, but all other types should be 
            //  inserted as they encountered.
            //

            SymbolInfo::iterator where = parent->children_.find(component.back());

            while(where != parent->children_.end())
            {
               if(where->first != component.back())
                   break;

               if(where->second.typeId_ == SymbolInfo::Namespace
                 )
               {
                  // we have a symbol by the same name and it is also a
                  // namespace

                  return 0;
               }

               ++where;

            }


        }

        // if we get here, either the type is not namespace or there is no existing
        // namespace by that name in the parent

        SymbolInfo::Children::iterator where;
        
        where = 
        parent->children_.insert( SymbolInfo::Children::value_type(component.back(), 
                                                                   SymbolInfo(name,
                                                                              component.back(),
                                                                              type,
                                                                              filename,
                                                                              line
                                                                             ) 
                                                                  )
                                );

        members_.insert( MembersMap::value_type( component.back(), &where->second ) );
        

        return 0;
    }



} // namespace CppTagDB
} // namespace cxxtls