gap50 0.1.0

data/lib/gap50/gap/dll.rb

@@ -0,0 +1,40 @@
+module Gap
+    class DLLFunction
+        def initialize(path, name)
+            @path = path
+            @name = name
+        end
+
+        def call(*args)
+            param = args.map do |x|
+                case x
+                when Integer
+                    "L"
+                else
+                    "p"
+                end
+            end
+            begin
+                Win32API.new(@path, @name, param, "L").call(*args)
+            rescue LoadError
+                Win32API.new(File.expand_path(@path), @name, param, "L").call(*args)
+            end
+        end
+    end
+
+    class DLL
+        def initialize(filename, sam = Gap::Main, &block)
+            @sam      = sam
+            @filename = filename
+            @realpath = @sam.genfile(@filename, &block).tr("/", "\\")
+        end
+
+        def [](name)
+            DLLFunction.new @realpath, name
+        end
+
+        def method_missing(sym, *args)
+            self[sym.to_s].call(*args)
+        end
+    end
+end

data/lib/gap50/gap/exec.rb

@@ -0,0 +1,39 @@
+module Gap
+    class Exec
+        def initialize(sam = Gap::Main)
+            @sam = sam
+        end
+
+        def exec(cmdline, input)
+            md5 = MD5.hexdigest(cmdline) + MD5.hexdigest(input)
+            inputfile  = _file md5, ".input"
+            outputfile = _file md5, ".output"
+            outf = md5 + ".output"
+            key = [Samsara::Meta.new(:Exec), outf]
+            @sam.gen key do
+                @sam.writefile inputfile, input
+                system "#{cmdline} < #{inputfile} > #{outputfile}"
+                @sam.readfile outputfile
+            end
+        end
+
+        def marshal(cmdline, input)
+            Marshal.load exec(cmdline, input)
+        end
+
+        DEFAULT_EXEC = Exec.new
+        def self.exec(*a)
+            DEFAULT_EXEC.exec(*a)
+        end
+
+        def self.marshal(*a)
+            DEFAULT_EXEC.marshal(*a)
+        end
+
+        private
+        def _file(name, ext = "")
+            "temp/exec_" << name << ext
+        end
+
+    end
+end

data/lib/gap50/gap/gap.rb

@@ -0,0 +1,3 @@
+module Gap
+    Main = Samsara.new "main.sam"
+end

data/lib/gap50/gap/require.rb

@@ -0,0 +1,96 @@
+module Gap
+    class Require
+        def initialize(sam = Gap::Main, strict = true)
+            @strict = strict
+            @sam = sam
+        end
+
+        def require(*args)
+            if @strict
+                args.each{|x|
+                    _require_strict x
+                }
+            else
+                args.each{|x|
+                    _require x
+                }
+            end
+        ensure
+            $@.replace caller if $@
+        end
+
+        ORIGIN = Kernel.method(:require)
+        INSTANCE_ORIGIN = Kernel.instance_method(:require)
+        DEFAULT_REQUIRE = Require.new
+        REQUIRE_STACK = [[INSTANCE_ORIGIN, Kernel]]
+
+        
+        def replace_kernel!
+            that = self
+            REQUIRE_STACK.push [self.class.instance_method(:require), self]
+            _fix_kernel
+        ensure
+            $@.replace caller if $@
+        end
+
+        def back_require!
+            REQUIRE_STACK.pop
+            _fix_kernel
+        ensure
+            $@.replace caller if $@
+        end
+
+        def use_kernel!
+            Kernel.send :define_method, INSTANCE_ORIGIN
+        ensure
+            $@.replace caller if $@
+        end
+
+        private
+        def _require(a)
+            ORIGIN.call a
+        rescue
+            if ex.to_s =~ /^LoadError: .*? -- (.*)$/
+                file = $1
+                path = "./" + @sam.genfile(file)
+                ORIGIN.call path
+            else
+                raise ArgumentError, "Can't load #{a}"
+            end
+        end
+
+        def _require_strict(file)
+            [file, file + ".rb"].each{|x|
+                begin
+                    if @sam.has_file_in?(x)
+                        path = "./" + @sam.genfile(x)
+                        return ORIGIN.call path
+                    end
+                rescue LoadError
+                ensure
+                    $@.replace caller if $@
+                end
+            }
+            ORIGIN.call file
+        ensure
+            $@.replace caller if $@
+        end
+
+        def _fix_kernel
+            if REQUIRE_STACK[-1]
+                m, o = REQUIRE_STACK[-1]
+                if o == Kernel
+                    use_kernel!
+                else
+                    Kernel.send :define_method, :require do |*args|
+                        m.bind(o).call(*args)
+                    end
+                end
+            else
+                use_kernel!
+            end
+        ensure
+            $@.replace caller if $@
+        end        
+    end
+end

