etagsdb.cxx

Go to the documentation of this file.

/*
//  Copyright 1997, Lowell Boggs, all rights reserved.
//  Refer to the file, copyright, for a list of your rights.
*/
#include <portable_io.h>
#include <string.h>
#include <stdlib.h>


#include <cxxtls/etagsdb.h>

#ifdef _AIX
#include <strings.h>
#endif

#if !defined(_MSC_VER)
#define stricmp strcasecmp
#endif

extern "C"
{
  typedef int (*compare_func_t)(char const *l, char const *r);
};

namespace cxxtls
{


EtagsDB::
EtagsDB(std::string filename)
{
  filename_ = filename;

  file_ = fopen(filename.c_str(), "rb");

}

EtagsDB::
~EtagsDB()
{
  if(file_)
    fclose(file_);
}


bool
EtagsDB::
find_first(std::string const &symbol,
             std::string       *foundFile,
             int               *foundLine,
             std::string       *sourceText,
             bool               case_sensitive
            )
    /*
    **  etagsSearchFirst will return 1 only if the symbol is found in the
    **  the specified tagFile.  If a 1 is returned, the in foundFile will
    **  contain the name of a file_, and foundLine will contain the 1 based
    **  number of a line on which the symbol is defined.  In any other
    **  situation, a 0 will be returned.   sourceText is the text of the
    **  source line where etags recognized the function or macro defintion.
    **  It is returned to the caller so that in case the source file_ has been
    **  edited, and the line number has changed, the program can scan the
    **  source file_ for sourceText matching.  This text may have tabs in
    **  it and is not the complete line.
    */
{ /* search for a symbol in the specified tagFile */

    *foundLine = 0;
    *foundFile = "";

    if(file_ == 0)
      return false;

    fseek(file_, 0, SEEK_SET);

    case_sensitive_ = case_sensitive;

    symbol_ = symbol;

    return find_next(foundFile, foundLine, sourceText);

} /* search for a symbol in the specified tagFile */

#define issym(c) ( (c >= 'a' && c <= 'z') || \
                   (c >= 'A' && c <= 'Z') || \
                   (c >= '0' && c <= '9') || \
                    c == ':'              || \
                    c == '_'              || \
                    c == '~'                 \
                 )

