Source/CTest/cmCTestBZR.cxx - third_party/cmake - Git at Google

 /*============================================================================
   CMake - Cross Platform Makefile Generator
   Copyright 2000-2009 Kitware, Inc.

   Distributed under the OSI-approved BSD License (the "License");
   see accompanying file Copyright.txt for details.

   This software is distributed WITHOUT ANY WARRANTY; without even the
   implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
   See the License for more information.
 ============================================================================*/
 #include "cmCTestBZR.h"

 #include "cmCTest.h"
 #include "cmSystemTools.h"
 #include "cmXMLParser.h"

 #include <cmsys/RegularExpression.hxx>

 #include <cm_expat.h>

 //----------------------------------------------------------------------------
 extern "C"
 int cmBZRXMLParserUnknownEncodingHandler(void*,
                                          const XML_Char *name,
                                          XML_Encoding *info)
 {
   static const int latin1[]=
     {
       0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
       0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
       0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
       0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
       0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
       0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
       0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
       0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
       0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
       0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
       0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
       0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
       0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
       0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
       0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
       0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
       0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
       0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
       0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
       0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
       0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
       0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
       0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
       0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
       0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
       0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
       0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
       0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
       0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
       0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
       0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
       0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
     };

   // The BZR xml output plugin can use some encodings that are not
   // recognized by expat.  This will lead to an error, e.g. "Error
   // parsing bzr log xml: unknown encoding", the following is a
   // workaround for these unknown encodings.
   if(name == std::string("ascii") || name == std::string("cp1252") ||
      name == std::string("ANSI_X3.4-1968"))
     {
     for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
     return 1;
     }

   return 0;
 }

 //----------------------------------------------------------------------------
 cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
   cmCTestGlobalVC(ct, log)
 {
   this->PriorRev = this->Unknown;
   // Even though it is specified in the documention, with bzr 1.13
   // BZR_PROGRESS_BAR has no effect. In the future this bug might be fixed.
   // Since it doesn't hurt, we specify this environment variable.
   cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none");
 }

 //----------------------------------------------------------------------------
 cmCTestBZR::~cmCTestBZR()
 {
 }

 //----------------------------------------------------------------------------
 class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
 {
 public:
   InfoParser(cmCTestBZR* bzr, const char* prefix):
     BZR(bzr), CheckOutFound(false)
     {
     this->SetLog(&bzr->Log, prefix);
     this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
     this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
     }
 private:
   cmCTestBZR* BZR;
   bool CheckOutFound;
   cmsys::RegularExpression RegexCheckOut;
   cmsys::RegularExpression RegexParent;
   virtual bool ProcessLine()
     {
     if(this->RegexCheckOut.find(this->Line))
       {
       this->BZR->URL = this->RegexCheckOut.match(1);
       CheckOutFound = true;
       }
     else if(!CheckOutFound && this->RegexParent.find(this->Line))
       {
       this->BZR->URL = this->RegexParent.match(1);
       }
     return true;
     }
 };

 //----------------------------------------------------------------------------
 class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
 {
 public:
   RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
     Rev(rev)
     {
     this->SetLog(&bzr->Log, prefix);
     this->RegexRevno.compile("^([0-9]+)$");
     }
 private:
   std::string& Rev;
   cmsys::RegularExpression RegexRevno;
   virtual bool ProcessLine()
     {
     if(this->RegexRevno.find(this->Line))
       {
       this->Rev = this->RegexRevno.match(1);
       }
     return true;
     }
 };

 //----------------------------------------------------------------------------
 std::string cmCTestBZR::LoadInfo()
 {
   // Run "bzr info" to get the repository info from the work tree.
   const char* bzr = this->CommandLineTool.c_str();
   const char* bzr_info[] = {bzr, "info", 0};
   InfoParser iout(this, "info-out> ");
   OutputLogger ierr(this->Log, "info-err> ");
   this->RunChild(bzr_info, &iout, &ierr);

   // Run "bzr revno" to get the repository revision number from the work tree.
   const char* bzr_revno[] = {bzr, "revno", 0};
   std::string rev;
   RevnoParser rout(this, "revno-out> ", rev);
   OutputLogger rerr(this->Log, "revno-err> ");
   this->RunChild(bzr_revno, &rout, &rerr);

   return rev;
 }

 void cmCTestBZR::NoteOldRevision()
 {
   this->OldRevision = this->LoadInfo();
   this->Log << "Revision before update: " << this->OldRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   Old revision of repository is: "
              << this->OldRevision << "\n");
   this->PriorRev.Rev = this->OldRevision;
 }

 //----------------------------------------------------------------------------
 void cmCTestBZR::NoteNewRevision()
 {
   this->NewRevision = this->LoadInfo();
   this->Log << "Revision after update: " << this->NewRevision << "\n";
   cmCTestLog(this->CTest, HANDLER_OUTPUT, "   New revision of repository is: "
              << this->NewRevision << "\n");
   this->Log << "URL = " << this->URL << "\n";
 }

 //----------------------------------------------------------------------------
 class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
                              private cmXMLParser
 {
 public:
   LogParser(cmCTestBZR* bzr, const char* prefix):
     OutputLogger(bzr->Log, prefix), BZR(bzr),
     EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
     { this->InitializeParser(); }
   ~LogParser() { this->CleanupParser(); }

   virtual int InitializeParser()
      {
      int res = cmXMLParser::InitializeParser();
      if (res)
        {
        XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
                                      cmBZRXMLParserUnknownEncodingHandler, 0);
        }
      return res;
      }
 private:
   cmCTestBZR* BZR;

   typedef cmCTestBZR::Revision Revision;
   typedef cmCTestBZR::Change   Change;
   Revision Rev;
   std::vector<Change> Changes;
   Change CurChange;
   std::vector<char> CData;

   cmsys::RegularExpression EmailRegex;

   virtual bool ProcessChunk(const char* data, int length)
     {
     this->OutputLogger::ProcessChunk(data, length);
     this->ParseChunk(data, length);
     return true;
     }

   virtual void StartElement(const std::string& name, const char**)
     {
     this->CData.clear();
     if(name == "log")
       {
       this->Rev = Revision();
       this->Changes.clear();
       }
     // affected-files can contain blocks of
     // modified, unknown, renamed, kind-changed, removed, conflicts, added
     else if(name == "modified"
             || name == "renamed"
             || name == "kind-changed")
       {
       this->CurChange = Change();
       this->CurChange.Action = 'M';
       }
     else if(name == "added")
       {
       this->CurChange = Change();
       this->CurChange = 'A';
       }
     else if(name == "removed")
       {
       this->CurChange = Change();
       this->CurChange = 'D';
       }
     else if(name == "unknown"
             || name == "conflicts")
       {
       // Should not happen here
       this->CurChange = Change();
       }
     }

   virtual void CharacterDataHandler(const char* data, int length)
     {
     this->CData.insert(this->CData.end(), data, data+length);
     }

   virtual void EndElement(const std::string& name)
     {
     if(name == "log")
       {
       this->BZR->DoRevision(this->Rev, this->Changes);
       }
     else if(!this->CData.empty() &&
             (name == "file" || name == "directory"))
       {
       this->CurChange.Path.assign(&this->CData[0], this->CData.size());
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
       }
     else if(!this->CData.empty() && name == "symlink")
       {
       // symlinks have an arobase at the end in the log
       this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
       cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
       this->Changes.push_back(this->CurChange);
       }
     else if(!this->CData.empty() && name == "committer")
       {
       this->Rev.Author.assign(&this->CData[0], this->CData.size());
       if(this->EmailRegex.find(this->Rev.Author))
         {
         this->Rev.Author = this->EmailRegex.match(1);
         this->Rev.EMail = this->EmailRegex.match(2);
         }
       }
     else if(!this->CData.empty() && name == "timestamp")
       {
       this->Rev.Date.assign(&this->CData[0], this->CData.size());
       }
     else if(!this->CData.empty() && name == "message")
       {
       this->Rev.Log.assign(&this->CData[0], this->CData.size());
       }
     else if(!this->CData.empty() && name == "revno")
       {
       this->Rev.Rev.assign(&this->CData[0], this->CData.size());
       }
     this->CData.clear();
     }

   virtual void ReportError(int, int, const char* msg)
     {
     this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
     }
 };

 //----------------------------------------------------------------------------
 class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
 {
 public:
   UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
     {
     this->SetLog(&bzr->Log, prefix);
     this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
     }
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexUpdate;

   virtual bool ProcessChunk(const char* first, int length)
     {
     bool last_is_new_line = (*first == '\r' || *first == '\n');

     const char* const last = first + length;
     for(const char* c = first; c != last; ++c)
       {
       if(*c == '\r' || *c == '\n')
         {
         if(!last_is_new_line)
           {
           // Log this line.
           if(this->Log && this->Prefix)
             {
             *this->Log << this->Prefix << this->Line << "\n";
             }

           // Hand this line to the subclass implementation.
           if(!this->ProcessLine())
             {
             this->Line = "";
             return false;
             }

           this->Line = "";
           last_is_new_line = true;
           }
         }
       else
         {
         // Append this character to the line under construction.
         this->Line.append(1, *c);
         last_is_new_line = false;
         }
       }
     return true;
     }

   bool ProcessLine()
     {
     if(this->RegexUpdate.find(this->Line))
       {
       this->DoPath(this->RegexUpdate.match(1)[0],
                    this->RegexUpdate.match(2)[0],
                    this->RegexUpdate.match(3)[0],
                    this->RegexUpdate.match(4));
       }
     return true;
     }

   void DoPath(char c0, char c1, char c2, std::string path)
     {
     if(path.empty()) return;
     cmSystemTools::ConvertToUnixSlashes(path);

     const std::string dir = cmSystemTools::GetFilenamePath(path);
     const std::string name = cmSystemTools::GetFilenameName(path);

     if ( c0=='C' )
       {
       this->BZR->Dirs[dir][name].Status = PathConflicting;
       return;
       }

     if ( c1=='M' || c1=='K' || c1=='N' || c1=='D' || c2 =='*' )
       {
       this->BZR->Dirs[dir][name].Status = PathUpdated;
       return;
       }
     }
 };

 //----------------------------------------------------------------------------
 bool cmCTestBZR::UpdateImpl()
 {
   // Get user-specified update options.
   std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
   if(opts.empty())
     {
     opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
     }
   std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());

   // TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)

   // Use "bzr pull" to update the working tree.
   std::vector<char const*> bzr_update;
   bzr_update.push_back(this->CommandLineTool.c_str());
   bzr_update.push_back("pull");

   for(std::vector<std::string>::const_iterator ai = args.begin();
       ai != args.end(); ++ai)
     {
     bzr_update.push_back(ai->c_str());
     }

   bzr_update.push_back(this->URL.c_str());

   bzr_update.push_back(0);

   // For some reason bzr uses stderr to display the update status.
   OutputLogger out(this->Log, "pull-out> ");
   UpdateParser err(this, "pull-err> ");
   return this->RunUpdateCommand(&bzr_update[0], &out, &err);
 }

 //----------------------------------------------------------------------------
 void cmCTestBZR::LoadRevisions()
 {
   cmCTestLog(this->CTest, HANDLER_OUTPUT,
              "   Gathering version information (one . per revision):\n"
              "    " << std::flush);

   // We are interested in every revision included in the update.
   this->Revisions.clear();
   std::string revs;
   if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
     {
     // DoRevision takes care of discarding the information about OldRevision
     revs = this->OldRevision + ".." + this->NewRevision;
     }
   else
     {
     return;
     }

   // Run "bzr log" to get all global revisions of interest.
   const char* bzr = this->CommandLineTool.c_str();
   const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
                            this->URL.c_str(), 0};
   {
   LogParser out(this, "log-out> ");
   OutputLogger err(this->Log, "log-err> ");
   this->RunChild(bzr_log, &out, &err);
   }
   cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
 }

 //----------------------------------------------------------------------------
 class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
 {
 public:
   StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
     {
     this->SetLog(&bzr->Log, prefix);
     this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
     }
 private:
   cmCTestBZR* BZR;
   cmsys::RegularExpression RegexStatus;
   bool ProcessLine()
     {
     if(this->RegexStatus.find(this->Line))
       {
       this->DoPath(this->RegexStatus.match(1)[0],
                    this->RegexStatus.match(2)[0],
                    this->RegexStatus.match(3)[0],
                    this->RegexStatus.match(4));
       }
     return true;
     }

   void DoPath(char c0, char c1, char c2, std::string path)
     {
     if(path.empty()) return;
     cmSystemTools::ConvertToUnixSlashes(path);

     if ( c0=='C' )
       {
       this->BZR->DoModification(PathConflicting, path);
       return;
       }

     if ( c0 == '+' || c0 == 'R' || c0 == 'P'
          || c1=='M' || c1=='K' || c1=='N' || c1=='D'
          || c2 =='*' )
       {
       this->BZR->DoModification(PathModified, path);
       return;
       }
     }
 };

 //----------------------------------------------------------------------------
 void cmCTestBZR::LoadModifications()
 {
   // Run "bzr status" which reports local modifications.
   const char* bzr = this->CommandLineTool.c_str();
   const char* bzr_status[] = {bzr, "status", "-SV", 0};
   StatusParser out(this, "status-out> ");
   OutputLogger err(this->Log, "status-err> ");
   this->RunChild(bzr_status, &out, &err);
 }
	/*============================================================================
	CMake - Cross Platform Makefile Generator
	Copyright 2000-2009 Kitware, Inc.

	Distributed under the OSI-approved BSD License (the "License");
	see accompanying file Copyright.txt for details.

	This software is distributed WITHOUT ANY WARRANTY; without even the
	implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
	See the License for more information.
	============================================================================*/
	#include "cmCTestBZR.h"

	#include "cmCTest.h"
	#include "cmSystemTools.h"
	#include "cmXMLParser.h"

	#include <cmsys/RegularExpression.hxx>

	#include <cm_expat.h>

	//----------------------------------------------------------------------------
	extern "C"
	int cmBZRXMLParserUnknownEncodingHandler(void*,
	const XML_Char *name,
	XML_Encoding *info)
	{
	static const int latin1[]=
	{
	0x0000, 0x0001, 0x0002, 0x0003, 0x0004, 0x0005, 0x0006, 0x0007,
	0x0008, 0x0009, 0x000A, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F,
	0x0010, 0x0011, 0x0012, 0x0013, 0x0014, 0x0015, 0x0016, 0x0017,
	0x0018, 0x0019, 0x001A, 0x001B, 0x001C, 0x001D, 0x001E, 0x001F,
	0x0020, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
	0x0028, 0x0029, 0x002A, 0x002B, 0x002C, 0x002D, 0x002E, 0x002F,
	0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
	0x0038, 0x0039, 0x003A, 0x003B, 0x003C, 0x003D, 0x003E, 0x003F,
	0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
	0x0048, 0x0049, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F,
	0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
	0x0058, 0x0059, 0x005A, 0x005B, 0x005C, 0x005D, 0x005E, 0x005F,
	0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
	0x0068, 0x0069, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F,
	0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
	0x0078, 0x0079, 0x007A, 0x007B, 0x007C, 0x007D, 0x007E, 0x007F,
	0x20AC, 0x0081, 0x201A, 0x0192, 0x201E, 0x2026, 0x2020, 0x2021,
	0x02C6, 0x2030, 0x0160, 0x2039, 0x0152, 0x008D, 0x017D, 0x008F,
	0x0090, 0x2018, 0x2019, 0x201C, 0x201D, 0x2022, 0x2013, 0x2014,
	0x02DC, 0x2122, 0x0161, 0x203A, 0x0153, 0x009D, 0x017E, 0x0178,
	0x00A0, 0x00A1, 0x00A2, 0x00A3, 0x00A4, 0x00A5, 0x00A6, 0x00A7,
	0x00A8, 0x00A9, 0x00AA, 0x00AB, 0x00AC, 0x00AD, 0x00AE, 0x00AF,
	0x00B0, 0x00B1, 0x00B2, 0x00B3, 0x00B4, 0x00B5, 0x00B6, 0x00B7,
	0x00B8, 0x00B9, 0x00BA, 0x00BB, 0x00BC, 0x00BD, 0x00BE, 0x00BF,
	0x00C0, 0x00C1, 0x00C2, 0x00C3, 0x00C4, 0x00C5, 0x00C6, 0x00C7,
	0x00C8, 0x00C9, 0x00CA, 0x00CB, 0x00CC, 0x00CD, 0x00CE, 0x00CF,
	0x00D0, 0x00D1, 0x00D2, 0x00D3, 0x00D4, 0x00D5, 0x00D6, 0x00D7,
	0x00D8, 0x00D9, 0x00DA, 0x00DB, 0x00DC, 0x00DD, 0x00DE, 0x00DF,
	0x00E0, 0x00E1, 0x00E2, 0x00E3, 0x00E4, 0x00E5, 0x00E6, 0x00E7,
	0x00E8, 0x00E9, 0x00EA, 0x00EB, 0x00EC, 0x00ED, 0x00EE, 0x00EF,
	0x00F0, 0x00F1, 0x00F2, 0x00F3, 0x00F4, 0x00F5, 0x00F6, 0x00F7,
	0x00F8, 0x00F9, 0x00FA, 0x00FB, 0x00FC, 0x00FD, 0x00FE, 0x00FF
	};

	// The BZR xml output plugin can use some encodings that are not
	// recognized by expat. This will lead to an error, e.g. "Error
	// parsing bzr log xml: unknown encoding", the following is a
	// workaround for these unknown encodings.
	if(name == std::string("ascii") \|\| name == std::string("cp1252") \|\|
	name == std::string("ANSI_X3.4-1968"))
	{
	for(unsigned int i=0;i<256;++i) info->map[i] = latin1[i];
	return 1;
	}

	return 0;
	}

	//----------------------------------------------------------------------------
	cmCTestBZR::cmCTestBZR(cmCTest* ct, std::ostream& log):
	cmCTestGlobalVC(ct, log)
	{
	this->PriorRev = this->Unknown;
	// Even though it is specified in the documention, with bzr 1.13
	// BZR_PROGRESS_BAR has no effect. In the future this bug might be fixed.
	// Since it doesn't hurt, we specify this environment variable.
	cmSystemTools::PutEnv("BZR_PROGRESS_BAR=none");
	}

	//----------------------------------------------------------------------------
	cmCTestBZR::~cmCTestBZR()
	{
	}

	//----------------------------------------------------------------------------
	class cmCTestBZR::InfoParser: public cmCTestVC::LineParser
	{
	public:
	InfoParser(cmCTestBZR* bzr, const char* prefix):
	BZR(bzr), CheckOutFound(false)
	{
	this->SetLog(&bzr->Log, prefix);
	this->RegexCheckOut.compile("checkout of branch: *([^\t\r\n]+)$");
	this->RegexParent.compile("parent branch: *([^\t\r\n]+)$");
	}
	private:
	cmCTestBZR* BZR;
	bool CheckOutFound;
	cmsys::RegularExpression RegexCheckOut;
	cmsys::RegularExpression RegexParent;
	virtual bool ProcessLine()
	{
	if(this->RegexCheckOut.find(this->Line))
	{
	this->BZR->URL = this->RegexCheckOut.match(1);
	CheckOutFound = true;
	}
	else if(!CheckOutFound && this->RegexParent.find(this->Line))
	{
	this->BZR->URL = this->RegexParent.match(1);
	}
	return true;
	}
	};

	//----------------------------------------------------------------------------
	class cmCTestBZR::RevnoParser: public cmCTestVC::LineParser
	{
	public:
	RevnoParser(cmCTestBZR* bzr, const char* prefix, std::string& rev):
	Rev(rev)
	{
	this->SetLog(&bzr->Log, prefix);
	this->RegexRevno.compile("^([0-9]+)$");
	}
	private:
	std::string& Rev;
	cmsys::RegularExpression RegexRevno;
	virtual bool ProcessLine()
	{
	if(this->RegexRevno.find(this->Line))
	{
	this->Rev = this->RegexRevno.match(1);
	}
	return true;
	}
	};

	//----------------------------------------------------------------------------
	std::string cmCTestBZR::LoadInfo()
	{
	// Run "bzr info" to get the repository info from the work tree.
	const char* bzr = this->CommandLineTool.c_str();
	const char* bzr_info[] = {bzr, "info", 0};
	InfoParser iout(this, "info-out> ");
	OutputLogger ierr(this->Log, "info-err> ");
	this->RunChild(bzr_info, &iout, &ierr);

	// Run "bzr revno" to get the repository revision number from the work tree.
	const char* bzr_revno[] = {bzr, "revno", 0};
	std::string rev;
	RevnoParser rout(this, "revno-out> ", rev);
	OutputLogger rerr(this->Log, "revno-err> ");
	this->RunChild(bzr_revno, &rout, &rerr);

	return rev;
	}

	void cmCTestBZR::NoteOldRevision()
	{
	this->OldRevision = this->LoadInfo();
	this->Log << "Revision before update: " << this->OldRevision << "\n";
	cmCTestLog(this->CTest, HANDLER_OUTPUT, " Old revision of repository is: "
	<< this->OldRevision << "\n");
	this->PriorRev.Rev = this->OldRevision;
	}

	//----------------------------------------------------------------------------
	void cmCTestBZR::NoteNewRevision()
	{
	this->NewRevision = this->LoadInfo();
	this->Log << "Revision after update: " << this->NewRevision << "\n";
	cmCTestLog(this->CTest, HANDLER_OUTPUT, " New revision of repository is: "
	<< this->NewRevision << "\n");
	this->Log << "URL = " << this->URL << "\n";
	}

	//----------------------------------------------------------------------------
	class cmCTestBZR::LogParser: public cmCTestVC::OutputLogger,
	private cmXMLParser
	{
	public:
	LogParser(cmCTestBZR* bzr, const char* prefix):
	OutputLogger(bzr->Log, prefix), BZR(bzr),
	EmailRegex("(.*) <([A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+)>")
	{ this->InitializeParser(); }
	~LogParser() { this->CleanupParser(); }

	virtual int InitializeParser()
	{
	int res = cmXMLParser::InitializeParser();
	if (res)
	{
	XML_SetUnknownEncodingHandler(static_cast<XML_Parser>(this->Parser),
	cmBZRXMLParserUnknownEncodingHandler, 0);
	}
	return res;
	}
	private:
	cmCTestBZR* BZR;

	typedef cmCTestBZR::Revision Revision;
	typedef cmCTestBZR::Change Change;
	Revision Rev;
	std::vector<Change> Changes;
	Change CurChange;
	std::vector<char> CData;

	cmsys::RegularExpression EmailRegex;

	virtual bool ProcessChunk(const char* data, int length)
	{
	this->OutputLogger::ProcessChunk(data, length);
	this->ParseChunk(data, length);
	return true;
	}

	virtual void StartElement(const std::string& name, const char**)
	{
	this->CData.clear();
	if(name == "log")
	{
	this->Rev = Revision();
	this->Changes.clear();
	}
	// affected-files can contain blocks of
	// modified, unknown, renamed, kind-changed, removed, conflicts, added
	else if(name == "modified"
	\|\| name == "renamed"
	\|\| name == "kind-changed")
	{
	this->CurChange = Change();
	this->CurChange.Action = 'M';
	}
	else if(name == "added")
	{
	this->CurChange = Change();
	this->CurChange = 'A';
	}
	else if(name == "removed")
	{
	this->CurChange = Change();
	this->CurChange = 'D';
	}
	else if(name == "unknown"
	\|\| name == "conflicts")
	{
	// Should not happen here
	this->CurChange = Change();
	}
	}

	virtual void CharacterDataHandler(const char* data, int length)
	{
	this->CData.insert(this->CData.end(), data, data+length);
	}

	virtual void EndElement(const std::string& name)
	{
	if(name == "log")
	{
	this->BZR->DoRevision(this->Rev, this->Changes);
	}
	else if(!this->CData.empty() &&
	(name == "file" \|\| name == "directory"))
	{
	this->CurChange.Path.assign(&this->CData[0], this->CData.size());
	cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
	this->Changes.push_back(this->CurChange);
	}
	else if(!this->CData.empty() && name == "symlink")
	{
	// symlinks have an arobase at the end in the log
	this->CurChange.Path.assign(&this->CData[0], this->CData.size()-1);
	cmSystemTools::ConvertToUnixSlashes(this->CurChange.Path);
	this->Changes.push_back(this->CurChange);
	}
	else if(!this->CData.empty() && name == "committer")
	{
	this->Rev.Author.assign(&this->CData[0], this->CData.size());
	if(this->EmailRegex.find(this->Rev.Author))
	{
	this->Rev.Author = this->EmailRegex.match(1);
	this->Rev.EMail = this->EmailRegex.match(2);
	}
	}
	else if(!this->CData.empty() && name == "timestamp")
	{
	this->Rev.Date.assign(&this->CData[0], this->CData.size());
	}
	else if(!this->CData.empty() && name == "message")
	{
	this->Rev.Log.assign(&this->CData[0], this->CData.size());
	}
	else if(!this->CData.empty() && name == "revno")
	{
	this->Rev.Rev.assign(&this->CData[0], this->CData.size());
	}
	this->CData.clear();
	}

	virtual void ReportError(int, int, const char* msg)
	{
	this->BZR->Log << "Error parsing bzr log xml: " << msg << "\n";
	}
	};

	//----------------------------------------------------------------------------
	class cmCTestBZR::UpdateParser: public cmCTestVC::LineParser
	{
	public:
	UpdateParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
	{
	this->SetLog(&bzr->Log, prefix);
	this->RegexUpdate.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
	}
	private:
	cmCTestBZR* BZR;
	cmsys::RegularExpression RegexUpdate;

	virtual bool ProcessChunk(const char* first, int length)
	{
	bool last_is_new_line = (first == '\r' \|\| first == '\n');

	const char* const last = first + length;
	for(const char* c = first; c != last; ++c)
	{
	if(c == '\r' \|\| c == '\n')
	{
	if(!last_is_new_line)
	{
	// Log this line.
	if(this->Log && this->Prefix)
	{
	*this->Log << this->Prefix << this->Line << "\n";
	}

	// Hand this line to the subclass implementation.
	if(!this->ProcessLine())
	{
	this->Line = "";
	return false;
	}

	this->Line = "";
	last_is_new_line = true;
	}
	}
	else
	{
	// Append this character to the line under construction.
	this->Line.append(1, *c);
	last_is_new_line = false;
	}
	}
	return true;
	}

	bool ProcessLine()
	{
	if(this->RegexUpdate.find(this->Line))
	{
	this->DoPath(this->RegexUpdate.match(1)[0],
	this->RegexUpdate.match(2)[0],
	this->RegexUpdate.match(3)[0],
	this->RegexUpdate.match(4));
	}
	return true;
	}

	void DoPath(char c0, char c1, char c2, std::string path)
	{
	if(path.empty()) return;
	cmSystemTools::ConvertToUnixSlashes(path);

	const std::string dir = cmSystemTools::GetFilenamePath(path);
	const std::string name = cmSystemTools::GetFilenameName(path);

	if ( c0=='C' )
	{
	this->BZR->Dirs[dir][name].Status = PathConflicting;
	return;
	}

	if ( c1=='M' \|\| c1=='K' \|\| c1=='N' \|\| c1=='D' \|\| c2 =='*' )
	{
	this->BZR->Dirs[dir][name].Status = PathUpdated;
	return;
	}
	}
	};

	//----------------------------------------------------------------------------
	bool cmCTestBZR::UpdateImpl()
	{
	// Get user-specified update options.
	std::string opts = this->CTest->GetCTestConfiguration("UpdateOptions");
	if(opts.empty())
	{
	opts = this->CTest->GetCTestConfiguration("BZRUpdateOptions");
	}
	std::vector<std::string> args = cmSystemTools::ParseArguments(opts.c_str());

	// TODO: if(this->CTest->GetTestModel() == cmCTest::NIGHTLY)

	// Use "bzr pull" to update the working tree.
	std::vector<char const*> bzr_update;
	bzr_update.push_back(this->CommandLineTool.c_str());
	bzr_update.push_back("pull");

	for(std::vector<std::string>::const_iterator ai = args.begin();
	ai != args.end(); ++ai)
	{
	bzr_update.push_back(ai->c_str());
	}

	bzr_update.push_back(this->URL.c_str());

	bzr_update.push_back(0);

	// For some reason bzr uses stderr to display the update status.
	OutputLogger out(this->Log, "pull-out> ");
	UpdateParser err(this, "pull-err> ");
	return this->RunUpdateCommand(&bzr_update[0], &out, &err);
	}

	//----------------------------------------------------------------------------
	void cmCTestBZR::LoadRevisions()
	{
	cmCTestLog(this->CTest, HANDLER_OUTPUT,
	" Gathering version information (one . per revision):\n"
	" " << std::flush);

	// We are interested in every revision included in the update.
	this->Revisions.clear();
	std::string revs;
	if(atoi(this->OldRevision.c_str()) <= atoi(this->NewRevision.c_str()))
	{
	// DoRevision takes care of discarding the information about OldRevision
	revs = this->OldRevision + ".." + this->NewRevision;
	}
	else
	{
	return;
	}

	// Run "bzr log" to get all global revisions of interest.
	const char* bzr = this->CommandLineTool.c_str();
	const char* bzr_log[] = {bzr, "log", "-v", "-r", revs.c_str(), "--xml",
	this->URL.c_str(), 0};
	{
	LogParser out(this, "log-out> ");
	OutputLogger err(this->Log, "log-err> ");
	this->RunChild(bzr_log, &out, &err);
	}
	cmCTestLog(this->CTest, HANDLER_OUTPUT, std::endl);
	}

	//----------------------------------------------------------------------------
	class cmCTestBZR::StatusParser: public cmCTestVC::LineParser
	{
	public:
	StatusParser(cmCTestBZR* bzr, const char* prefix): BZR(bzr)
	{
	this->SetLog(&bzr->Log, prefix);
	this->RegexStatus.compile("^([-+R?XCP ])([NDKM ])([* ]) +(.+)$");
	}
	private:
	cmCTestBZR* BZR;
	cmsys::RegularExpression RegexStatus;
	bool ProcessLine()
	{
	if(this->RegexStatus.find(this->Line))
	{
	this->DoPath(this->RegexStatus.match(1)[0],
	this->RegexStatus.match(2)[0],
	this->RegexStatus.match(3)[0],
	this->RegexStatus.match(4));
	}
	return true;
	}

	void DoPath(char c0, char c1, char c2, std::string path)
	{
	if(path.empty()) return;
	cmSystemTools::ConvertToUnixSlashes(path);

	if ( c0=='C' )
	{
	this->BZR->DoModification(PathConflicting, path);
	return;
	}

	if ( c0 == '+' \|\| c0 == 'R' \|\| c0 == 'P'
	\|\| c1=='M' \|\| c1=='K' \|\| c1=='N' \|\| c1=='D'
	\|\| c2 =='*' )
	{
	this->BZR->DoModification(PathModified, path);
	return;
	}
	}
	};

	//----------------------------------------------------------------------------
	void cmCTestBZR::LoadModifications()
	{
	// Run "bzr status" which reports local modifications.
	const char* bzr = this->CommandLineTool.c_str();
	const char* bzr_status[] = {bzr, "status", "-SV", 0};
	StatusParser out(this, "status-out> ");
	OutputLogger err(this->Log, "status-err> ");
	this->RunChild(bzr_status, &out, &err);
	}