data/lib/gap50/gap50.rb

@@ -0,0 +1,9 @@
+require "gap50/version"
+require 'gap50/preload'
+require 'gap50/cache'
+require 'gap50/samsara'
+require 'gap50/gap'
+require 'gap50/ext'
+module Gap50
+  # Your code goes here...
+end

data/lib/gap50/preload.rb

@@ -0,0 +1,12 @@
+begin
+    Win32API
+rescue NameError
+    require 'win32api'
+end
+
+begin
+    Zlib
+rescue NameError
+    require 'zlib'
+end
+

data/lib/gap50/samsara.rb

@@ -0,0 +1,4 @@
+require 'gap50/samsara/md5.rb'
+require 'gap50/samsara/random.rb'
+require 'gap50/samsara/maker.rb'
+require 'gap50/samsara/samsara.rb'

data/lib/gap50/samsara/maker.rb

@@ -0,0 +1,113 @@
+module Gap
+    class Maker
+        RND = Random.new
+        attr_accessor :temp, :sam
+
+
+        def initialize(sam = nil, temp = genname, &block)
+            @sam = sam
+            @temp = temp
+            if defined? instance_exec
+                transaction do |m|
+                    instance_exec &block
+                end
+            else
+                transaction do |m|
+                    instance_eval &block
+                end
+            end
+        end
+
+        def path(name)
+            @temp + "/" + name
+        end
+
+        def readfile(name)
+            @sam.readfile path(name)
+        end
+
+        def writefile(name, value)
+            @sam.writefile path(name), value
+        end
+
+        def copyfile(src, dest)
+            writefile dest, @sam.readfile(src)
+        end
+
+        def exec(cmd)
+            system "cd #{@temp} && #{cmd}"            
+        end
+
+        def transaction
+            _create
+            ret = yield self
+            _import_all
+            _cleanup
+            ret
+        end
+
+        def asBase64
+            _import_all
+            @sam.toBase64
+        end
+
+        def asMarshal
+            _import_all
+            @sam.toMarshal
+        end
+
+        def genlib(name, text)
+            writefile "cpp/#{name}.cpp", %{#define GAPI(type) extern "C" type __stdcall
+#{text}
+}
+            exec "g++ cpp/#{name}.cpp -o cpp/#{name}.dll -static -s -shared -m32 -Wl,-add-stdcall-alias"
+        end
+
+        def from(name)
+            @sam = Samsara.new name
+            _export_all
+        end
+
+        alias COPY  copyfile
+        alias WRITE writefile
+        alias READ  readfile
+        alias RUN   exec
+        alias FROM  from
+        alias CXX   genlib
+        private
+        def _export_all
+            @sam.each{|k, v|
+                if k[0] == Samsara::MetaFile
+                    @sam.export k[1], @temp
+                end
+            }
+        end
+
+        def _import_all
+            len = @temp.length + 1
+            Dir.glob(@temp + "/**/*") do |f|
+                next if FileTest.directory?(f)
+                name = f[len..-1]
+                @sam.import name, @temp
+            end
+        end
+
+        def _cleanup
+            @sam.rmdir_p(@temp)
+        end
+
+        def _create
+            if !FileTest.directory?(temp)
+                Dir.mkdir temp
+            end
+        end
+
+        def genname
+            while 0
+                name = "temp-#{RND.hex(16)}"
+                return name if !FileTest.exists?(name)
+            end
+        end
+        
+    end
+end