int
EtagsDB::
searchFor(std::string const &symbol,
          std::string       *foundFile,
          int               *foundLine,
          std::string       *sourceText
         )
    /*
    **  this function reads lines from the tags file_ and parses that file_
    **  into information suitable for determining if the specified
    **  symbol is defined in a file_ which was read to produce the TAGS
    **  information.
    **
    **  this function returns 2 if end of tags file_ is encountered
    **  it returns 1 if the symbol is found
    **  it returns 0 if the symbol is not found but not eof
    */
{ /* searchFor() */

    char line[5000];
    char leader[5000];
    char *ptr;
    char tagName[5000];
    char definitionalLine[5000];
    char *scan;

    int symLength;
    int tagLength;

    tagName[0] = 0;
    definitionalLine[0] = 0;

    if(file_ == 0) return 2;  /* end of file_ without finding it */

    if(0 == fgets(line, 5000, file_) )
        {
            most_recent_file_[0] = 0;
            return 2;   /* end of file_ is a 2 */
        }

    if(line[0] == 0x0c)
        { /* this line is a delimiter which sets apart files */

            most_recent_file_[0] = 0;

            if(0 == fgets(line, sizeof(line), file_) )
                {
                    return 2;
                }

            sscanf(line, "%[^,\n]", most_recent_file_);

            return 0;

        } /* this line is a delimiter which sets apart files */

    for(scan = line, ptr=leader;
        *scan != 0 && *scan < 0x7f;
        *ptr++ = *scan++
        );

    *ptr = 0;

    ++scan;

    if( *scan > '9' )
        { /* full symbol name comes next */

            for(ptr = tagName; *scan >= ' '; *ptr++ = *scan++);

            *ptr = 0;

            ++scan;

            /* now we have the line number */

            for(ptr = definitionalLine; *scan >= ' '; *ptr++ = *scan++);

            *ptr = 0;

        } /* full symbol name comes next */
    else
        { /* line number text comes next */

            for(ptr = definitionalLine; 
                *scan >= ' ' && 
                  size_t(ptr-definitionalLine) < size_t(sizeof(definitionalLine)-1);
                *ptr++ = *scan++);

            if( size_t(ptr - definitionalLine) >= size_t(sizeof(definitionalLine)-1) )
            {
              return 0;  /* bad data */
            }
             
            *ptr = 0;

            ++scan;

            for(ptr = tagName; 
                *scan >= ' ' &&
                   size_t(ptr-tagName) < size_t(sizeof(tagName)-1);
                *ptr++ = *scan++);

            *ptr = 0;

        } /* line number text comes next */


    /*
    **  at this point, definitionalLine is defined, leader is define,
    **  and symbol is defined
    **
    **  Note that any one of these could be an empty string -- in particular
    **  the symbol name could be an empty string.
    */

    if(tagName[0] == 0)
        { /* etags.exe didn't put in a tagName:  find it in leader */

            for(scan=leader + strlen(leader);
                scan > leader && !issym(scan[-1]);
                --scan
              );

           while(scan > leader && issym(scan[-1]))
            {
                --scan;
            }

           for(ptr = tagName; issym(*scan); *ptr++ = *scan++);


           *ptr = 0;

        } /* etags.exe didn't put in a tagName:  find it in leader */


        compare_func_t compare_func;
        
        if(!case_sensitive_)
          compare_func = compare_func_t(stricmp);
        else
          compare_func = compare_func_t(strcmp);

        // check for an exact match

        if(symbol[0] == 0 || (*compare_func)(tagName, symbol.c_str()) == 0)
            {
                *foundFile = most_recent_file_;

                *sourceText = leader;

                *foundLine = atoi(definitionalLine);
                return 1;
            }

        {
          /*
          **  A simple direct comparison didn't work so try a more
          **  flexible algorithm
          */
        
          tagLength = strlen(tagName);
          symLength = strlen(symbol.c_str());
        
          bool e1 = tagLength > symLength;

          bool e2 = 0 == (*compare_func)(tagName + (tagLength - symLength),
                                         symbol.c_str());
        
          bool e3 = tagName[tagLength - symLength -1] == ':';
        
          if( e1 && e2 && e3 )
              {
                  *foundFile = most_recent_file_;
                  *sourceText= leader;
                  *foundLine = atoi(definitionalLine);
                  return 1;
              }
        }

    return 0;

} /* searchFor() */

bool
EtagsDB::
find_next(std::string       *foundFile,
          int               *foundLine,
          std::string       *sourceText
         )
{
    int rc = 0;

    while(rc == 0)
        {
            rc = searchFor(symbol_, foundFile, foundLine, sourceText);

        }

    if(rc == 1)
        {
            return true;
        }

    return false;
}

EtagsDB::
EtagsDB()
{
  file_ = 0;
}

bool
EtagsDB::
set_tags_file(std::string tags_file_name)
{
  if(file_)
  {
    fclose(file_);
  }

  filename_ = tags_file_name;

  file_ = fopen(tags_file_name.c_str(), "rb");

  return file_ == 0;
}

int
EtagsDB::
matching_files(std::string relpath, std::list<std::string> *matches) const
{
  if(relpath.size() && 
     (relpath[0] == '/' || 
       ( (relpath.size() > 2) && (relpath[1] == ':' ) )
     )
    )
  {
    matches->push_back(relpath);
    return 1;
  }

  if(file_ == 0)
    return 0;

  fseek(file_, 0, SEEK_SET);

  char line[5000];

  int count=0;


  for(;;)
  {

    if(0 == fgets(line, 5000, file_) )
    {
      // end of file

      return count;
    }

    if(line[0] == 0x0c)
    { /* this line is a delimiter which sets apart files */

      if(0 == fgets(line, sizeof(line), file_) )
      {
        // eof, missing filename

        return count;
      }

      char filename[5000];
      
      sscanf(line, "%[^,\n]", filename);

      std::string whole(filename);

      size_t rel_len = relpath.size();
      size_t whole_len = whole.size();

      if(rel_len == 0)
      {
        ++count;
        matches->push_back(whole);
      }
      else
      if(whole_len >= rel_len)
      {
        size_t offset = whole_len - rel_len;

        std::string tail = whole.substr(offset, whole_len);

        if(tail == relpath)
        {
          if(offset == 0 || whole[offset-1] == '/' || whole[offset-1] == '\\')
          {
            ++count;
            matches->push_back(whole);
          }
          
        }

      }


    } /* this line is a delimiter which sets apart files */
  }

  // you can't get here from there
}

} // namespace cxxtls