bibtex2bibtex.cc

Go to the documentation of this file.

/* bibtex2bibtex.cc */
/* program to sort the entries in a Bibtex file into separate files according
   to specific criteria */

/* Copyright (C) 2002 - 2009, Bernd Speiser */
/* This file is part of bibtex2bibtex.

bibtex2bibtex is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

bibtex2bibtex is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
  
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

#include <algorithm>
#include <iostream>
#include <sstream>
#include <fstream>
#include <vector>
#include <map>
#include <cstring>

#include "BibtexEntry.h"

using namespace bibtex2bibtex;

std::vector<BibtexEntry *> read_bibtexfile (std::ifstream &);

std::vector<std::string> tokenize_key (std::string key)
{
  std::vector<std::string> tokens;

  if (key.find_first_of ("/") == std::string::npos)
  {
    if (key.find_first_of ("_") == std::string::npos)
      std::cout << "illegal key structure: `" << key << "'" << std::endl;

    else
    {
      std::string token;

      token = key.substr (0, key.find_first_of ("_"));

      tokens.push_back (token);

      token =  key.substr (key.find_first_of ("_") + 1);

      tokens.push_back (token);
    }
  }

  else
  {
    std::string token;

    token = key.substr (0, key.find_first_of ("/"));

    tokens.push_back (token);

    std::string rest (key.substr ( key.find_first_of ("/") + 1));

    if (rest.find_first_of ("/") == std::string::npos)
    {
      if (rest.find_first_of ("_") == std::string::npos)
        std::cout << "illegal key structure: `" << key << "'" << std::endl;

      else
      {
        std::string token;

        token = rest.substr (0, rest.find_first_of ("_"));

        tokens.push_back (token);

        token =  rest.substr (rest.find_first_of ("_") + 1);

        tokens.push_back (token);
      }
    }

    else
    {
      std::string token;

      token = rest.substr (0, rest.find_first_of ("/"));

      tokens.push_back (token);

      std::string rest1 (rest.substr ( rest.find_first_of ("/") + 1));

      token = rest1.substr (0, rest1.find_first_of ("_") + 1);

      if (token != "etal_")
        std::cout << "illegal key structure: `" << key << "'" << std::endl;

      else
      {
        tokens.push_back (token);

        token =  rest1.substr (rest1.find_first_of ("_") + 1);

        tokens.push_back (token);
      }
    }
  }

  return tokens;
}

bool equal_keys (BibtexEntry *entry1, BibtexEntry *entry2)
{
  std::vector<std::string> tokens1;
  std::vector<std::string> tokens2;

  tokens1 = tokenize_key (entry1->key ());
  tokens2 = tokenize_key (entry2->key ());

  std::vector<std::string>::iterator stringtoken;

  for (stringtoken = tokens1.begin(); stringtoken < tokens1.end (); 
                                                          stringtoken++)
    transform ((*stringtoken).begin (), (*stringtoken).end (), 
                                      (*stringtoken).begin (), tolower);

  for (stringtoken = tokens2.begin(); stringtoken < tokens2.end (); 
                                                          stringtoken++)
    transform ((*stringtoken).begin (), (*stringtoken).end (), 
                                      (*stringtoken).begin (), tolower);

  if (tokens1.size () != tokens2.size ())
    return false;

  else
  {
    int i = 0;

    for (stringtoken = tokens1.begin(); stringtoken < tokens1.end (); 
                                                          stringtoken++)
    {
      if ((*stringtoken) != tokens2[i])
        return false;

      i++;
    }

    return true;
  }
}

class lessCopy {
public:
  bool operator () (const std::string &s1, const std::string &s2)
  {

    std::string t11 (s1.substr(0, s1.find_first_of ("0123456789")));
    std::string t21 (s2.substr(0, s2.find_first_of ("0123456789")));
  
    std::string rest1 ("");
    if (s1.find_first_of ("0123456789") != std::string::npos)
      rest1 = s1.substr(s1.find_first_of ("0123456789"));
  
    std::string rest2 ("");
    if (s2.find_first_of ("0123456789") != std::string::npos)
      rest2 = s2.substr(s2.find_first_of ("0123456789"));
  
  
    int i12;
    std::istringstream is1
          (rest1.substr (0, rest1.find_first_of (" ")));
    is1 >> i12;
    int i22;
    std::istringstream is2 
           (rest2.substr (0, rest2.find_first_of (" ")));
    is2 >> i22;
  
    std::string rest11 ("");
    if ((rest1.find_first_of (" ") != std::string::npos))
      rest11 = rest1.substr(rest1.find_first_of (" "));
  
    std::string rest21 ("");
    if ((rest2.find_first_of (" ") != std::string::npos))
      rest21 = rest2.substr(rest2.find_first_of (" "));
  
    std::string t13 (rest11);
    std::string t23 (rest21);
  
    return (t11 < t21) || (!(t21 < t11) && (i12 < i22))
              || (!(t21 < t11) && !(i22 < i12) && (t13 < t23));
  }
};

bool less_keys (BibtexEntry *entry1, BibtexEntry *entry2)
{
  std::vector<std::string> tokens1;
  std::vector<std::string> tokens2;

  tokens1 = tokenize_key (entry1->key ());
  tokens2 = tokenize_key (entry2->key ());

  std::vector<std::string>::iterator stringtoken;

  for (stringtoken = tokens1.begin(); stringtoken < tokens1.end (); 
                                                          stringtoken++)
    transform ((*stringtoken).begin (), (*stringtoken).end (), 
                                      (*stringtoken).begin (), tolower);

  for (stringtoken = tokens2.begin(); stringtoken < tokens2.end (); 
                                                          stringtoken++)
    transform ((*stringtoken).begin (), (*stringtoken).end (), 
                                      (*stringtoken).begin (), tolower);

  if (tokens1[0] != tokens2[0])
    return tokens1[0] < tokens2[0];

  else
  {
    if (tokens1.size () == tokens2.size ())
    {
      if (tokens1[1] != tokens2[1])
        return tokens1[1] < tokens2[1];

      else if ((tokens1.size () == 3) && tokens1[2] != tokens2[2])
         return tokens1[2] < tokens2[2];

      else if ((tokens1.size () == 4) && (tokens1[3] != tokens2[3]))
         return tokens1[3] < tokens2[3];

      else
        return false;
    }

    else if (tokens1.size () > tokens2.size ())
    {
      if (tokens2.size () == 2)
        return false;

      if (tokens2.size () == 3)
      {
        if (tokens1[1] == tokens2[1])
          return false;

        else
          return tokens1[1] < tokens2[1];
      }
    }

    else if (tokens1.size () < tokens2.size ())
    {
      if (tokens1.size () == 2)
        return true;

      if (tokens1.size () == 3)
      {
        if (tokens1[1] == tokens2[1])
          return true;

        else
          return tokens1[1] < tokens2[1];
      }
    }
  }
}

int main (int argc, char *argv[])
{
  if (argc == 1)
  {
    std::cout << "usage: bibtex2bibtex --version|--help         or"
         << std::endl
         << "       bibtex2bibtex [options] [-c criterion] -f inputfile"
         << " [-[p]m mergefile]" << std::endl;

    exit (1);
  }

  if (!strcmp (argv[1], "--version"))
  {
      std::cout << "bibtex2bibtex, version 1.3" << std::endl;

      exit (0);
  }

  if (!strcmp (argv[1], "--help"))
  {
    std::cout << "usage: bibtex2bibtex --version|--help         or"
         << std::endl
         << "       bibtex2bibtex [options] [-c criterion] -f inputfile"
         << " [-[p]m mergefile]" << std::endl;
    exit (0);
  }

  std::cout << "starting bibtex2bibtex - sorting and merging of "
       "BibTeX databases" << std::endl
       << "version 1.3, Copyright (C) 2002 - 2009, Bernd Speiser" << std::endl
       << "bibtex2bibtex comes with ABSOLUTELY NO WARRANTY; for details see"
       << std::endl
       << "the General Public License." << std::endl
       << "This is free software, and you are welcome to redistribute it"
       << std::endl
       << "under certain conditions; see the General Public License for "
          "details."
       << std::endl;

  bool verbose = false;
  bool newfile = false;
  bool count = false;
  bool duplicate_detect = false;
  bool generate_keys = false;
  bool pretend_merge = false;

  std::string criterion ("");
  std::string inputfile_name ("");
  std::string mergefile_name ("");

  std::ifstream input_file;
  std::ifstream merge_file;

  for (int i = 1; i < argc; i++)
  {
    if (!strcmp (argv[i], "--verbose") || !strcmp (argv[i], "-v"))
      verbose = true;

    else if (!strcmp (argv[i], "--genkey"))
      generate_keys = true;

    else if (!strcmp (argv[i], "--count"))
      count = true;

    else if (!strcmp (argv[i], "-n"))
      newfile = true;

    else if (!strcmp (argv[i], "-d"))
      duplicate_detect = true;

    else if (!strcmp (argv[i], "-f"))
    {
      i++;

      input_file.open (argv[i]);

      if (!input_file)
      {
        std::cout << "can't open file: " << argv[i] << std::endl;

        exit (1);
      }

      inputfile_name = argv[i];

      if (verbose)
        std::cout << "input file `" << inputfile_name 
                                             << "' opened" << std::endl;
    }

    else if ((!strcmp (argv[i], "-m")) || (!strcmp (argv[i], "-pm")))
    {
     if (!strcmp (argv[i], "-pm"))
       pretend_merge = true;

      i++;

      merge_file.open (argv[i]);

      if (!merge_file)
      {
        std::cout << "can't open file to merge: " << argv[i] << std::endl;

        exit (1);
      }

      mergefile_name = argv[i];

      if (verbose)
        std::cout << "merge file `" << mergefile_name 
                                             << "' opened" << std::endl;
    }

    else if (!strcmp (argv[i], "-c"))
    {
      i++;

      criterion = argv[i];

      if (criterion != "coworkers" && criterion != "key" 
                           && criterion != "source" && criterion != "copy")
      {
        std::cout << "no or illegal criterion given" << std::endl; 

        exit (1);
      }
    }
  }

  if (inputfile_name == "")
  {
    std::cout << "no input file given" << std::endl;

    exit (1);
  }

  std::vector <BibtexEntry *> entries;

  entries = read_bibtexfile (input_file);

  if (count || verbose)
    std::cout << entries.size () << " entries found in file " 
                                         << inputfile_name << std::endl;

  std::vector <BibtexEntry *>::const_iterator entry;

  if (generate_keys)
  {
    std::string newkey;
    std::string oldkey;
    std::string authors;
    std::string year;
 
    for (entry = entries.begin (); entry < entries.end (); entry++)
    {
      oldkey = (*entry)->key ();

      if (oldkey.empty ())
      {
        newkey = "";

        authors = (*entry)->authors ();

        std::string::size_type and_token;
        std::string::size_type komma;
        std::string::size_type blank;
        std::string::size_type begin;

        std::string rest = authors;

        if (!authors.empty ())
        {
          std::vector<std::string> names;

          for (;;)
          {
            and_token = rest.find (" and ");
            begin = rest.find_first_not_of (" ");

            if (and_token == std::string::npos)
            {
              names.push_back (rest);
    
              break;
            }

            else
            {
              names.push_back (rest.substr (0, and_token - begin));

              rest = rest.substr (and_token + 5);
            }
          }

          std::vector<std::string>::const_iterator name;

          bool first = true;
          int number = 0;

          for (name = names.begin (); name < names.end (); name++)
          {
            number++;

            if (number <= 2)
            {
              komma = (*name).find_first_of (",");

              if (komma == std::string::npos)
              {
                blank = (*name).find_first_of (" ");

                if (first)
                  first = false;

                else
                  newkey += "/";

                newkey += (*name).substr (blank + 1);
              }

              else
              {
                if (first)
                  first = false;

                else
                  newkey += "/";

                newkey += (*name).substr (0, blank);
              }
            }

            else
            {
              newkey += "/etal";

              break;
            }
          }
        }

        year = (*entry)->year ();

        if (!year.empty ())
          newkey = newkey + "_" + year;

        (*entry)->key (newkey);
      }
    }

    std::ofstream outputfile;

    std::string outputfile_name;

    if (newfile)
      outputfile_name = inputfile_name + ".key";

    else
      outputfile_name = inputfile_name;

    outputfile.open (outputfile_name.c_str ());

    int entrynumber = 0;

    for (entry = entries.begin (); entry < entries.end (); entry++)
    { 
      if (verbose)
        std::cout << "writing entry " << ++entrynumber << " to file " << 
                                  outputfile_name.c_str () << std::endl;

      (*entry)->output (outputfile);
    }
  }

  std::string coworkers;

  if (criterion == "coworkers")
  {
    for (entry = entries.begin (); entry < entries.end (); entry++)
    {
      coworkers = (*entry)->coworkers ();  

      std::string::size_type coworker_begin;
      std::string::size_type coworker_end;

      std::string coworker;

      bool last = false;

      for (;;)
      {
        coworker_begin = coworkers.find_first_not_of (" ,");

        if (coworker_begin == std::string::npos)
          break;

        coworker_end = coworkers.find_first_of (",");

        if (coworker_end == std::string::npos)
        {
          coworker = coworkers.substr (coworker_begin);

          coworkers = "";

          last = true;;
        }

        else
        {
          coworker 
             = coworkers.substr 
                        (coworker_begin, coworker_end - coworker_begin);

          coworkers = coworkers.substr (++coworker_end);
        }

        std::ofstream outputfile;

        std::string outputfile_name = inputfile_name + "." + coworker;

        outputfile.open 
              (outputfile_name.c_str (), std::ios::out | std::ios::app);

        (*entry)->output (outputfile);

        outputfile.close ();

        if (last)
          break;
      }
    }
  }

  else if (criterion == "key")
  {
    if (merge_file)
    {
      std::vector<BibtexEntry *> merge_entries;

      merge_entries = read_bibtexfile (merge_file);

      if (count || verbose)
        std::cout << merge_entries.size () << " entries found in merge file "
                                         << mergefile_name << std::endl;

      std::vector<BibtexEntry *>::const_iterator merge_entry;
      std::vector<BibtexEntry *>::const_iterator entry;

      if (verbose)
        std::cout << "starting duplicate detection comparing input and "
                                            "merge files " << std::endl;

      std::ofstream merge_duplicatefile;
      int duplicate_number = 0;
      bool duplicatesfile_open = false;

      std::ofstream merge_includefile;
      int include_number = 0;
      bool includesfile_open = false;

      for (merge_entry = merge_entries.begin (); 
                      merge_entry < merge_entries.end (); merge_entry++)
      {
        bool duplicates_found;

        for (entry = entries.begin (); entry < entries.end (); entry++)
        {
          duplicates_found = false;

          if (equal_keys (*entry, *merge_entry))
          {
            duplicates_found = true;

            duplicate_number++;

            if (!duplicatesfile_open)
            {
              std::string merge_duplicatefile_name (mergefile_name);

              merge_duplicatefile_name += ".merge_duplicates";

              merge_duplicatefile.open 
                                    (merge_duplicatefile_name.c_str ());

              duplicatesfile_open = true;
            }

            std::cout << "duplicate found comparing input and merge "
                    " files for key " << (*merge_entry)->key () 
                                                            << std::endl
                   << "entry not merged, writing duplicate to file " 
                                                           << std::endl;

            (*merge_entry)->output (merge_duplicatefile);

            break;
          }
        }

        if (pretend_merge && !duplicates_found)
        {
          ++include_number;

          if (!includesfile_open)
          {
            std::string merge_includefile_name (mergefile_name);

            merge_includefile_name += ".merge_includes";

            merge_includefile.open 
                                  (merge_includefile_name.c_str ());

            includesfile_open = true;
          }

          if (verbose)
            std::cout << "entry with key " << (*merge_entry)->key () << 
                " not found, writing to include file" << std::endl;

          (*merge_entry)->output (merge_includefile);
        }
   
        else if (!pretend_merge)
        {
          if (verbose)
            std::cout << "entry with key " << (*merge_entry)->key () << 
                         " not found, storing for output" << std::endl;

          if(!duplicates_found)
            entries.push_back (*merge_entry);
        }
      }

      if (verbose)
      {
        if (duplicate_number > 0)
          std::cout << duplicate_number 
            << " duplicate entries from file " 
                      << mergefile_name << " not merged  " << std::endl;

        if (include_number > 0)
          std::cout << include_number << " entries from file " 
             << mergefile_name << " found for including  " << std::endl;
      }
    }

    sort (entries.begin (), entries.end (), less_keys);

    std::vector<BibtexEntry *>::const_iterator firstentry;
    std::vector<BibtexEntry *>::const_iterator secondentry;

    if (duplicate_detect)
    {
      if (verbose)
        std::cout << "starting duplicate detection in file `" 
                                  << inputfile_name << "'" << std::endl;

      std::ofstream duplicatefile;

      bool duplicates_found;

      for (firstentry = entries.begin (); 
                          firstentry < entries.end () - 1; firstentry++)
      {
        if (verbose)
          std::cout << "scanning for key `" << (*firstentry)->key () 
                                                    << "'" << std::endl;

        duplicates_found = false;

        for (secondentry = firstentry + 1; secondentry < entries.end ();
                                                          secondentry++)
        {
          if (equal_keys (*firstentry, *secondentry))
          {
            if (!duplicates_found)
            {
              std::string duplicatefile_name (inputfile_name);

              duplicatefile_name += ".duplicates";

              duplicatefile.open (duplicatefile_name.c_str ());

              duplicates_found = true;
            }

            if (verbose)
              std::cout << "duplicates detected, keys " 
                                   << (*firstentry)->key ()<< std::endl;

            (*firstentry)->output (duplicatefile);
            (*secondentry)->output (duplicatefile);

          }       
        }
      }
    }


    std::ofstream outputfile;

    std::string outputfile_name;

    if (!pretend_merge)
    {
      if (newfile)
        outputfile_name = inputfile_name + ".sorted";

      else
        outputfile_name = inputfile_name;

      outputfile.open (outputfile_name.c_str ());

      int entrynumber = 0;

      for (entry = entries.begin (); entry < entries.end (); entry++)
      { 
        if (verbose)
          std::cout << "writing entry " << ++entrynumber << 
                   " to file " << outputfile_name.c_str () << std::endl;

        (*entry)->output (outputfile);
      }
    }
  }

  else if (criterion == "copy")
  {
    std::string copies;

    std::multimap<std::string, std::string, lessCopy> copymap;

    for (entry = entries.begin (); entry < entries.end (); entry++)
    {
      copies = (*entry)->copy ();
      if (verbose)
        std::cout << "read copy field: `" << copies << "'" << std::endl;

      if (copies != "")
      {
        std::string::size_type copy_begin;
        std::string::size_type copy_end;

        std::string copy;

        bool last = false;

        for (;;)
        {
          copy_begin = copies.find_first_not_of (" ;");

          if (copy_begin == std::string::npos)
            break;

          copy_end = copies.find_first_of (";");

          if (copy_end == std::string::npos)
          {
            copy = copies.substr (copy_begin);

            copies = "";

            last = true;;
          }

          else
          {
            copy 
               = copies.substr 
                          (copy_begin, copy_end - copy_begin);

            copies = copies.substr (++copy_end);
          }

          if (verbose)
            std::cout << "`" << copy << "'" << std::endl;

          copymap.insert (std::make_pair(copy, (*entry)->key()));

          if (last)
            break;
        }
      }

      else
        if (verbose)
          std::cout << " empty or missing copy field; entry ignored" 
                                                         << std::endl;
    }

    if (verbose)
      std::cout << " number of individual copy entries: " 
                                   << copymap.size () << std::endl;

    std::ofstream outputfile;

    std::string outputfile_name = inputfile_name + ".copies";

    outputfile.open 
                (outputfile_name.c_str (), std::ios::out | std::ios::app);

    std::multimap<std::string, std::string, lessCopy>::iterator copymap_output;
    for (copymap_output = copymap.begin (); 
             copymap_output != copymap.end (); copymap_output++)
    {
      outputfile << copymap_output->first << "      " 
                            << copymap_output->second << std::endl;
    }

    outputfile.close ();

    if (duplicate_detect)
    {
      if (verbose)
        std::cout << "starting duplicate detection within copies"
                                                         << std::endl;
  
      std::ofstream duplicatefile;
  
      std::string duplicatefile_name = inputfile_name + ".duplicates";
  
      duplicatefile.open 
            (duplicatefile_name.c_str (), std::ios::out | std::ios::app);
  
      std::map<std::string, std::string, lessCopy>::iterator 
                                                            copymap_entry1;
      std::map<std::string, std::string, lessCopy>::iterator 
                                                            copymap_entry2;
      std::map<std::string, std::string, lessCopy>::iterator copymap_store;
  
      for (copymap_entry1 = copymap.begin (); 
               copymap_entry1 != copymap.end (); copymap_entry1++)
      {
        std::string copy1;
        if (copymap_entry1->first.find_first_of ("0123456789") 
                                                        != std::string::npos)
       {
         std::string part1 (copymap_entry1->first.substr(0, 
                          copymap_entry1->first.find_first_of ("0123456789")));
         std::string rest (copymap_entry1->first.substr(
                          copymap_entry1->first.find_first_of ("0123456789")));
          if((rest.find_first_of (" ")) != std::string::npos)
          {
            std::string part2 (rest.substr(0, rest.find_first_of (" ")));
            copy1 = part1 + part2;
          }
          else
           copy1 = copymap_entry1->first; 
        }
        else
        {
          copy1 = copymap_entry1->first;
        }

        copymap_store = copymap_entry1;
        copymap_store++;
        for (copymap_entry2 = copymap_store; 
               copymap_entry2 != copymap.end (); copymap_entry2++)
        {
          std::string copy2;
          if (copymap_entry2->first.find_first_of ("0123456789") 
                                                     != std::string::npos)
          {
            std::string part1 (copymap_entry2->first.substr(0, 
                          copymap_entry2->first.find_first_of ("0123456789")));
            std::string rest (copymap_entry2->first.substr(
                          copymap_entry2->first.find_first_of ("0123456789")));
            if((rest.find_first_of(" ")) != std::string::npos)
            {
              std::string part2 (rest.substr(0, rest.find_first_of (" ")));
              copy2 = part1 + part2;
            }
            else
             copy2 = copymap_entry2->first; 
          }
          else
          {
            copy2 = copymap_entry2->first;
          }

          if (copy1 == copy2)
          {
            duplicatefile << "duplicated copy label: " << 
              copy1 << " for entries " << 
                copymap_entry1->second << " and " << 
                                   copymap_entry2->second << std::endl;
            break;
          }
        }
      }
    }
  }

  else if (criterion == "source")
  {
    std::string source;
    std::string clean_source;

    for (entry = entries.begin (); entry < entries.end (); entry++)
    {
      clean_source = "";

      source = (*entry)->source ();  

      std::string::size_type source_token_begin;
      std::string::size_type source_token_end;

      source_token_begin = source.find_first_not_of (" ");

      if (source_token_begin != std::string::npos)
      {
        for (;;)
        {
          source_token_end 
                       = source.find_first_of (" ", source_token_begin);

          if (source_token_end == std::string::npos)
          {
            clean_source += source.substr (source_token_begin);

            break;
          }

          else
          {
            clean_source 
              += source.substr (source_token_begin, 
                                 source_token_end - source_token_begin);

            source_token_begin = source_token_end + 1;
          }
        }
      }

      std::ofstream outputfile;

      std::string outputfile_name = inputfile_name + "." + clean_source;

      outputfile.open 
              (outputfile_name.c_str (), std::ios::out | std::ios::app);

      (*entry)->output (outputfile);

      outputfile.close ();
    }
  }

  exit (0);
}

std::ofstream & BibtexEntry::output (std::ofstream &outputfile)
{
  outputfile << text <<std::endl;
}

std::string BibtexEntry::source (void)
{
  return field ("journal");
}

std::string BibtexEntry::authors (void)
{
  return field ("author");
}

std::string BibtexEntry::year (void)
{
  return field ("year");
}

std::string BibtexEntry::copy (void)
{
  return field ("copy");
}

std::string BibtexEntry::coworkers (void)
{
  return field ("coworkers");
}

std::string BibtexEntry::field (std::string label)
{
  std::string field;

  field = "";

  std::string::size_type pointer = 0;

  int counter;

  pointer = text.find (label, pointer);

  while (pointer != std::string::npos)
  {
    pointer += label.length();
    pointer = text.find_first_not_of (" \n\t", pointer);

    if ((pointer != std::string::npos) && (text.at(pointer) == '='))
    {
      pointer = text.find_first_not_of (" \n\t", ++pointer);

      counter = 0;

      if ((pointer != std::string::npos) && (text.at(pointer) == '{'))
      {
        std::string::size_type begin = ++pointer;
        ++counter;
        for (std::string::size_type i = pointer; ; ++i)
        {
          if (text.at(i) == '{')
            ++counter;
          else if (text.at(i) == '}')
            --counter;
          
          if (counter == 0)
          {   
            field = text.substr (begin, i - begin);
            break;
          }
        }
        break;
      }
      break;
    }
    break;
  }

  return field;
}

std::string BibtexEntry::key (void)
{
  std::string::size_type key_line_begin;
  std::string::size_type key_begin;
  std::string::size_type key_end;

  std::string key;

  key_line_begin = text.find ("@");

  if (key_line_begin != std::string::npos)
  {
    std::string rest = text.substr (key_line_begin);

    key_begin = rest.find ("{"); 
    key_end = rest.find (","); 

    key = rest.substr (key_begin + 1, key_end - key_begin - 1);
  }

  else
    key = "";


  return key;
}

void BibtexEntry::key (std::string key)
{
  std::string rest;

  std::string::size_type begin_key;
  std::string::size_type end_key;

  begin_key = text.find_first_of ("@");
  begin_key = text.find_first_of ("{", begin_key + 1);

  end_key = text.find_first_of (",", begin_key + 1);

  std::string replace_string = "{" + key + ",";

  text.replace 
          (begin_key, end_key - begin_key + 1, replace_string.c_str ());
}

std::vector<BibtexEntry *> read_bibtexfile (std::ifstream &file)
{
  std::vector<BibtexEntry *> entries;

  BibtexEntry *newentry;

  const int buffersize = 1000;

  char buffer[buffersize];

  int entry_counter = 0;

  int line_number = 0;

  std::string bufferstring;

  while (file.getline (buffer, buffersize))
  {
    line_number++;

    if (strncmp (buffer, "}", 1))
    {
      bufferstring += buffer;

      bufferstring += '\n';
    }

    else
    {
      bufferstring += "}";

      newentry = new BibtexEntry (bufferstring);

      entries.push_back (newentry);

      bufferstring = "";
    }
  }

  return entries;
}

---