data/lib/gap50/samsara/md5.rb

@@ -0,0 +1,44 @@
+module Gap
+    MD5_INIT   = Win32API.new("ADVAPI32", "MD5Init", "p", "L")
+    MD5_UPDATE = Win32API.new("ADVAPI32", "MD5Update", "ppL", "L")
+    MD5_FINAL  = Win32API.new("ADVAPI32", "MD5Final", "p", "L")
+    class MD5
+        def initialize
+            @ctx = "\0" * 128 # buf
+            MD5_INIT.call(@ctx)
+        end
+
+        def update(str)
+            MD5_UPDATE.call(@ctx, str, str.unpack("C*").size)
+        end
+
+        def digest
+            MD5_FINAL.call(@ctx)
+            @ctx[88, 16]
+        end
+
+        def self.digest(a)
+            x = MD5.new
+            x.update a
+            x.digest
+        end
+
+        def self.hexdigest(a)
+            digest(a).unpack("H*").first
+        end
+
+        def self.file(fn)
+            open(fn, 'rb') do |f|
+                x = MD5.new
+                while (r = f.read(10240))
+                    x.update(r)
+                end
+                x.digest
+            end
+        end
+
+        def self.filehex(fn)
+            file(fn).unpack("H*").first
+        end
+    end
+end

data/lib/gap50/samsara/random.rb

@@ -0,0 +1,53 @@
+module Gap
+    CR_ACQUIRE   = Win32API.new("ADVAPI32", "CryptAcquireContext", "pLLLL", "L")
+    CR_GENRANDOM = Win32API.new("ADVAPI32", "CryptGenRandom", "LLp", "L")
+    CR_RELEASE   = Win32API.new("ADVAPI32", "CryptReleaseContext", "LL", "L")
+    class Random
+        REG = {}
+        def self.auto_release_proc
+            proc{|id|
+                if REG.include? id
+                    _dispose REG[id]
+                    REG.delete id
+                end
+            }
+        end
+        
+        def self.register_auto_release(id, ptr)
+            REG[object_id] = ptr
+            ObjectSpace.define_finalizer self, auto_release_proc
+        end
+
+        def initialize
+            buf = "\0" * 4
+            CR_ACQUIRE.call buf, 0, 0, 1, -268435456
+            @ptr, = buf.unpack("L")
+            self.class.register_auto_release object_id, @ptr
+        end
+
+        def bytes(len = 16)
+            buf = "\0" * len
+            CR_GENRANDOM.call @ptr, len, buf
+            buf
+        end
+
+        def hex(len = 16)
+            bytes(len).unpack("H*").first
+        end
+
+        def next_int
+            bytes(4).unpack("L").first
+        end
+
+        def self._dispose(ptr)
+            if ptr
+                CR_RELEASE.call ptr, 0
+            end
+        end
+
+        def dispose
+           self.class._dispose @ptr
+           @ptr = nil
+        end
+    end
+end

data/lib/gap50/samsara/samsara.rb

