CMakeLua/Source/kwsys/Glob.cxx

   1 /*=========================================================================
   2
   3   Program:   KWSys - Kitware System Library
   4   Module:    $RCSfile: Glob.cxx,v $
   5
   6   Copyright (c) Kitware, Inc., Insight Consortium.  All rights reserved.
   7   See Copyright.txt or http://www.kitware.com/Copyright.htm for details.
   8
   9      This software is distributed WITHOUT ANY WARRANTY; without even
  10      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  11      PURPOSE.  See the above copyright notices for more information.
  12
  13 =========================================================================*/
  14 #include "kwsysPrivate.h"
  15 #include KWSYS_HEADER(Glob.hxx)
  16
  17 #include KWSYS_HEADER(Configure.hxx)
  18
  19 #include KWSYS_HEADER(RegularExpression.hxx)
  20 #include KWSYS_HEADER(SystemTools.hxx)
  21 #include KWSYS_HEADER(Directory.hxx)
  22 #include KWSYS_HEADER(stl/string)
  23 #include KWSYS_HEADER(stl/vector)
  24
  25 // Work-around CMake dependency scanning limitation.  This must
  26 // duplicate the above list of headers.
  27 #if 0
  28 # include "Glob.hxx.in"
  29 # include "Directory.hxx.in"
  30 # include "Configure.hxx.in"
  31 # include "RegularExpression.hxx.in"
  32 # include "SystemTools.hxx.in"
  33 # include "kwsys_stl.hxx.in"
  34 # include "kwsys_stl_string.hxx.in"
  35 #endif
  36
  37 #include <ctype.h>
  38 #include <stdio.h>
  39 #include <string.h>
  40 namespace KWSYS_NAMESPACE
  41 {
  42 #if defined(_WIN32) || defined(__APPLE__) || defined(__CYGWIN__)
  43 // On Windows and apple, no difference between lower and upper case
  44 # define KWSYS_GLOB_CASE_INDEPENDENT
  45 #endif
  46
  47 #if defined(_WIN32) || defined(__CYGWIN__)
  48 // Handle network paths
  49 # define KWSYS_GLOB_SUPPORT_NETWORK_PATHS
  50 #endif
  51
  52 //----------------------------------------------------------------------------
  53 class GlobInternals
  54 {
  55 public:
  56   kwsys_stl::vector<kwsys_stl::string> Files;
  57   kwsys_stl::vector<kwsys::RegularExpression> Expressions;
  58 };
  59
  60 //----------------------------------------------------------------------------
  61 Glob::Glob()
  62 {
  63   this->Internals = new GlobInternals;
  64   this->Recurse = false;
  65   this->Relative = "";
  66
  67   this->RecurseThroughSymlinks = true;
  68     // RecurseThroughSymlinks is true by default for backwards compatibility,
  69     // not because it's a good idea...
  70   this->FollowedSymlinkCount = 0;
  71 }
  72
  73 //----------------------------------------------------------------------------
  74 Glob::~Glob()
  75 {
  76   delete this->Internals;
  77 }
  78
  79 //----------------------------------------------------------------------------
  80 kwsys_stl::vector<kwsys_stl::string>& Glob::GetFiles()
  81 {
  82   return this->Internals->Files;
  83 }
  84
  85 //----------------------------------------------------------------------------
  86 kwsys_stl::string Glob::PatternToRegex(const kwsys_stl::string& pattern,
  87                                        bool require_whole_string)
  88 {
  89   // Incrementally build the regular expression from the pattern.
  90   kwsys_stl::string regex = require_whole_string? "^" : "";
  91   kwsys_stl::string::const_iterator pattern_first = pattern.begin();
  92   kwsys_stl::string::const_iterator pattern_last = pattern.end();
  93   for(kwsys_stl::string::const_iterator i = pattern_first;
  94       i != pattern_last; ++i)
  95     {
  96     int c = *i;
  97     if(c == '*')
  98       {
  99       // A '*' (not between brackets) matches any string.
 100       // We modify this to not match slashes since the orignal glob
 101       // pattern documentation was meant for matching file name
 102       // components separated by slashes.
 103       regex += "[^/]*";
 104       }
 105     else if(c == '?')
 106       {
 107       // A '?' (not between brackets) matches any single character.
 108       // We modify this to not match slashes since the orignal glob
 109       // pattern documentation was meant for matching file name
 110       // components separated by slashes.
 111       regex += "[^/]";
 112       }
 113     else if(c == '[')
 114       {
 115       // Parse out the bracket expression.  It begins just after the
 116       // opening character.
 117       kwsys_stl::string::const_iterator bracket_first = i+1;
 118       kwsys_stl::string::const_iterator bracket_last = bracket_first;
 119
 120       // The first character may be complementation '!' or '^'.
 121       if(bracket_last != pattern_last &&
 122          (*bracket_last == '!' || *bracket_last == '^'))
 123         {
 124         ++bracket_last;
 125         }
 126
 127       // If the next character is a ']' it is included in the brackets
 128       // because the bracket string may not be empty.
 129       if(bracket_last != pattern_last && *bracket_last == ']')
 130         {
 131         ++bracket_last;
 132         }
 133
 134       // Search for the closing ']'.
 135       while(bracket_last != pattern_last && *bracket_last != ']')
 136         {
 137         ++bracket_last;
 138         }
 139
 140       // Check whether we have a complete bracket string.
 141       if(bracket_last == pattern_last)
 142         {
 143         // The bracket string did not end, so it was opened simply by
 144         // a '[' that is supposed to be matched literally.
 145         regex += "\\[";
 146         }
 147       else
 148         {
 149         // Convert the bracket string to its regex equivalent.
 150         kwsys_stl::string::const_iterator k = bracket_first;
 151
 152         // Open the regex block.
 153         regex += "[";
 154
 155         // A regex range complement uses '^' instead of '!'.
 156         if(k != bracket_last && *k == '!')
 157           {
 158           regex += "^";
 159           ++k;
 160           }
 161
 162         // Convert the remaining characters.
 163         for(; k != bracket_last; ++k)
 164           {
 165           // Backslashes must be escaped.
 166           if(*k == '\\')
 167             {
 168             regex += "\\";
 169             }
 170
 171           // Store this character.
 172           regex += *k;
 173           }
 174
 175         // Close the regex block.
 176         regex += "]";
 177
 178         // Jump to the end of the bracket string.
 179         i = bracket_last;
 180         }
 181       }
 182     else
 183       {
 184       // A single character matches itself.
 185       int ch = c;
 186       if(!(('a' <= ch && ch <= 'z') ||
 187            ('A' <= ch && ch <= 'Z') ||
 188            ('0' <= ch && ch <= '9')))
 189         {
 190         // Escape the non-alphanumeric character.
 191         regex += "\\";
 192         }
 193 #if defined(KWSYS_GLOB_CASE_INDEPENDENT)
 194       else
 195         {
 196         // On case-insensitive systems file names are converted to lower
 197         // case before matching.
 198         ch = tolower(ch);
 199         }
 200 #endif
 201
 202       // Store the character.
 203       regex.append(1, static_cast<char>(ch));
 204       }
 205     }
 206
 207   if(require_whole_string)
 208     {
 209     regex += "$";
 210     }
 211   return regex;
 212 }
 213
 214 //----------------------------------------------------------------------------
 215 void Glob::RecurseDirectory(kwsys_stl::string::size_type start,
 216   const kwsys_stl::string& dir, bool dir_only)
 217 {
 218   kwsys::Directory d;
 219   if ( !d.Load(dir.c_str()) )
 220     {
 221     return;
 222     }
 223   unsigned long cc;
 224   kwsys_stl::string fullname;
 225   kwsys_stl::string realname;
 226   kwsys_stl::string fname;
 227   for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ )
 228     {
 229     fname = d.GetFile(cc);
 230     if ( strcmp(fname.c_str(), ".") == 0 ||
 231       strcmp(fname.c_str(), "..") == 0  )
 232       {
 233       continue;
 234       }
 235
 236     if ( start == 0 )
 237       {
 238       realname = dir + fname;
 239       }
 240     else
 241       {
 242       realname = dir + "/" + fname;
 243       }
 244
 245 #if defined( KWSYS_GLOB_CASE_INDEPENDENT )
 246     // On Windows and apple, no difference between lower and upper case
 247     fname = kwsys::SystemTools::LowerCase(fname);
 248 #endif
 249
 250     if ( start == 0 )
 251       {
 252       fullname = dir + fname;
 253       }
 254     else
 255       {
 256       fullname = dir + "/" + fname;
 257       }
 258
 259     if ( !dir_only || !kwsys::SystemTools::FileIsDirectory(realname.c_str()) )
 260       {
 261       if ( (this->Internals->Expressions.size() > 0) &&
 262            this->Internals->Expressions[
 263              this->Internals->Expressions.size()-1].find(fname.c_str()) )
 264         {
 265         this->AddFile(this->Internals->Files, realname.c_str());
 266         }
 267       }
 268     if ( kwsys::SystemTools::FileIsDirectory(realname.c_str()) )
 269       {
 270       bool isSymLink = kwsys::SystemTools::FileIsSymlink(realname.c_str());
 271       if (!isSymLink || this->RecurseThroughSymlinks)
 272         {
 273         if (isSymLink)
 274           {
 275           ++this->FollowedSymlinkCount;
 276           }
 277         this->RecurseDirectory(start+1, realname, dir_only);
 278         }
 279       }
 280     }
 281 }
 282
 283 //----------------------------------------------------------------------------
 284 void Glob::ProcessDirectory(kwsys_stl::string::size_type start,
 285   const kwsys_stl::string& dir, bool dir_only)
 286 {
 287   //kwsys_ios::cout << "ProcessDirectory: " << dir << kwsys_ios::endl;
 288   bool last = ( start == this->Internals->Expressions.size()-1 );
 289   if ( last && this->Recurse )
 290     {
 291     this->RecurseDirectory(start, dir, dir_only);
 292     return;
 293     }
 294
 295   if ( start >= this->Internals->Expressions.size() )
 296     {
 297     return;
 298     }
 299
 300   kwsys::Directory d;
 301   if ( !d.Load(dir.c_str()) )
 302     {
 303     return;
 304     }
 305   unsigned long cc;
 306   kwsys_stl::string fullname;
 307   kwsys_stl::string realname;
 308   kwsys_stl::string fname;
 309   for ( cc = 0; cc < d.GetNumberOfFiles(); cc ++ )
 310     {
 311     fname = d.GetFile(cc);
 312     if ( strcmp(fname.c_str(), ".") == 0 ||
 313       strcmp(fname.c_str(), "..") == 0  )
 314       {
 315       continue;
 316       }
 317
 318     if ( start == 0 )
 319       {
 320       realname = dir + fname;
 321       }
 322     else
 323       {
 324       realname = dir + "/" + fname;
 325       }
 326
 327 #if defined(KWSYS_GLOB_CASE_INDEPENDENT)
 328     // On case-insensitive file systems convert to lower case for matching.
 329     fname = kwsys::SystemTools::LowerCase(fname);
 330 #endif
 331
 332     if ( start == 0 )
 333       {
 334       fullname = dir + fname;
 335       }
 336     else
 337       {
 338       fullname = dir + "/" + fname;
 339       }
 340
 341     //kwsys_ios::cout << "Look at file: " << fname << kwsys_ios::endl;
 342     //kwsys_ios::cout << "Match: "
 343     // << this->Internals->TextExpressions[start].c_str() << kwsys_ios::endl;
 344     //kwsys_ios::cout << "Full name: " << fullname << kwsys_ios::endl;
 345
 346     if ( (!dir_only || !last) &&
 347       !kwsys::SystemTools::FileIsDirectory(realname.c_str()) )
 348       {
 349       continue;
 350       }
 351
 352     if ( this->Internals->Expressions[start].find(fname.c_str()) )
 353       {
 354       if ( last )
 355         {
 356         this->AddFile(this->Internals->Files, realname.c_str());
 357         }
 358       else
 359         {
 360         this->ProcessDirectory(start+1, realname + "/", dir_only);
 361         }
 362       }
 363     }
 364 }
 365
 366 //----------------------------------------------------------------------------
 367 bool Glob::FindFiles(const kwsys_stl::string& inexpr)
 368 {
 369   kwsys_stl::string cexpr;
 370   kwsys_stl::string::size_type cc;
 371   kwsys_stl::string expr = inexpr;
 372
 373   this->Internals->Expressions.clear();
 374   this->Internals->Files.clear();
 375
 376   if ( !kwsys::SystemTools::FileIsFullPath(expr.c_str()) )
 377     {
 378     expr = kwsys::SystemTools::GetCurrentWorkingDirectory();
 379     expr += "/" + inexpr;
 380     }
 381   kwsys_stl::string fexpr = expr;
 382
 383   kwsys_stl::string::size_type skip = 0;
 384   kwsys_stl::string::size_type last_slash = 0;
 385   for ( cc = 0; cc < expr.size(); cc ++ )
 386     {
 387     if ( cc > 0 && expr[cc] == '/' && expr[cc-1] != '\\' )
 388       {
 389       last_slash = cc;
 390       }
 391     if ( cc > 0 &&
 392       (expr[cc] == '[' || expr[cc] == '?' || expr[cc] == '*') &&
 393       expr[cc-1] != '\\' )
 394       {
 395       break;
 396       }
 397     }
 398   if ( last_slash > 0 )
 399     {
 400     //kwsys_ios::cout << "I can skip: " << fexpr.substr(0, last_slash)
 401     //<< kwsys_ios::endl;
 402     skip = last_slash;
 403     }
 404   if ( skip == 0 )
 405     {
 406 #if defined( KWSYS_GLOB_SUPPORT_NETWORK_PATHS )
 407     // Handle network paths
 408     if ( expr[0] == '/' && expr[1] == '/' )
 409       {
 410       int cnt = 0;
 411       for ( cc = 2; cc < expr.size(); cc ++ )
 412         {
 413         if ( expr[cc] == '/' )
 414           {
 415           cnt ++;
 416           if ( cnt == 2 )
 417             {
 418             break;
 419             }
 420           }
 421         }
 422       skip = int(cc + 1);
 423       }
 424     else
 425 #endif
 426       // Handle drive letters on Windows
 427       if ( expr[1] == ':' && expr[0] != '/' )
 428         {
 429         skip = 2;
 430         }
 431     }
 432
 433   if ( skip > 0 )
 434     {
 435     expr = expr.substr(skip);
 436     }
 437
 438   cexpr = "";
 439   for ( cc = 0; cc < expr.size(); cc ++ )
 440     {
 441     int ch = expr[cc];
 442     if ( ch == '/' )
 443       {
 444       if ( cexpr.size() > 0 )
 445         {
 446         this->AddExpression(cexpr.c_str());
 447         }
 448       cexpr = "";
 449       }
 450     else
 451       {
 452       cexpr.append(1, static_cast<char>(ch));
 453       }
 454     }
 455   if ( cexpr.size() > 0 )
 456     {
 457     this->AddExpression(cexpr.c_str());
 458     }
 459
 460   // Handle network paths
 461   if ( skip > 0 )
 462     {
 463     this->ProcessDirectory(0, fexpr.substr(0, skip) + "/",
 464       true);
 465     }
 466   else
 467     {
 468     this->ProcessDirectory(0, "/", true);
 469     }
 470   return true;
 471 }
 472
 473 //----------------------------------------------------------------------------
 474 void Glob::AddExpression(const char* expr)
 475 {
 476   this->Internals->Expressions.push_back(
 477     kwsys::RegularExpression(
 478       this->PatternToRegex(expr).c_str()));
 479 }
 480
 481 //----------------------------------------------------------------------------
 482 void Glob::SetRelative(const char* dir)
 483 {
 484   if ( !dir )
 485     {
 486     this->Relative = "";
 487     return;
 488     }
 489   this->Relative = dir;
 490 }
 491
 492 //----------------------------------------------------------------------------
 493 const char* Glob::GetRelative()
 494 {
 495   if ( this->Relative.empty() )
 496     {
 497     return 0;
 498     }
 499   return this->Relative.c_str();
 500 }
 501
 502 //----------------------------------------------------------------------------
 503 void Glob::AddFile(kwsys_stl::vector<kwsys_stl::string>& files, const char* file)
 504 {
 505   if ( !this->Relative.empty() )
 506     {
 507     files.push_back(kwsys::SystemTools::RelativePath(this->Relative.c_str(), file));
 508     }
 509   else
 510     {
 511     files.push_back(file);
 512     }
 513 }
 514
 515 } // namespace KWSYS_NAMESPACE
 516