[130] | 1 | // |
---|
| 2 | // This program is and should be standalone so that : |
---|
| 3 | // UNIX> c++ obuild_find.cxx |
---|
| 4 | // DOS> cl.exe obuild_find.cxx |
---|
| 5 | // builds at first shoot. |
---|
| 6 | // |
---|
| 7 | |
---|
| 8 | #include <string> |
---|
| 9 | #include <vector> |
---|
| 10 | #include <stdlib.h> |
---|
| 11 | |
---|
| 12 | // From Lib : |
---|
| 13 | static bool Lib_System_getenv(const std::string&,std::string&); |
---|
| 14 | static std::string Lib_System_pathSeparator(); |
---|
| 15 | static std::string Lib_System_fileSeparator(); |
---|
| 16 | static std::vector<std::string> Lib_smanip_words(const std::string&, |
---|
| 17 | const std::string&, |
---|
| 18 | bool = false); |
---|
| 19 | static bool Lib_smanip_match(const std::string&,const std::string&); |
---|
| 20 | static bool Lib_smanip_printf(std::string&,int,const char*,...); |
---|
| 21 | |
---|
| 22 | static bool Lib_dirmanip_entries(const std::string&, |
---|
| 23 | std::vector<std::string>&,bool = true); |
---|
| 24 | static bool Lib_dirmanip_isAnEntry(const std::string&,const std::string&, |
---|
| 25 | bool&); |
---|
| 26 | static bool Lib_dirmanip_find(const std::vector<std::string>& aPaths, |
---|
| 27 | const std::string& aPackage, |
---|
| 28 | const std::string& aVersion, |
---|
| 29 | std::string& aPath, |
---|
| 30 | std::string& aError); |
---|
| 31 | |
---|
| 32 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 33 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 34 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 35 | int main( |
---|
| 36 | int aArgc |
---|
| 37 | ,char** aArgv |
---|
| 38 | ) |
---|
| 39 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 40 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 41 | { |
---|
| 42 | std::vector<std::string> args; |
---|
| 43 | {for(int index=0;index<aArgc;index++) args.push_back(aArgv[index]);} |
---|
| 44 | |
---|
| 45 | std::string pack; |
---|
| 46 | std::string vers; |
---|
| 47 | if(args.size()==2) { |
---|
| 48 | pack = args[1]; |
---|
| 49 | } else if(args.size()==3) { |
---|
| 50 | pack = args[1]; |
---|
| 51 | vers = args[2]; |
---|
| 52 | } else { |
---|
| 53 | fprintf(stderr,"obuild_find : one or two arguments expected.\n"); |
---|
| 54 | printf("\n"); |
---|
| 55 | return EXIT_FAILURE; |
---|
| 56 | } |
---|
| 57 | |
---|
| 58 | //fprintf(stderr,"obuild_find : \"%s\" vers \"%s\"\n",pack.c_str(),vers.c_str()); |
---|
| 59 | |
---|
| 60 | std::string::size_type star = vers.find('*'); |
---|
| 61 | bool vers_wildcard = (star==std::string::npos?false:true); |
---|
| 62 | |
---|
| 63 | std::string opath; |
---|
| 64 | if(!Lib_System_getenv("OBUILD_PATH",opath)) { |
---|
| 65 | fprintf(stderr,"\ |
---|
| 66 | obuild_find : environment variable OBUILD_PATH not defined.\n\ |
---|
| 67 | \n\ |
---|
| 68 | OBUILD_PATH is a list of head directories\n\ |
---|
| 69 | containing packages. Directories are ':' separated on a UNIX\n\ |
---|
| 70 | and ';' separated on a Windows.\n\ |
---|
| 71 | \n\ |
---|
| 72 | For example, on a UNIX, if /work/project1 contains package pack1\n\ |
---|
| 73 | and /usr/project2 contains the package pack2 ; then\n\ |
---|
| 74 | having for the obuild directories the directory hierachies :\n\ |
---|
| 75 | /work/project1/pack1/<version>/obuild\n\ |
---|
| 76 | /usr/project2/pack2/<version>/obuild\n\ |
---|
| 77 | someone set the OBUILD_PATH variable under a csh flavoured\n\ |
---|
| 78 | shell with :\n\ |
---|
| 79 | csh> setenv OBUILD_PATH \"/work/project1:/usr/project2\"\n\ |
---|
| 80 | and under a sh flavoured shell with :\n\ |
---|
| 81 | sh> OBUILD_PATH=\"/work/project1:/usr/project2\"\n\ |
---|
| 82 | sh> export OBUILD_PATH\n\ |
---|
| 83 | Under DOS :\n\ |
---|
| 84 | DOS> SET OBUILD_PATH=C:\\work\\project1;D:\\usr\\project2\"\n\ |
---|
| 85 | \n\ |
---|
| 86 | "); |
---|
| 87 | printf("\n"); |
---|
| 88 | return EXIT_FAILURE; |
---|
| 89 | } |
---|
| 90 | |
---|
| 91 | std::string sep = Lib_System_pathSeparator(); |
---|
| 92 | std::vector<std::string> paths = Lib_smanip_words(opath,sep); |
---|
| 93 | |
---|
| 94 | std::string path,serr; |
---|
| 95 | std::string dir; |
---|
| 96 | if(!Lib_dirmanip_find(paths,pack,vers,dir,serr)) { |
---|
| 97 | fprintf(stderr,"%s\n",serr.c_str()); |
---|
| 98 | printf("\n"); |
---|
| 99 | return EXIT_FAILURE; |
---|
| 100 | } |
---|
| 101 | if(dir=="") { |
---|
| 102 | printf("\n"); |
---|
| 103 | return EXIT_FAILURE; //Not found. |
---|
| 104 | } |
---|
| 105 | printf("%s\n",dir.c_str()); |
---|
| 106 | return EXIT_SUCCESS; |
---|
| 107 | } |
---|
| 108 | |
---|
| 109 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 110 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 111 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 112 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 113 | bool Lib_System_getenv( |
---|
| 114 | const std::string& aString |
---|
| 115 | ,std::string& aValue |
---|
| 116 | ) |
---|
| 117 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 118 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 119 | { |
---|
| 120 | const char* env = ::getenv(aString.c_str()); |
---|
| 121 | if(env) { |
---|
| 122 | aValue = std::string(env?env:""); |
---|
| 123 | return true; |
---|
| 124 | } else { |
---|
| 125 | aValue = ""; |
---|
| 126 | return false; |
---|
| 127 | } |
---|
| 128 | } |
---|
| 129 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 130 | std::string Lib_System_fileSeparator( |
---|
| 131 | ) |
---|
| 132 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 133 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 134 | { |
---|
| 135 | #ifdef WIN32 |
---|
| 136 | return "\\"; |
---|
| 137 | #else |
---|
| 138 | return "/"; |
---|
| 139 | #endif |
---|
| 140 | } |
---|
| 141 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 142 | std::string Lib_System_pathSeparator( |
---|
| 143 | ) |
---|
| 144 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 145 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 146 | { |
---|
| 147 | #ifdef WIN32 |
---|
| 148 | return ";"; |
---|
| 149 | #else |
---|
| 150 | return ":"; |
---|
| 151 | #endif |
---|
| 152 | } |
---|
| 153 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 154 | #include <string.h> /* strcpy */ |
---|
| 155 | #include <stdlib.h> /* malloc,free */ |
---|
| 156 | |
---|
| 157 | #define Lib_strdup(str) ((str) != NULL ? (::strcpy((char*)::malloc((unsigned)::strlen(str) + 1), str)) : (char*)NULL) |
---|
| 158 | #define Lib_strdel(str) {if((str)!=NULL) {::free(str);str=NULL;}} |
---|
| 159 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 160 | bool Lib_smanip_match( |
---|
| 161 | const std::string& aString |
---|
| 162 | ,const std::string& aPattern |
---|
| 163 | ) |
---|
| 164 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 165 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 166 | { |
---|
| 167 | int lpattern = aPattern.length(); |
---|
| 168 | int lstring = aString.length(); |
---|
| 169 | if ((lpattern==0)&&(lstring==0)) return true; |
---|
| 170 | if ((lpattern==0)&&(lstring!=0)) return true; |
---|
| 171 | if ((lpattern!=0)&&(lstring==0)) return false; |
---|
| 172 | // pattern is * : |
---|
| 173 | if(aPattern=="*") return true; |
---|
| 174 | int wcount = 0; |
---|
| 175 | int count; |
---|
| 176 | for(count=0;count<lpattern;count++) { |
---|
| 177 | if(aPattern[count]=='*') wcount++; |
---|
| 178 | } |
---|
| 179 | // no wildcard : |
---|
| 180 | if(wcount==0) { |
---|
| 181 | return (aPattern==aString ? true : false ); |
---|
| 182 | } |
---|
| 183 | |
---|
| 184 | // complex pattern : |
---|
| 185 | #define PACKET 32 |
---|
| 186 | char** words = (char**)::malloc(PACKET * sizeof(char*)); |
---|
| 187 | if(words==NULL) return false; |
---|
| 188 | int wmax = PACKET; |
---|
| 189 | int wnumber= 0; |
---|
| 190 | char* s = Lib_strdup(aPattern.c_str()); |
---|
| 191 | char* token = s; |
---|
| 192 | while(1) { |
---|
| 193 | char* pos = ::strstr (token,"*"); |
---|
| 194 | if(pos) { |
---|
| 195 | *pos = '\0'; |
---|
| 196 | if(*token!='\0') { |
---|
| 197 | if(wnumber>=wmax) { |
---|
| 198 | words = (char**)::realloc(words,(wmax+PACKET) * sizeof(char*)); |
---|
| 199 | if(words==NULL) { |
---|
| 200 | Lib_strdel(s); |
---|
| 201 | return false; |
---|
| 202 | } |
---|
| 203 | wmax += PACKET; |
---|
| 204 | } |
---|
| 205 | words[wnumber] = token; |
---|
| 206 | wnumber++; |
---|
| 207 | } |
---|
| 208 | token = pos + 1; |
---|
| 209 | } else { // last word : |
---|
| 210 | if(*token!='\0') { |
---|
| 211 | if(wnumber>=wmax) { |
---|
| 212 | words = (char**)::realloc(words,(wmax+PACKET) * sizeof(char*)); |
---|
| 213 | if(words==NULL) { |
---|
| 214 | Lib_strdel(s); |
---|
| 215 | return false; |
---|
| 216 | } |
---|
| 217 | wmax += PACKET; |
---|
| 218 | } |
---|
| 219 | words[wnumber] = token; |
---|
| 220 | wnumber++; |
---|
| 221 | } |
---|
| 222 | break; |
---|
| 223 | } |
---|
| 224 | } |
---|
| 225 | // check that at least one word is not empty : |
---|
| 226 | bool ok = false; |
---|
| 227 | for(count=0;count<wnumber;count++) { |
---|
| 228 | if(*(words[count])!='\0') { |
---|
| 229 | ok = true; |
---|
| 230 | break; |
---|
| 231 | } |
---|
| 232 | } |
---|
| 233 | if(!ok) { // only wildcards : |
---|
| 234 | Lib_strdel(s); |
---|
| 235 | if(words) ::free(words); |
---|
| 236 | return true; |
---|
| 237 | } |
---|
| 238 | |
---|
| 239 | // loop on words : |
---|
| 240 | bool match = true; |
---|
| 241 | token = (char*)aString.c_str(); |
---|
| 242 | for(count=0;count<wnumber;count++) { |
---|
| 243 | int lword; |
---|
| 244 | lword = ::strlen(words[count]); |
---|
| 245 | if(lword>0) { |
---|
| 246 | char* pos; |
---|
| 247 | if(count==0) { |
---|
| 248 | if(aPattern[0]!='*') { |
---|
| 249 | // Begin of pattern (words[0]) and aString must match : |
---|
| 250 | if(::strncmp(token,words[count],lword)!=0) { |
---|
| 251 | match = false; // Different. |
---|
| 252 | break; |
---|
| 253 | } |
---|
| 254 | token = token + lword; |
---|
| 255 | continue; |
---|
| 256 | } |
---|
| 257 | } |
---|
| 258 | pos = ::strstr (token,words[count]); |
---|
| 259 | if(!pos) { |
---|
| 260 | match = false; |
---|
| 261 | break; |
---|
| 262 | } |
---|
| 263 | if((count==(wnumber-1)) && (aPattern[lpattern-1]!='*') ) { |
---|
| 264 | // Last word : |
---|
| 265 | if(::strcmp(aString.c_str()+lstring-lword,words[count])!=0) |
---|
| 266 | match = false; // Compare last word and end of aString. |
---|
| 267 | break; |
---|
| 268 | } else { |
---|
| 269 | token = pos + lword; |
---|
| 270 | } |
---|
| 271 | } |
---|
| 272 | } |
---|
| 273 | Lib_strdel(s); |
---|
| 274 | if(words) ::free(words); |
---|
| 275 | return match; |
---|
| 276 | } |
---|
| 277 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 278 | std::vector<std::string> Lib_smanip_words( |
---|
| 279 | const std::string& aString |
---|
| 280 | ,const std::string& aLimiter |
---|
| 281 | ,bool aTakeEmpty // false |
---|
| 282 | ) |
---|
| 283 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 284 | // If aLimiter is for exa "|" and for "xxx||xxx" : |
---|
| 285 | // - aTakeEmpty false : {"xxx","xxx"} will be created (and NOT {"xxx","","xxx"}). |
---|
| 286 | // - aTakeEmpty true : {"xxx","","xxx"} will be created. |
---|
| 287 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 288 | { |
---|
| 289 | std::vector<std::string> words; |
---|
| 290 | if(aString=="") return words; |
---|
| 291 | std::string::size_type lim = (aTakeEmpty?0:1); |
---|
| 292 | if(aLimiter=="") { |
---|
| 293 | words.push_back(aString); |
---|
| 294 | } else { |
---|
| 295 | std::string::size_type l = aString.length(); |
---|
| 296 | std::string::size_type llimiter = aLimiter.length(); |
---|
| 297 | std::string::size_type pos = 0; |
---|
| 298 | while(1) { |
---|
| 299 | std::string::size_type index = aString.find(aLimiter,pos); |
---|
| 300 | if(index==std::string::npos){ // Last word. |
---|
| 301 | if((l-pos)>=lim) words.push_back(aString.substr(pos,l-pos)); |
---|
| 302 | break; |
---|
| 303 | } else { |
---|
| 304 | // abcxxxef |
---|
| 305 | // 0 3 67 |
---|
| 306 | if((index-pos)>=lim) words.push_back(aString.substr(pos,index-pos)); |
---|
| 307 | pos = index + llimiter; |
---|
| 308 | } |
---|
| 309 | } |
---|
| 310 | } |
---|
| 311 | return words; |
---|
| 312 | } |
---|
| 313 | #include <stdarg.h> |
---|
| 314 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 315 | bool Lib_smanip_printf( |
---|
| 316 | std::string& aString |
---|
| 317 | ,int aLength |
---|
| 318 | ,const char* aFormat |
---|
| 319 | ,... |
---|
| 320 | ) |
---|
| 321 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 322 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 323 | { |
---|
| 324 | aString = ""; |
---|
| 325 | if(aLength<0) return false; |
---|
| 326 | if(!aFormat) return false; |
---|
| 327 | char* s = new char[aLength+1]; |
---|
| 328 | if(!s) return false; |
---|
| 329 | s[aLength] = '\0'; |
---|
| 330 | va_list args; |
---|
| 331 | va_start (args,aFormat); |
---|
| 332 | vsprintf (s,aFormat,args); |
---|
| 333 | va_end (args); |
---|
| 334 | if(s[aLength]!='\0') { |
---|
| 335 | delete [] s; |
---|
| 336 | return false; |
---|
| 337 | } |
---|
| 338 | aString = s; |
---|
| 339 | delete [] s; |
---|
| 340 | return true; |
---|
| 341 | } |
---|
| 342 | |
---|
| 343 | #ifdef WIN32 |
---|
| 344 | #include <windows.h> |
---|
| 345 | #include <direct.h> |
---|
| 346 | #else //UNIX |
---|
| 347 | #include <dirent.h> |
---|
| 348 | #if defined(_POSIX_SOURCE) |
---|
| 349 | #define REAL_DIR_ENTRY(dp) 1 |
---|
| 350 | #else |
---|
| 351 | #define REAL_DIR_ENTRY(dp) (dp->d_ino != 0) |
---|
| 352 | #endif |
---|
| 353 | #include <unistd.h> |
---|
| 354 | #endif |
---|
| 355 | |
---|
| 356 | #include <sys/stat.h> |
---|
| 357 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 358 | bool Lib_dirmanip_entries( |
---|
| 359 | const std::string& aPath |
---|
| 360 | ,std::vector<std::string>& aList |
---|
| 361 | ,bool aFullPath |
---|
| 362 | ) |
---|
| 363 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 364 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 365 | { |
---|
| 366 | aList.clear(); |
---|
| 367 | struct stat finfo; |
---|
| 368 | if (::stat(aPath.c_str(),&finfo) < 0) return false; |
---|
| 369 | #ifdef WIN32 |
---|
| 370 | if (!(finfo.st_mode & S_IFDIR)) return false; |
---|
| 371 | std::string entry = aPath; |
---|
| 372 | if (!(entry[entry.size()] == '/' || entry[entry.size()] == '\\' )) |
---|
| 373 | entry += "\\"; |
---|
| 374 | entry += "*"; |
---|
| 375 | WIN32_FIND_DATA findFileData; |
---|
| 376 | HANDLE dir = ::FindFirstFile(entry.c_str(),&findFileData); |
---|
| 377 | if(dir == INVALID_HANDLE_VALUE) return false; |
---|
| 378 | // Get file names : |
---|
| 379 | for (;;) { |
---|
| 380 | if(!::FindNextFile(dir,&findFileData)) break; |
---|
| 381 | std::string name = (const char*)findFileData.cFileName; |
---|
| 382 | if(aFullPath) |
---|
| 383 | aList.push_back(aPath+"\\"+name); |
---|
| 384 | else |
---|
| 385 | aList.push_back(name); |
---|
| 386 | } |
---|
| 387 | ::FindClose(dir); |
---|
| 388 | #else |
---|
| 389 | if (!S_ISDIR(finfo.st_mode)) return false; |
---|
| 390 | DIR* dir = ::opendir(aPath.c_str()); |
---|
| 391 | if(!dir) return false; |
---|
| 392 | // Get file names : |
---|
| 393 | for (;;) { |
---|
| 394 | struct dirent* dp = ::readdir(dir); |
---|
| 395 | //struct direct* dp; |
---|
| 396 | if (dp==NULL) break; |
---|
| 397 | if (REAL_DIR_ENTRY(dp)) { |
---|
| 398 | std::string name = dp->d_name; |
---|
| 399 | // Be sure we can work on the file : |
---|
| 400 | std::string fname = aPath+"/"+name; |
---|
| 401 | if (::stat(fname.c_str(),&finfo) < 0) continue; |
---|
| 402 | if(aFullPath) |
---|
| 403 | aList.push_back(fname); |
---|
| 404 | else |
---|
| 405 | aList.push_back(name); |
---|
| 406 | } |
---|
| 407 | } |
---|
| 408 | ::closedir(dir); |
---|
| 409 | #endif |
---|
| 410 | return true; |
---|
| 411 | } |
---|
| 412 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 413 | bool Lib_dirmanip_isAnEntry( |
---|
| 414 | const std::string& aPath |
---|
| 415 | ,const std::string& aName |
---|
| 416 | ,bool& aFound |
---|
| 417 | ) |
---|
| 418 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 419 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 420 | { |
---|
| 421 | aFound = false; |
---|
| 422 | struct stat finfo; |
---|
| 423 | if (::stat(aPath.c_str(),&finfo) < 0) return false; |
---|
| 424 | #ifdef WIN32 |
---|
| 425 | if (!(finfo.st_mode & S_IFDIR)) return false; |
---|
| 426 | std::string entry = aPath; |
---|
| 427 | if (!(entry[entry.size()] == '/' || entry[entry.size()] == '\\' )) |
---|
| 428 | entry += "\\"; |
---|
| 429 | entry += "*"; |
---|
| 430 | WIN32_FIND_DATA findFileData; |
---|
| 431 | HANDLE dir = ::FindFirstFile(entry.c_str(),&findFileData); |
---|
| 432 | if(dir == INVALID_HANDLE_VALUE) return false; |
---|
| 433 | // Get file names : |
---|
| 434 | for (;;) { |
---|
| 435 | if(!::FindNextFile(dir,&findFileData)) break; |
---|
| 436 | std::string name = (const char*)findFileData.cFileName; |
---|
| 437 | if(name==aName) { |
---|
| 438 | aFound = true; |
---|
| 439 | ::FindClose(dir); |
---|
| 440 | return true; |
---|
| 441 | } |
---|
| 442 | } |
---|
| 443 | ::FindClose(dir); |
---|
| 444 | #else |
---|
| 445 | if (!S_ISDIR(finfo.st_mode)) return false; |
---|
| 446 | DIR* dir = ::opendir(aPath.c_str()); |
---|
| 447 | if(!dir) return false; |
---|
| 448 | // Get file names : |
---|
| 449 | for (;;) { |
---|
| 450 | struct dirent* dp = ::readdir(dir); |
---|
| 451 | //struct direct* dp; |
---|
| 452 | if (dp==NULL) break; |
---|
| 453 | if (REAL_DIR_ENTRY(dp)) { |
---|
| 454 | std::string name = dp->d_name; |
---|
| 455 | if(name==aName) { |
---|
| 456 | aFound = true; |
---|
| 457 | ::closedir(dir); |
---|
| 458 | return true; |
---|
| 459 | } |
---|
| 460 | } |
---|
| 461 | } |
---|
| 462 | ::closedir(dir); |
---|
| 463 | #endif |
---|
| 464 | return true; |
---|
| 465 | } |
---|
| 466 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 467 | bool Lib_dirmanip_find( |
---|
| 468 | const std::vector<std::string>& aPaths |
---|
| 469 | ,const std::string& aPackage |
---|
| 470 | ,const std::string& aVersion |
---|
| 471 | ,std::string& aPath |
---|
| 472 | ,std::string& aError |
---|
| 473 | ) |
---|
| 474 | ////////////////////////////////////////////////////////////////////////////// |
---|
| 475 | // aVersion could be empty and can contain woldcards. |
---|
| 476 | // The list of paths is searched first to last. |
---|
| 477 | // return true and aPath="" mean not found. |
---|
| 478 | // return false : something went wrong in directory manipulation. |
---|
| 479 | // aError contains then an error message. |
---|
| 480 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!// |
---|
| 481 | { |
---|
| 482 | if(aPackage=="") { |
---|
| 483 | aError = "Lib::dirmanip::find : empty package name."; |
---|
| 484 | return false; |
---|
| 485 | } |
---|
| 486 | |
---|
| 487 | std::string sep = Lib_System_fileSeparator(); |
---|
| 488 | |
---|
| 489 | std::string::size_type star = aVersion.find('*'); |
---|
| 490 | bool vers_wildcard = (star==std::string::npos?false:true); |
---|
| 491 | |
---|
| 492 | unsigned int pathn = aPaths.size(); |
---|
| 493 | //fprintf(stderr,"obuild_find : number of path %d\n",pathn); |
---|
| 494 | for(unsigned int pathi=0;pathi<pathn;pathi++) { |
---|
| 495 | std::string dir = aPaths[pathi]; |
---|
| 496 | //fprintf(stderr,"Lib::dirmanip::find : look directory \"%s\"\n", |
---|
| 497 | // dir.c_str()); |
---|
| 498 | bool found; |
---|
| 499 | if(!Lib_dirmanip_isAnEntry(dir,aPackage,found)) { |
---|
| 500 | aPath = ""; |
---|
| 501 | Lib_smanip_printf(aError,128+dir.size(), |
---|
| 502 | "Lib::dirmanip::find : can't open directory \"%s\"\n",dir.c_str()); |
---|
| 503 | return false; |
---|
| 504 | } |
---|
| 505 | if(found) { |
---|
| 506 | if(aVersion=="") { |
---|
| 507 | dir += sep+aPackage; |
---|
| 508 | aPath = dir; |
---|
| 509 | aError = ""; |
---|
| 510 | return true; |
---|
| 511 | } |
---|
| 512 | // Look version : |
---|
| 513 | dir += sep+aPackage; |
---|
| 514 | if(vers_wildcard) { |
---|
| 515 | std::vector<std::string> files; |
---|
| 516 | if(Lib_dirmanip_entries(dir,files,false)) { |
---|
| 517 | unsigned int number = files.size(); |
---|
| 518 | for(unsigned int index=0;index<number;index++) { |
---|
| 519 | const std::string& file = files[index]; |
---|
| 520 | //std::string p,n,s; |
---|
| 521 | //Lib::smanip::pathNameSuffix(file,p,n,s); |
---|
| 522 | if(Lib_smanip_match(file,aVersion)) { |
---|
| 523 | dir += sep+file; |
---|
| 524 | aPath = dir; |
---|
| 525 | aError = ""; |
---|
| 526 | return true; |
---|
| 527 | } |
---|
| 528 | } |
---|
| 529 | } |
---|
| 530 | } else { |
---|
| 531 | bool found; |
---|
| 532 | if(!Lib_dirmanip_isAnEntry(dir,aVersion,found)) { |
---|
| 533 | aPath = ""; |
---|
| 534 | Lib_smanip_printf(aError,128+dir.size(), |
---|
| 535 | "Lib::dirmanip::find : can't open directory \"%s\"\n",dir.c_str()); |
---|
| 536 | return false; |
---|
| 537 | } |
---|
| 538 | dir += sep+aVersion; |
---|
| 539 | aPath = dir; |
---|
| 540 | aError = ""; |
---|
| 541 | return true; |
---|
| 542 | } |
---|
| 543 | } |
---|
| 544 | } |
---|
| 545 | |
---|
| 546 | aPath = ""; // return true and aPath="" mean not found. |
---|
| 547 | aError = ""; |
---|
| 548 | return true; |
---|
| 549 | } |
---|