@@ -0,0 +1,195 @@
+module Gap
+    class Samsara
+        Meta = Struct.new :meta
+        MetaFile = Meta.new :file
+        MetaMD5  = Meta.new :filemd5
+        attr_accessor :filepath
+        def initialize(name, filepath = "samfile")
+            @cache = Gap::Cache.new name
+            @filepath = filepath
+        end
+
+        def fromBase64(b64)
+            @cache.fromBase64 b64
+        end
+
+        def toBase64
+            @cache.toBase64
+        end
+
+        def fromMarshal(text)
+            @cache.fromMarshal text
+        end
+
+        def toMarshal
+            @cache.toMarshal
+        end
+
+        def each(&block)
+            @cache.each(&block)
+        end
+
+        def export(file, dir)
+            _export file, dir
+        end
+
+        def import(file, dir)
+            _import file, dir
+        end
+        #
+        #   gen : [Any] -> ([Any] -> Any) -> Any
+        #
+        def gen(*path)
+            if @cache.has?(path)
+                @cache[path]
+            else
+                @cache.transaction do |db|
+                    db[path] = yield path
+                    db[path]
+                end
+            end
+        end
+
+        #
+        #   genfile : filename -> [Any] -> (filename -> [Any] -> Any) -> Any
+        #
+        def genfile(filename, args = nil, &block)
+            realpath = file(filename)
+            md5key =  [MetaMD5, filename]
+            filekey = [MetaFile, filename]
+            if @cache.has?(md5key) && 
+               @cache.has?(filekey) &&
+               FileTest.file?(realpath) && 
+               MD5.filehex(realpath) == @cache[md5key]
+            elsif @cache.has?(filekey)
+                _writefile realpath, @cache[filekey]
+            else
+                u = yield filekey
+                @cache.transaction do |db|
+                    db[md5key]  = MD5.hexdigest u
+                    db[filekey] = u
+                    _writefile realpath, @cache[filekey]
+                end
+            end
+            realpath
+        end
+
+        def has_file_in?(filename) 
+            md5key =  [MetaMD5, filename]
+            filekey = [MetaFile, filename]
+            @cache.has?(md5key) && 
+            @cache.has?(filekey) && 
+            @cache[md5key] != nil &&
+            MD5.hexdigest(@cache[filekey]) == @cache[md5key]
+        end
+
+        def need_update_file?(filename, realfile)
+            if has_file_in?(filename)
+                md5key =  [MetaMD5, filename]
+                MD5.filehex(realfile) != @cache[md5key]
+            else
+                true
+            end
+        end
+
+        def file(name)
+            _file(name)
+        end
+
+        def writefile(a, b)
+            _writefile a, b
+        end
+
+        def readfile(a)
+            _readfile a
+        end
+
+        def mangle(name)
+            _mangle(name)
+        end
+
+        def rmdir_p(name)
+            _rmdir_p(name)
+        end
+
+        
+    private
+        def _file(name)
+            File.join(@filepath, _mangle(name))
+        end
+
+        def _mangle(name)
+            name.gsub("://", "$SEP$/").gsub(/[:"']/){ "$#{$&.unpack("H")}$" }
+        end
+
+        def _demangle(name)
+            name.gsub("$SEP$/", "://").gsub(/\$([a-f0-9]+)\$/) { [$1].pack("H") }
+        end
+
+        def _mkdirp(name)
+            names = name.tr("\\", "/").split("/")[0..-2]
+            names.inject(""){|a, b|
+                if a == ""
+                    path = b
+                else
+                    path = a + "/" + b
+                end
+                if !FileTest.directory?(path)
+                    Dir.mkdir(path)
+                end
+                path
+            }
+        end
+
+        def _readfile(name)
+            open(name, 'rb') do |f|
+                f.read
+            end
+        end
+        def _writefile(name, val)
+            _mkdirp(name)
+            open(name, "wb") do |f|
+                f.write val
+            end
+        end
+
+        def _export(file, dir)
+            if has_file_in?(file)
+                name = _mangle(dir + "/" + file)
+                filekey = [MetaFile, file]
+                _writefile(name, @cache[filekey])
+            else
+                raise "File not found #{file}"
+            end
+        end
+
+        def _import(file, dir)
+            name = _mangle(dir + "/" + file)
+            @cache.transaction do |db|
+                filekey = [MetaFile, file]
+                md5key =  [MetaMD5, file]
+                db.remove filekey
+                db.remove md5key
+                content = _readfile name
+                db[md5key] = MD5.hexdigest(content)
+                db[filekey] = content
+            end
+        end
+
+        def _rmdir_p(name)
+            raise if name == nil || name[0] == "/"
+            files = [name]
+            Dir.glob(name + "/**/*") do |f|
+                files << f
+            end
+            files.sort!{|a, b| b.length <=> a.length}
+            files.each{|x|
+                if FileTest.file?(x)
+                    File.delete x
+                else
+                    Dir.delete x
+                end
+            }
+        end
+    end
+end