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