extras/physfs_rb/physfs/rb_physfs.c
changeset 514 f4e89d934fee
child 654 c0ae01de361d
equal deleted inserted replaced
513:bd18a574bda5 514:f4e89d934fee
       
     1 /*
       
     2  * PhysicsFS - ruby interface
       
     3  * 
       
     4  * Author::  Ed Sinjiashvili (slimb@vlinkmail.com)
       
     5  * License:: LGPL
       
     6  */
       
     7 
       
     8 #include "physfs.h"
       
     9 #include "ruby.h"
       
    10 
       
    11 #include "rb_physfs.h" 
       
    12 #include "rb_physfs_file.h"
       
    13 
       
    14 VALUE modulePhysfs;
       
    15 
       
    16 /*
       
    17  * PhysicsFS::init str
       
    18  *
       
    19  * initialize PhysicsFS
       
    20  */
       
    21 VALUE physfs_init (VALUE self, VALUE str)
       
    22 {
       
    23     int result = PHYSFS_init (STR2CSTR(str));
       
    24 
       
    25     if (result)
       
    26 	return Qtrue;
       
    27 
       
    28     return Qfalse;
       
    29 }
       
    30 
       
    31 /*
       
    32  * PhysicsFS::deinit
       
    33  */
       
    34 VALUE physfs_deinit (VALUE self)
       
    35 {
       
    36     if (PHYSFS_deinit ())
       
    37 	return Qtrue;
       
    38 
       
    39     return Qfalse;
       
    40 }
       
    41 
       
    42 /*
       
    43  * PhysicsFS::version
       
    44  * 
       
    45  * return PhysicsFS::Version object
       
    46  */
       
    47 VALUE physfs_version (VALUE self)
       
    48 {
       
    49     char evalStr[200];
       
    50     PHYSFS_Version ver;
       
    51 
       
    52     PHYSFS_getLinkedVersion (&ver);
       
    53 
       
    54     sprintf (evalStr, "PhysicsFS::Version.new %d, %d, %d", 
       
    55 	     ver.major, ver.minor, ver.patch);
       
    56     return rb_eval_string (evalStr);
       
    57 }
       
    58 
       
    59 /*
       
    60  * PhysicsFS::supported_archives
       
    61  *
       
    62  * return Array of PhysicsFS::ArchiveInfo objects
       
    63  */
       
    64 VALUE physfs_supported_archives (VALUE self)
       
    65 {
       
    66     const PHYSFS_ArchiveInfo **info = PHYSFS_supportedArchiveTypes();
       
    67     VALUE klass = rb_const_get (modulePhysfs, rb_intern ("ArchiveInfo"));
       
    68     VALUE ary = rb_ary_new ();
       
    69     VALUE params[4];
       
    70 
       
    71     while ( *info != 0 ) 
       
    72     {
       
    73         params[0] = rb_str_new2 ((*info)->extension);
       
    74         params[1] = rb_str_new2 ((*info)->description);
       
    75         params[2] = rb_str_new2 ((*info)->author);
       
    76         params[3] = rb_str_new2 ((*info)->url);
       
    77 
       
    78         rb_ary_push (ary, rb_class_new_instance (4, params, klass));
       
    79         info++;
       
    80     }
       
    81 
       
    82     return ary;
       
    83 }
       
    84 
       
    85 /*
       
    86  * PhysicsFS::last_error
       
    87  *
       
    88  * return string representation of last PhysicsFS error
       
    89  */
       
    90 VALUE physfs_last_error (VALUE self)
       
    91 {
       
    92     const char *last_error = PHYSFS_getLastError ();
       
    93 
       
    94     if (last_error == 0)
       
    95 	last_error = "";
       
    96 
       
    97     return rb_str_new2 (last_error);
       
    98 }
       
    99 
       
   100 /*
       
   101  * PhysicsFS::dir_separator
       
   102  *
       
   103  * return platform directory separator
       
   104  */
       
   105 VALUE physfs_dir_separator (VALUE self)
       
   106 {
       
   107     return rb_str_new2 (PHYSFS_getDirSeparator ());
       
   108 }
       
   109 
       
   110 /*
       
   111  * PhysicsFS::permit_symlinks boolValue
       
   112  *
       
   113  * turn symlinks support on/off
       
   114  */
       
   115 VALUE physfs_permit_symlinks (VALUE self, VALUE allow)
       
   116 {
       
   117     int p = 1;
       
   118     
       
   119     if (allow == Qfalse || allow == Qnil)
       
   120         p = 0;
       
   121 
       
   122     PHYSFS_permitSymbolicLinks (p);
       
   123     return Qtrue;
       
   124 }
       
   125 
       
   126 /*
       
   127  * PhysicsFS::cdrom_dirs
       
   128  *
       
   129  * return Array of strings containing available CDs 
       
   130  */
       
   131 VALUE physfs_cdrom_dirs (VALUE self)
       
   132 {
       
   133     char **cds = PHYSFS_getCdRomDirs();
       
   134     char **i;
       
   135     VALUE ary = rb_ary_new ();
       
   136 
       
   137     for (i = cds; *i != 0; i++)
       
   138         rb_ary_push (ary, rb_str_new2 (*i));
       
   139 
       
   140     PHYSFS_freeList (cds);
       
   141     return ary;
       
   142 }
       
   143 
       
   144 /*
       
   145  * PhysicsFS::base_dir
       
   146  *
       
   147  * return base directory
       
   148  */
       
   149 VALUE physfs_base_dir (VALUE self)
       
   150 {
       
   151     const char *base_dir = PHYSFS_getBaseDir ();
       
   152     if (base_dir == 0)
       
   153         base_dir = "";
       
   154 
       
   155     return rb_str_new2 (base_dir);
       
   156 }
       
   157 
       
   158 /*
       
   159  * PhysicsFS::user_dir
       
   160  *
       
   161  * return user directory
       
   162  */
       
   163 VALUE physfs_user_dir (VALUE self)
       
   164 {
       
   165     const char *user_dir = PHYSFS_getBaseDir ();
       
   166     if (user_dir == 0)
       
   167         user_dir = "";
       
   168 
       
   169     return rb_str_new2 (user_dir);
       
   170 }
       
   171    
       
   172 /*
       
   173  * PhysicsFS::write_dir 
       
   174  *
       
   175  * return write directory
       
   176  */
       
   177 VALUE physfs_write_dir (VALUE self)
       
   178 {
       
   179     const char *write_dir = PHYSFS_getWriteDir ();
       
   180     if (write_dir == 0)
       
   181         return Qnil;
       
   182 
       
   183     return rb_str_new2 (write_dir);
       
   184 }
       
   185 
       
   186 /*
       
   187  * PhysicsFS::write_dir= str
       
   188  *
       
   189  * set write directory to *str*
       
   190  */
       
   191 VALUE physfs_set_write_dir (VALUE self, VALUE str)
       
   192 {
       
   193     int result = PHYSFS_setWriteDir (STR2CSTR(str));
       
   194 
       
   195     if (result)
       
   196         return Qtrue;
       
   197     return Qfalse;
       
   198 }
       
   199 
       
   200 /*
       
   201  * PhysicsFS::add_to_search_path str, append
       
   202  *
       
   203  * if append > 0 - append str to search path, otherwise prepend it
       
   204  */
       
   205 VALUE physfs_add_search_path (VALUE self, VALUE str, VALUE append)
       
   206 {
       
   207     int result = PHYSFS_addToSearchPath (STR2CSTR(str), FIX2INT(append));
       
   208     if (result)
       
   209         return Qtrue;
       
   210     return Qfalse;
       
   211 }
       
   212 
       
   213 /*
       
   214  * PhysicsFS::remove_from_search_path str
       
   215  *
       
   216  * removes str from search path
       
   217  */
       
   218 VALUE physfs_remove_search_path (VALUE self, VALUE str)
       
   219 {
       
   220     int result = PHYSFS_removeFromSearchPath (STR2CSTR(str));
       
   221     if (result)
       
   222         return Qtrue;
       
   223     return Qfalse;
       
   224 }
       
   225 
       
   226 /*
       
   227  * PhysicsFS::search_path
       
   228  *
       
   229  * return current search_path - as array of strings
       
   230  */
       
   231 VALUE physfs_search_path (VALUE self)
       
   232 {
       
   233     char **path = PHYSFS_getSearchPath ();
       
   234     char **i;
       
   235     VALUE ary = rb_ary_new ();
       
   236 
       
   237     for (i = path ; *i != 0; i++)
       
   238         rb_ary_push (ary, rb_str_new2 (*i));
       
   239 
       
   240     PHYSFS_freeList (path);
       
   241     return ary;
       
   242 }
       
   243 
       
   244 // 
       
   245 VALUE physfs_setSaneConfig(VALUE self, VALUE org, VALUE app, VALUE ext,
       
   246                            VALUE includeCdroms, VALUE archivesFirst)
       
   247 {
       
   248     int res = PHYSFS_setSaneConfig (STR2CSTR(org), STR2CSTR(app), STR2CSTR(ext),
       
   249                                    RTEST(includeCdroms), RTEST(archivesFirst));
       
   250     if (res)
       
   251         return Qtrue;
       
   252 
       
   253     return Qfalse;
       
   254 }
       
   255 
       
   256 /*
       
   257  * PhysicsFS::mkdir newdir
       
   258  *
       
   259  * create new directory 
       
   260  */ 
       
   261 VALUE physfs_mkdir (VALUE self, VALUE newdir)
       
   262 {
       
   263     int result = PHYSFS_mkdir (STR2CSTR(newdir));
       
   264     if (result)
       
   265         return Qtrue;
       
   266     return Qfalse;
       
   267 }
       
   268 
       
   269 /*
       
   270  * PhysicsFS::delete name
       
   271  *
       
   272  * delete file with name
       
   273  */
       
   274 VALUE physfs_delete (VALUE self, VALUE name)
       
   275 {
       
   276     int result = PHYSFS_delete (STR2CSTR(name));
       
   277     if (result)
       
   278         return Qtrue;
       
   279     return Qfalse;
       
   280 }
       
   281 
       
   282 /*
       
   283  * PhysicsFS::real_dir name
       
   284  *
       
   285  * return real directory (in search path) of a name
       
   286  */
       
   287 VALUE physfs_real_dir (VALUE self, VALUE name)
       
   288 {
       
   289     const char *path = PHYSFS_getRealDir (STR2CSTR(name));
       
   290     if (path == 0)
       
   291         return Qnil;
       
   292 
       
   293     return rb_str_new2 (path);
       
   294 }
       
   295 
       
   296 /*
       
   297  * PhysicsFS::enumerate dir
       
   298  *
       
   299  * list a dir from a search path
       
   300  */
       
   301 VALUE physfs_enumerate (VALUE self, VALUE dir)
       
   302 {
       
   303     char **files = PHYSFS_enumerateFiles (STR2CSTR(dir));
       
   304     char **i;
       
   305     VALUE ary = rb_ary_new ();
       
   306 
       
   307     for (i = files; *i != 0; i++)
       
   308         rb_ary_push (ary, rb_str_new2 (*i));
       
   309 
       
   310     PHYSFS_freeList (files);
       
   311     return ary;
       
   312 }
       
   313 
       
   314 /*
       
   315  * PhysicsFS::exists? name
       
   316  *
       
   317  * does a file with name exist?
       
   318  */
       
   319 VALUE physfs_exists (VALUE self, VALUE name)
       
   320 {
       
   321     int result = PHYSFS_exists (STR2CSTR(name));
       
   322     if (result)
       
   323         return Qtrue;
       
   324     return Qfalse;
       
   325 }
       
   326 
       
   327 /*
       
   328  * PhysicsFS::is_directory? name
       
   329  *
       
   330  * return true if name is directory
       
   331  */
       
   332 VALUE physfs_is_directory (VALUE self, VALUE name)
       
   333 {
       
   334     int result = PHYSFS_isDirectory (STR2CSTR(name));
       
   335     if (result)
       
   336         return Qtrue;
       
   337     return Qfalse;
       
   338 }
       
   339 
       
   340 /*
       
   341  * PhysicsFS::is_symlink? name
       
   342  *
       
   343  * return true if name is symlink
       
   344  */
       
   345 VALUE physfs_is_symlink (VALUE self, VALUE name)
       
   346 {
       
   347     int result = PHYSFS_isSymbolicLink (STR2CSTR(name));
       
   348     if (result)
       
   349         return Qtrue;
       
   350     return Qfalse;
       
   351 }
       
   352 
       
   353 /*
       
   354  * PhysicsFS::last_mod_time name
       
   355  *
       
   356  * return last modification time of a file
       
   357  */
       
   358 VALUE physfs_last_mod_time (VALUE self, VALUE name)
       
   359 {
       
   360     int result = PHYSFS_getLastModTime (STR2CSTR(name));
       
   361     
       
   362     return INT2FIX(result);
       
   363 }
       
   364 
       
   365 /*
       
   366  * PhysicsFS::open_read name
       
   367  *
       
   368  * return +PhysicsFS::File+ ready for reading
       
   369  */
       
   370 VALUE physfs_open_read (VALUE self, VALUE name)
       
   371 {
       
   372     PHYSFS_file *file = PHYSFS_openRead (STR2CSTR(name));
       
   373     return physfs_file_new (file);
       
   374 }
       
   375 
       
   376 /*
       
   377  * PhysicsFS::open_write name
       
   378  *
       
   379  * return PhysicsFS::File ready for writing
       
   380  */
       
   381 VALUE physfs_open_write (VALUE self, VALUE name)
       
   382 {
       
   383     PHYSFS_file *file = PHYSFS_openWrite (STR2CSTR(name));
       
   384     return physfs_file_new (file);
       
   385 }
       
   386 
       
   387 /*
       
   388  * PhysicsFS::open_append name
       
   389  *
       
   390  * return PhysicsFS::File ready for appending
       
   391  */
       
   392 VALUE physfs_open_append (VALUE self, VALUE name)
       
   393 {
       
   394     PHYSFS_file *file = PHYSFS_openAppend (STR2CSTR(name));
       
   395     return physfs_file_new (file);
       
   396 }
       
   397 
       
   398 void Init_physfs_so (void)
       
   399 {
       
   400     modulePhysfs = rb_define_module ("PhysicsFS");
       
   401 
       
   402     rb_define_singleton_method (modulePhysfs, "init_internal", physfs_init, 1);
       
   403     rb_define_singleton_method (modulePhysfs, "deinit", physfs_deinit, 0);
       
   404     rb_define_singleton_method (modulePhysfs, "version", physfs_version, 0);
       
   405     rb_define_singleton_method (modulePhysfs, "supported_archives",
       
   406 				physfs_supported_archives, 0);
       
   407     rb_define_singleton_method (modulePhysfs, "last_error", 
       
   408 				physfs_last_error, 0);
       
   409     rb_define_singleton_method (modulePhysfs, "dir_separator",
       
   410 				physfs_dir_separator, 0);
       
   411     rb_define_singleton_method (modulePhysfs, "permit_symlinks",
       
   412                                 physfs_permit_symlinks, 1);
       
   413     rb_define_singleton_method (modulePhysfs, "cdrom_dirs", 
       
   414                                 physfs_cdrom_dirs, 0);
       
   415     rb_define_singleton_method (modulePhysfs, "base_dir", physfs_base_dir, 0);
       
   416     rb_define_singleton_method (modulePhysfs, "user_dir", physfs_user_dir, 0);
       
   417 
       
   418     rb_define_singleton_method (modulePhysfs, "write_dir", physfs_write_dir, 0);
       
   419     rb_define_singleton_method (modulePhysfs, "write_dir=", 
       
   420                                 physfs_set_write_dir, 1);
       
   421 
       
   422     rb_define_singleton_method (modulePhysfs, "add_to_search_path",
       
   423                                 physfs_add_search_path, 2);
       
   424     rb_define_singleton_method (modulePhysfs, "remove_from_search_path",
       
   425                                 physfs_remove_search_path, 1);
       
   426     rb_define_singleton_method (modulePhysfs, "search_path",
       
   427                                 physfs_search_path, 0);
       
   428 
       
   429     rb_define_singleton_method (modulePhysfs, "set_sane_config",
       
   430                                 physfs_setSaneConfig, 5);
       
   431 
       
   432     rb_define_singleton_method (modulePhysfs, "mkdir", physfs_mkdir, 1);
       
   433     rb_define_singleton_method (modulePhysfs, "delete", physfs_delete, 1);
       
   434     rb_define_singleton_method (modulePhysfs, "real_dir",
       
   435                                 physfs_real_dir, 1);
       
   436     rb_define_singleton_method (modulePhysfs, "enumerate", physfs_enumerate, 1);
       
   437     rb_define_singleton_method (modulePhysfs, "exists?", physfs_exists, 1);
       
   438     rb_define_singleton_method (modulePhysfs, "is_directory?", 
       
   439                                 physfs_is_directory, 1);
       
   440     rb_define_singleton_method (modulePhysfs, "is_symlink?", 
       
   441                                 physfs_is_symlink, 1);
       
   442     rb_define_singleton_method (modulePhysfs, "last_mod_time",
       
   443                                 physfs_last_mod_time, 1);
       
   444 
       
   445     rb_define_singleton_method (modulePhysfs, "open_read", 
       
   446                                 physfs_open_read, 1);
       
   447     rb_define_singleton_method (modulePhysfs, "open_write", 
       
   448                                 physfs_open_write, 1);
       
   449     rb_define_singleton_method (modulePhysfs, "open_append", 
       
   450                                 physfs_open_append, 1);
       
   451 
       
   452     init_physfs_file ();
       
   453     init_sdl_rwops ();
       
   454 }
       
   455 
       
   456 /*
       
   457 // Local Variables:
       
   458 // mode: C
       
   459 // c-indentation-style: "stroustrup"
       
   460 // indent-tabs-mode: nil
       
   461 // End:
       
   462 */