/* ** filesystem-binding.cpp ** ** This file is part of mkxp. ** ** Copyright (C) 2013 Jonas Kulla ** ** mkxp is free software: you can redistribute it and/or modify ** it under the terms of the GNU General Public License as published by ** the Free Software Foundation, either version 2 of the License, or ** (at your option) any later version. ** ** mkxp is distributed in the hope that it will be useful, ** but WITHOUT ANY WARRANTY; without even the implied warranty of ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ** GNU General Public License for more details. ** ** You should have received a copy of the GNU General Public License ** along with mkxp. If not, see . */ #include "binding-util.h" #include "sharedstate.h" #include "filesystem.h" #include "ruby/encoding.h" #include "ruby/intern.h" #include DEF_TYPE(FileInt); static VALUE fileIntForPath(const char *path) { SDL_RWops *ops = SDL_AllocRW(); shState->fileSystem().openRead(*ops, path); VALUE klass = rb_const_get(rb_cObject, rb_intern("FileInt")); VALUE obj = rb_obj_alloc(klass); setPrivateData(obj, ops, FileIntType); return obj; } RB_METHOD(fileIntRead) { int length = -1; rb_get_args(argc, argv, "i", &length, RB_ARG_END); SDL_RWops *ops = getPrivateData(self); if (length == -1) { Sint64 cur = SDL_RWtell(ops); Sint64 end = SDL_RWseek(ops, 0, SEEK_END); length = end - cur; SDL_RWseek(ops, cur, SEEK_SET); } if (length == 0) return Qnil; VALUE data = rb_str_new(0, length); SDL_RWread(ops, RSTRING_PTR(data), 1, length); return data; } RB_METHOD(fileIntClose) { RB_UNUSED_PARAM; SDL_RWops *ops = getPrivateData(self); SDL_RWclose(ops); return Qnil; } RB_METHOD(fileIntGetByte) { RB_UNUSED_PARAM; SDL_RWops *ops = getPrivateData(self); unsigned char byte; size_t result = SDL_RWread(ops, &byte, 1, 1); return (result == 1) ? rb_fix_new(byte) : Qnil; } RB_METHOD(fileIntBinmode) { RB_UNUSED_PARAM; return Qnil; } static void fileIntFreeInstance(void *inst) { SDL_RWops *ops = static_cast(inst); SDL_RWclose(ops); SDL_FreeRW(ops); } VALUE kernelLoadDataInt(const char *filename) { rb_gc_start(); VALUE port = fileIntForPath(filename); VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal")); // FIXME need to catch exceptions here with begin rescue VALUE result = rb_funcall(marsh, rb_intern("load"), 1, port); rb_funcall(port, rb_intern("close"), 0); return result; } RB_METHOD(kernelLoadData) { RB_UNUSED_PARAM; const char *filename; rb_get_args(argc, argv, "z", &filename, RB_ARG_END); return kernelLoadDataInt(filename); } RB_METHOD(kernelSaveData) { RB_UNUSED_PARAM; VALUE obj; VALUE filename; rb_get_args(argc, argv, "oS", &obj, &filename, RB_ARG_END); VALUE file = rb_funcall(rb_cFile, rb_intern("open"), 2, filename, rb_str_new_cstr("w")); VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal")); rb_funcall(marsh, rb_intern("dump"), 2, obj, file); rb_funcall(file, rb_intern("close"), 0); return Qnil; } static VALUE stringForceUTF8(VALUE arg) { if (rb_type(arg) == RUBY_T_STRING && ENCODING_IS_ASCII8BIT(arg)) rb_enc_associate_index(arg, rb_utf8_encindex()); return arg; } static VALUE customProc(VALUE arg, VALUE proc) { VALUE obj = stringForceUTF8(arg); obj = rb_funcall2(proc, rb_intern("call"), 1, &obj); return obj; } RB_METHOD(_marshalLoad) { RB_UNUSED_PARAM; VALUE port, proc = Qnil; rb_get_args(argc, argv, "o|o", &port, &proc, RB_ARG_END); VALUE utf8Proc; if (NIL_P(proc)) utf8Proc = rb_proc_new(RUBY_METHOD_FUNC(stringForceUTF8), Qnil); else utf8Proc = rb_proc_new(RUBY_METHOD_FUNC(customProc), proc); VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal")); return rb_funcall(marsh, rb_intern("_mkxp_load_alias"), 2, port, utf8Proc); } void fileIntBindingInit() { initType(FileIntType, "FileInt", fileIntFreeInstance); VALUE klass = rb_define_class("FileInt", rb_cIO); _rb_define_method(klass, "read", fileIntRead); _rb_define_method(klass, "getbyte", fileIntGetByte); _rb_define_method(klass, "binmode", fileIntBinmode); _rb_define_method(klass, "close", fileIntClose); _rb_define_module_function(rb_mKernel, "load_data", kernelLoadData); _rb_define_module_function(rb_mKernel, "save_data", kernelSaveData); /* We overload the built-in 'Marshal::load()' function to silently * insert our utf8proc that ensures all read strings will be * UTF-8 encoded */ VALUE marsh = rb_const_get(rb_cObject, rb_intern("Marshal")); rb_define_alias(rb_singleton_class(marsh), "_mkxp_load_alias", "load"); _rb_define_module_function(marsh, "load", _marshalLoad); }