cinelerra-5.1/guicast/filesystem.C

   1 /*
   2  * CINELERRA
   3  * Copyright (C) 2010 Adam Williams <broadcast at earthling dot net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  18  *
  19  */
  20
  21 #include "bcsignals.h"
  22 #include "cstrdup.h"
  23 #include <dirent.h>
  24 #include <errno.h>
  25 #include <pwd.h>
  26 #include <stddef.h>
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <string.h>
  30 #include <sys/stat.h>
  31 #include <sys/types.h>
  32 #include <time.h>
  33 #include <unistd.h>
  34 #include <utime.h>
  35
  36
  37 #include "filesystem.h"
  38
  39 FileItem::FileItem()
  40 {
  41         path = 0;
  42         name = 0;
  43         reset();
  44 }
  45
  46 FileItem::FileItem(char *path, char *name, int is_dir,
  47         int64_t size, int month, int day, int year,
  48         int64_t calendar_time, int item_no)
  49 {
  50         this->path = new char[strlen(path)];
  51         this->name = new char[strlen(name)];
  52         if(this->path) strcpy(this->path, path);
  53         if(this->name) strcpy(this->name, name);
  54         this->is_dir = is_dir;
  55         this->size = size;
  56         this->month = month;
  57         this->day = day;
  58         this->year = year;
  59         this->calendar_time = calendar_time;
  60         this->item_no = item_no;
  61 }
  62
  63 FileItem::~FileItem()
  64 {
  65         reset();
  66 }
  67
  68 int FileItem::reset()
  69 {
  70         if(this->path) delete [] this->path;
  71         if(this->name) delete [] this->name;
  72         path = 0;
  73         name = 0;
  74         is_dir = 0;
  75         size = 0;
  76         month = 0;
  77         day = 0;
  78         year = 0;
  79         calendar_time = 0;
  80         item_no = -1;
  81         return 0;
  82 }
  83
  84 int FileItem::set_path(char *path)
  85 {
  86         if(this->path) delete [] this->path;
  87         this->path = new char[strlen(path) + 1];
  88         strcpy(this->path, path);
  89         return 0;
  90 }
  91
  92 int FileItem::set_name(char *name)
  93 {
  94         if(this->name) delete [] this->name;
  95         this->name = new char[strlen(name) + 1];
  96         strcpy(this->name, name);
  97         return 0;
  98 }
  99
 100
 101
 102 FileSystem::FileSystem()
 103 {
 104         reset_parameters();
 105         (void)getcwd(current_dir, BCTEXTLEN);
 106 }
 107
 108 FileSystem::~FileSystem()
 109 {
 110         delete_directory();
 111 }
 112
 113 int FileSystem::reset_parameters()
 114 {
 115         show_all_files = 0;
 116         want_directory = 0;
 117         strcpy(filter, "");
 118         strcpy(current_dir, "");
 119         sort_order = SORT_ASCENDING;
 120         sort_field = SORT_PATH;
 121         return 0;
 122 }
 123
 124 int FileSystem::delete_directory()
 125 {
 126         dir_list.remove_all_objects();
 127         return 0;
 128 }
 129
 130 int FileSystem::set_sort_order(int value)
 131 {
 132         this->sort_order = value;
 133         return 0;
 134 }
 135
 136 int FileSystem::set_sort_field(int field)
 137 {
 138         this->sort_field = field;
 139         return 0;
 140 }
 141
 142 // filename.with.dots.extension
 143 //   becomes
 144 // extension.dots.with.filename
 145
 146 int FileSystem::dot_reverse_filename(char *out, const char *in)
 147 {
 148         int i, i2, j=0, lastdot;
 149         lastdot = strlen(in);
 150         for ( i=strlen(in); --i >= 0; ) {
 151                 if (in[i] == '.') {
 152                         i2 = i+1;
 153                                 while (i2 < lastdot)
 154                                         out[j++] = in[i2++];
 155                         out[j++] = in[i];
 156                         lastdot = i;
 157                 }
 158         }
 159         if (in[++i] != '.') {
 160                 while (i < lastdot) out[j++] = in[i++];
 161         }
 162         out[j++] = '\0';
 163         return 0;
 164 }
 165
 166 int FileSystem::path_ascending(const void *ptr1, const void *ptr2)
 167 {
 168         FileItem *item1 = *(FileItem**)ptr1;
 169         FileItem *item2 = *(FileItem**)ptr2;
 170 //printf("path_ascending %p %p\n", ptr1, ptr2);
 171         int ret = strcasecmp(item1->name, item2->name);
 172         if( ret != 0 ) return ret;
 173         return item1->item_no - item2->item_no;
 174 }
 175
 176 int FileSystem::path_descending(const void *ptr1, const void *ptr2)
 177 {
 178         FileItem *item1 = *(FileItem**)ptr1;
 179         FileItem *item2 = *(FileItem**)ptr2;
 180         int ret = strcasecmp(item2->name, item1->name);
 181         if( ret != 0 ) return ret;
 182         return item2->item_no - item1->item_no;
 183 }
 184
 185
 186 int FileSystem::size_ascending(const void *ptr1, const void *ptr2)
 187 {
 188         FileItem *item1 = *(FileItem**)ptr1;
 189         FileItem *item2 = *(FileItem**)ptr2;
 190         return item1->size == item2->size ?
 191                 item1->item_no - item2->item_no :
 192                 item1->size > item2->size;
 193 }
 194
 195 int FileSystem::size_descending(const void *ptr1, const void *ptr2)
 196 {
 197         FileItem *item1 = *(FileItem**)ptr1;
 198         FileItem *item2 = *(FileItem**)ptr2;
 199         return item2->size == item1->size ?
 200                 item2->item_no - item1->item_no :
 201                 item2->size > item1->size;
 202 }
 203
 204
 205 int FileSystem::date_ascending(const void *ptr1, const void *ptr2)
 206 {
 207         FileItem *item1 = *(FileItem**)ptr1;
 208         FileItem *item2 = *(FileItem**)ptr2;
 209         return item1->calendar_time == item2->calendar_time ?
 210                 item1->item_no - item2->item_no :
 211                 item1->calendar_time > item2->calendar_time;
 212 }
 213
 214 int FileSystem::date_descending(const void *ptr1, const void *ptr2)
 215 {
 216         FileItem *item1 = *(FileItem**)ptr1;
 217         FileItem *item2 = *(FileItem**)ptr2;
 218         return item2->calendar_time == item1->calendar_time ?
 219                 item2->item_no - item1->item_no :
 220                 item2->calendar_time > item1->calendar_time;
 221 }
 222
 223 int FileSystem::ext_ascending(const void *ptr1, const void *ptr2)
 224 {
 225         FileItem *item1 = *(FileItem**)ptr1;
 226         FileItem *item2 = *(FileItem**)ptr2;
 227         char *ext1 = strrchr(item1->name,'.');
 228         if( !ext1 ) ext1 = item1->name;
 229         char *ext2 = strrchr(item2->name,'.');
 230         if( !ext2 ) ext2 = item2->name;
 231         int ret = strcasecmp(ext1, ext2);
 232         if( ret ) return ret;
 233         if( item1->item_no >= 0 && item2->item_no >= 0 )
 234                 return item1->item_no - item2->item_no;
 235         char dotreversedname1[BCTEXTLEN], dotreversedname2[BCTEXTLEN];
 236         dot_reverse_filename(dotreversedname1,item1->name);
 237         dot_reverse_filename(dotreversedname2,item2->name);
 238         return strcasecmp(dotreversedname1, dotreversedname2);
 239 }
 240
 241 int FileSystem::ext_descending(const void *ptr1, const void *ptr2)
 242 {
 243         FileItem *item1 = *(FileItem**)ptr1;
 244         FileItem *item2 = *(FileItem**)ptr2;
 245         char *ext1 = strrchr(item1->name,'.');
 246         if( !ext1 ) ext1 = item1->name;
 247         char *ext2 = strrchr(item2->name,'.');
 248         if( !ext2 ) ext2 = item2->name;
 249         int ret = strcasecmp(ext2, ext1);
 250         if( ret ) return ret;
 251         if( item2->item_no >= 0 && item1->item_no >= 0 )
 252                 return item2->item_no - item1->item_no;
 253         char dotreversedname1[BCTEXTLEN], dotreversedname2[BCTEXTLEN];
 254         dot_reverse_filename(dotreversedname1,item1->name);
 255         dot_reverse_filename(dotreversedname2,item2->name);
 256         return strcasecmp(dotreversedname2, dotreversedname1);
 257 }
 258
 259 int FileSystem::sort_table(ArrayList<FileItem*> *dir_list)
 260 {
 261         if(!dir_list || !dir_list->size()) return 0;
 262         static int (*cmpr[][2])(const void *ptr1, const void *ptr2) = {
 263                 { &path_ascending, &path_descending },
 264                 { &size_ascending, &size_descending },
 265                 { &date_ascending, &date_descending },
 266                 { &ext_ascending,  &ext_descending  },
 267         };
 268
 269         qsort(dir_list->values,
 270                 dir_list->size(), sizeof(FileItem*),
 271                 cmpr[sort_field][sort_order]);
 272
 273         return 0;
 274 }
 275
 276 int FileSystem::combine(ArrayList<FileItem*> *dir_list, ArrayList<FileItem*> *file_list)
 277 {
 278         int i;
 279
 280         sort_table(dir_list);
 281         for(i = 0; i < dir_list->total; i++)
 282         {
 283                 this->dir_list.append(dir_list->values[i]);
 284         }
 285
 286         sort_table(file_list);
 287         for(i = 0; i < file_list->total; i++)
 288         {
 289                 this->dir_list.append(file_list->values[i]);
 290         }
 291         return 0;
 292 }
 293
 294 int FileSystem::test_filter(FileItem *file)
 295 {
 296         char *filter1 = 0, *filter2 = filter, *subfilter1, *subfilter2;
 297         int result = 0;
 298         int done = 0, token_done;
 299         int token_number = 0;
 300
 301 // Don't filter directories
 302         if(file->is_dir) return 0;
 303
 304 // Empty filename string
 305         if(!file->name) return 1;
 306
 307         do
 308         {
 309 // Get next token
 310                 filter1 = strchr(filter2, '[');
 311                 string[0] = 0;
 312
 313 // Get next filter
 314                 if(filter1)
 315                 {
 316                         filter1++;
 317                         filter2 = strchr(filter1, ']');
 318
 319                         if(filter2)
 320                         {
 321                                 int i;
 322                                 for(i = 0; filter1 + i < filter2; i++)
 323                                         string[i] = filter1[i];
 324                                 string[i] = 0;
 325                         }
 326                         else
 327                         {
 328                                 strcpy(string, filter1);
 329                                 done = 1;
 330                         }
 331                 }
 332                 else
 333                 {
 334                         if(!token_number)
 335                                 strcpy(string, filter);
 336                         else
 337                                 done = 1;
 338                 }
 339
 340 // Process the token
 341                 if(string[0] != 0)
 342                 {
 343                         char *path = file->name;
 344                         subfilter1 = string;
 345                         token_done = 0;
 346                         result = 0;
 347
 348                         do
 349                         {
 350                                 string2[0] = 0;
 351                                 subfilter2 = strchr(subfilter1, '*');
 352
 353                                 if(subfilter2)
 354                                 {
 355                                         int i;
 356                                         for(i = 0; subfilter1 + i < subfilter2; i++)
 357                                                 string2[i] = subfilter1[i];
 358
 359                                         string2[i] = 0;
 360                                 }
 361                                 else
 362                                 {
 363                                         strcpy(string2, subfilter1);
 364                                         token_done = 1;
 365                                 }
 366
 367                                 if(string2[0] != 0)
 368                                 {
 369 // Subfilter must exist at some later point in the string
 370                                         if(subfilter1 > string)
 371                                         {
 372                                                 if(!strstr(path, string2))
 373                                                 {
 374                                                         result = 1;
 375                                                         token_done = 1;
 376                                                 }
 377                                                 else
 378                                                 path = strstr(path, string2) + strlen(string2);
 379                                         }
 380                                         else
 381 // Subfilter must exist at this point in the string
 382                                         {
 383                                                 if(strncmp(path, string2, strlen(string2)))
 384 //                                              if(strncasecmp(path, string2, strlen(string2)))
 385                                                 {
 386                                                         result = 1;
 387                                                         token_done = 1;
 388                                                 }
 389                                                 else
 390                                                 path += strlen(string2);
 391                                         }
 392
 393 // String must terminate after subfilter
 394                                         if(!subfilter2)
 395                                         {
 396                                                 if(*path != 0)
 397                                                 {
 398                                                         result = 1;
 399                                                         token_done = 1;
 400                                                 }
 401                                         }
 402                                 }
 403                                 subfilter1 = subfilter2 + 1;
 404 // Let pass if no subfilter
 405                         }while(!token_done && !result);
 406                 }
 407                 token_number++;
 408         }while(!done && result);
 409
 410         return result;
 411 }
 412
 413
 414 int FileSystem::scan_directory(const char *new_dir)
 415 {
 416         if( new_dir != 0 )
 417                 strcpy(current_dir, new_dir);
 418         DIR *dirstream = opendir(current_dir);
 419         if( !dirstream ) return 1;          // failed to open directory
 420
 421         struct dirent64 *new_filename;
 422         while( (new_filename = readdir64(dirstream)) != 0 ) {
 423                 FileItem *new_file = 0;
 424                 int include_this = 1;
 425
 426 // File is directory heirarchy
 427                 if(!strcmp(new_filename->d_name, ".") ||
 428                         !strcmp(new_filename->d_name, "..")) include_this = 0;
 429
 430 // File is hidden and we don't want all files
 431                 if(include_this &&
 432                         !show_all_files &&
 433                         new_filename->d_name[0] == '.') include_this = 0;
 434
 435 // file not hidden
 436                 if(include_this)
 437                 {
 438                         new_file = new FileItem;
 439                         char full_path[BCTEXTLEN], name_only[BCTEXTLEN];
 440                         sprintf(full_path, "%s", current_dir);
 441                         add_end_slash(full_path);
 442                         strcat(full_path, new_filename->d_name);
 443                         strcpy(name_only, new_filename->d_name);
 444                         new_file->set_path(full_path);
 445                         new_file->set_name(name_only);
 446
 447 // Get information about the file.
 448                         struct stat ostat;
 449                         if(!stat(full_path, &ostat))
 450                         {
 451                                 new_file->size = ostat.st_size;
 452                                 struct tm *mod_time = localtime(&(ostat.st_mtime));
 453                                 new_file->month = mod_time->tm_mon + 1;
 454                                 new_file->day = mod_time->tm_mday;
 455                                 new_file->year = mod_time->tm_year + 1900;
 456                                 new_file->calendar_time = ostat.st_mtime;
 457
 458                                 if(S_ISDIR(ostat.st_mode))
 459                                 {
 460                                         strcat(name_only, "/"); // is a directory
 461                                         new_file->is_dir = 1;
 462                                 }
 463
 464 // File is excluded from filter
 465                                 if(include_this && test_filter(new_file)) include_this = 0;
 466 //printf("FileSystem::update 3 %d %d\n", include_this, test_filter(new_file));
 467
 468 // File is not a directory and we just want directories
 469                                 if(include_this && want_directory && !new_file->is_dir) include_this = 0;
 470                         }
 471                         else
 472                         {
 473                                 printf("FileSystem::update %s %s\n", full_path, strerror(errno));
 474                                 include_this = 0;
 475                         }
 476
 477 // add to list
 478                         if(include_this)
 479                                 dir_list.append(new_file);
 480                         else
 481                                 delete new_file;
 482                 }
 483         }
 484         closedir(dirstream);
 485         return 0;
 486 }
 487
 488 int FileSystem::update(const char *new_dir)
 489 {
 490         delete_directory();
 491         int result = scan_directory(new_dir);
 492 // combine the directories and files in the master list
 493         return !result ? update_sort() : result;
 494 }
 495
 496 int FileSystem::update_sort()
 497 {
 498         ArrayList<FileItem*> directories, files;
 499         for( int i=0; i< dir_list.size(); ++i ) {
 500                 FileItem *item = dir_list[i];
 501                 item->item_no = i;
 502                 (item->is_dir ? &directories : &files)->append(item);
 503         }
 504         dir_list.remove_all();
 505 // combine the directories and files in the master list
 506         combine(&directories, &files);
 507         return 0;
 508 // success
 509 }
 510
 511
 512 int FileSystem::set_filter(const char *new_filter)
 513 {
 514         strcpy(filter, new_filter);
 515         return 0;
 516 }
 517
 518 int FileSystem::set_show_all()
 519 {
 520         show_all_files = 1;
 521         return 0;
 522 }
 523
 524 int FileSystem::set_want_directory()
 525 {
 526         want_directory = 1;
 527         return 0;
 528 }
 529
 530 int FileSystem::is_dir(const char *path)      // return 0 if the text is a directory
 531 {
 532         if(!strlen(path)) return 0;
 533
 534         char new_dir[BCTEXTLEN];
 535         struct stat ostat;    // entire name is a directory
 536
 537         strcpy(new_dir, path);
 538         complete_path(new_dir);
 539         if(!stat(new_dir, &ostat) && S_ISDIR(ostat.st_mode))
 540                 return 1;
 541         else
 542                 return 0;
 543 }
 544
 545 int FileSystem::create_dir(const char *new_dir_)
 546 {
 547         char new_dir[BCTEXTLEN];
 548         strcpy(new_dir, new_dir_);
 549         complete_path(new_dir);
 550
 551         mkdir(new_dir, S_IREAD | S_IWRITE | S_IEXEC);
 552         return 0;
 553 }
 554
 555 int FileSystem::parse_tildas(char *new_dir)
 556 {
 557         if(new_dir[0] == 0) return 1;
 558
 559 // Our home directory
 560         if(new_dir[0] == '~')
 561         {
 562
 563                 if(new_dir[1] == '/' || new_dir[1] == 0)
 564                 {
 565 // user's home directory
 566                         char *home;
 567                         char string[BCTEXTLEN];
 568                         home = getenv("HOME");
 569
 570 // print starting after tilda
 571                         if(home) sprintf(string, "%s%s", home, &new_dir[1]);
 572                         strcpy(new_dir, string);
 573                         return 0;
 574                 }
 575                 else
 576 // Another user's home directory
 577                 {
 578                         char string[BCTEXTLEN], new_user[BCTEXTLEN];
 579                         struct passwd *pw;
 580                         int i, j;
 581
 582                         for(i = 1, j = 0; new_dir[i] != 0 && new_dir[i] != '/'; i++, j++)
 583                         {                // copy user name
 584                                 new_user[j] = new_dir[i];
 585                         }
 586                         new_user[j] = 0;
 587
 588                         setpwent();
 589                         while( (pw = getpwent()) != 0 )
 590                         {
 591 // get info for user
 592                                 if(!strcmp(pw->pw_name, new_user))
 593                                 {
 594 // print starting after tilda
 595                                 sprintf(string, "%s%s", pw->pw_dir, &new_dir[i]);
 596                                 strcpy(new_dir, string);
 597                                 break;
 598                         }
 599                         }
 600                         endpwent();
 601                         return 0;
 602                 }
 603         }
 604         return 0;
 605 }
 606
 607 int FileSystem::parse_directories(char *new_dir)
 608 {
 609 //printf("FileSystem::parse_directories 1 %s\n", new_dir);
 610         if( *new_dir != '/' && current_dir[0] ) {  // expand to abs path
 611                 char string[BCTEXTLEN];
 612                 strcpy(string, current_dir);
 613                 add_end_slash(string);
 614                 strcat(string, new_dir);
 615                 strcpy(new_dir, string);
 616         }
 617         return 0;
 618 }
 619
 620 int FileSystem::parse_dots(char *new_dir)
 621 {
 622 // recursively remove ..s
 623         int changed = 1;
 624         while(changed)
 625         {
 626                 int i, j, len;
 627                 len = strlen(new_dir);
 628                 changed = 0;
 629                 for(i = 0, j = 1; !changed && j < len; i++, j++)
 630                 {
 631 // Got 2 dots
 632                         if(new_dir[i] == '.' && new_dir[j] == '.')
 633                         {
 634 // Ignore if character after .. doesn't qualify
 635                                 if(j + 1 < len &&
 636                                         new_dir[j + 1] != ' ' &&
 637                                         new_dir[j + 1] != '/')
 638                                         continue;
 639
 640 // Ignore if character before .. doesn't qualify
 641                                 if(i > 0 &&
 642                                         new_dir[i - 1] != '/') continue;
 643
 644                                 changed = 1;
 645                                 while(new_dir[i] != '/' && i > 0)
 646                                 {
 647 // look for first / before ..
 648                                         i--;
 649                                 }
 650
 651 // find / before this /
 652                                 if(i > 0) i--;
 653                                 while(new_dir[i] != '/' && i > 0)
 654                                 {
 655 // look for first / before first / before ..
 656                                         i--;
 657                                 }
 658
 659 // i now equals /first filename before ..
 660 // look for first / after ..
 661                                 while(new_dir[j] != '/' && j < len)
 662                                 {
 663                                         j++;
 664                                 }
 665
 666 // j now equals /first filename after ..
 667                                 while(j < len)
 668                                 {
 669                                         new_dir[i++] = new_dir[j++];
 670                                 }
 671
 672                                 new_dir[i] = 0;
 673 // default to root directory
 674                                 if((new_dir[0]) == 0) sprintf(new_dir, "/");
 675                                 break;
 676                         }
 677                 }
 678         }
 679         return 0;
 680 }
 681
 682 int FileSystem::complete_path(char *filename)
 683 {
 684 //printf("FileSystem::complete_path 1\n");
 685         if(!strlen(filename)) return 1;
 686 //printf("FileSystem::complete_path 1\n");
 687         parse_tildas(filename);
 688 //printf("FileSystem::complete_path 1\n");
 689         parse_directories(filename);
 690 //printf("FileSystem::complete_path 1\n");
 691         parse_dots(filename);
 692 // don't add end slash since this requires checking if dir
 693 //printf("FileSystem::complete_path 2\n");
 694         return 0;
 695 }
 696
 697 int FileSystem::extract_dir(char *out, const char *in)
 698 {
 699         strcpy(out, in);
 700         if(!is_dir(in))
 701         {
 702 // complete string is not directory
 703                 int i;
 704
 705                 complete_path(out);
 706
 707                 for(i = strlen(out); i > 0 && out[i - 1] != '/'; i--)
 708                 {
 709                         ;
 710                 }
 711                 if(i >= 0) out[i] = 0;
 712         }
 713         return 0;
 714 }
 715
 716 int FileSystem::extract_name(char *out, const char *in, int test_dir)
 717 {
 718         int i;
 719
 720         if(test_dir && is_dir(in))
 721                 out[0] = 0; // complete string is directory
 722         else
 723         {
 724                 for(i = strlen(in)-1; i > 0 && in[i] != '/'; i--)
 725                 {
 726                         ;
 727                 }
 728                 if(in[i] == '/') i++;
 729                 strcpy(out, &in[i]);
 730         }
 731         return 0;
 732 }
 733
 734 int FileSystem::join_names(char *out, const char *dir_in, const char *name_in)
 735 {
 736         strcpy(out, dir_in);
 737         int len = strlen(out);
 738         int result = 0;
 739
 740         while(!result)
 741                 if(len == 0 || out[len] != 0) result = 1; else len--;
 742
 743         if(len != 0)
 744         {
 745                 if(out[len] != '/') strcat(out, "/");
 746         }
 747
 748         strcat(out, name_in);
 749         return 0;
 750 }
 751
 752 int64_t FileSystem::get_date(const char *filename)
 753 {
 754         struct stat file_status;
 755         bzero(&file_status, sizeof(struct stat));
 756         int result = stat(filename, &file_status);
 757         return !result ? file_status.st_mtime : -1;
 758 }
 759
 760 void FileSystem::set_date(const char *path, int64_t value)
 761 {
 762         struct utimbuf new_time;
 763         new_time.actime = value;
 764         new_time.modtime = value;
 765         utime(path, &new_time);
 766 }
 767
 768 int64_t FileSystem::get_size(char *filename)
 769 {
 770         struct stat file_status;
 771         bzero(&file_status, sizeof(struct stat));
 772         int result = stat(filename, &file_status);
 773         return !result ? file_status.st_size : -1;
 774 }
 775
 776 int FileSystem::change_dir(const char *new_dir, int update)
 777 {
 778         char new_dir_full[BCTEXTLEN];
 779
 780         strcpy(new_dir_full, new_dir);
 781
 782         complete_path(new_dir_full);
 783 // cut ending slash
 784         if(strcmp(new_dir_full, "/") &&
 785                 new_dir_full[strlen(new_dir_full) - 1] == '/')
 786                 new_dir_full[strlen(new_dir_full) - 1] = 0;
 787
 788         if(update)
 789                 this->update(new_dir_full);
 790         else
 791         {
 792                 strcpy(current_dir, new_dir_full);
 793         }
 794         return 0;
 795 }
 796
 797 int FileSystem::set_current_dir(const char *new_dir)
 798 {
 799         strcpy(current_dir, new_dir);
 800         return 0;
 801 }
 802
 803 int FileSystem::add_end_slash(char *new_dir)
 804 {
 805         if(new_dir[strlen(new_dir) - 1] != '/') strcat(new_dir, "/");
 806         return 0;
 807 }
 808
 809
 810 // collapse ".",  "..", "//"  eg. x/./..//y = y
 811 char *FileSystem::basepath(const char *path)
 812 {
 813         char fpath[BCTEXTLEN];
 814         unsigned len = strlen(path);
 815         if( len >= sizeof(fpath) ) return 0;
 816         strcpy(fpath, path);
 817         char *flat = cstrdup("");
 818
 819         int r = 0;
 820         char *fn = fpath + len;
 821         while( fn > fpath ) {
 822                 while( --fn >= fpath )
 823                         if( *fn == '/' ) { *fn = 0;  break; }
 824                 fn = fn < fpath ? fpath : fn+1;
 825                 if( !*fn || !strcmp(fn, ".") ) continue;
 826                 if( !strcmp(fn, "..") ) { ++r; continue; }
 827                 if( r < 0 ) continue;
 828                 if( r > 0 ) { --r;  continue; }
 829                 char *cp = cstrcat(3, "/",fn,flat);
 830                 delete [] flat;  flat = cp;
 831         }
 832
 833         if( *path != '/' ) {
 834                 char *cp = cstrcat(2, ".",flat);
 835                 delete [] flat;  flat = cp;
 836         }
 837
 838         return flat;
 839 }
 840