exerb 6.0.1

data/lib/exerb/file_table.rb

@@ -0,0 +1,189 @@
+
+#==============================================================================#
+# $Id: file_table.rb,v 1.15 2007/02/26 10:20:44 yuya Exp $
+#==============================================================================#
+
+require 'exerb/utility'
+require 'zlib'
+
+#==============================================================================#
+
+module Exerb
+end # Exerb
+
+#==============================================================================#
+
+class Exerb::FileTable
+
+  def initialize
+    @entries  = []
+  end
+
+  def add(id, data, flag, zipd = 0)
+    @entries << Exerb::FileTable::Entry.new(id, data, flag, zipd)
+    return @entries.last
+  end
+
+  def add_from_file(id, path, flag)
+    return File.open(path, 'rb') { |file|
+      if ENV['exy_zipd'] && /\.rbw?$/i =~ path
+        data = Zlib.deflate(file.read, 9)
+        self.add(id, data, flag, 1)
+      else
+        self.add(id, file.read, flag)
+      end
+    }
+  end
+
+  def add_ruby_script(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_RUBY_SCRIPT | flag)
+  end
+
+  def add_ruby_script_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_RUBY_SCRIPT | flag)
+  end
+
+  def add_extension_library(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_EXTENSION_LIBRARY | flag)
+  end
+
+  def add_extension_library_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_EXTENSION_LIBRARY | flag)
+  end
+
+  def add_dynamic_library(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_DYNAMIC_LIBRARY | flag)
+  end
+
+  def add_dynamic_library_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_DYNAMIC_LIBRARY | flag)
+  end
+
+  def add_resource_library(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_RESOURCE_LIBRARY | flag)
+  end
+
+  def add_resource_library_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_RESOURCE_LIBRARY | flag)
+  end
+
+  def add_data_binary(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_DATA_BINARY | flag)
+  end
+
+  def add_data_binary_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_DATA_BINARY | flag)
+  end
+
+  def add_compiled_script(id, data, flag = 0)
+    return self.add(id, data, Entry::FLAG_TYPE_COMPILED_SCRIPT | flag)
+  end
+
+  def add_compiled_script_from_file(id, path, flag = 0)
+    return self.add_from_file(id, path, Entry::FLAG_TYPE_COMPILED_SCRIPT | flag)
+  end
+
+  def pack
+    headers = ''
+    pool    = ''
+
+    @entries.each { |entry|
+      headers << entry.pack_header(pool)
+      pool    << entry.pack_pool
+    }
+
+    packed_headers = Exerb::Utility.alignment16(headers)
+    packed_pool    = Exerb::Utility.alignment16(pool)
+
+    table_header = Exerb::FileTable::Header.new
+    table_header.signature         = Exerb::FileTable::Header::SIGNATURE
+    table_header.number_of_headers = @entries.size
+    table_header.offset_of_headers = Exerb::Utility.alignment16(table_header.pack).size
+    table_header.offset_of_pool    = table_header.offset_of_headers + packed_headers.size
+
+    return Exerb::Utility.alignment16(table_header.pack) + packed_headers + packed_pool
+  end
+
+end # Exerb::FileTabel
+
+#==============================================================================#
+
+class Exerb::FileTable::Header
+
+  SIGNATURE = 0x04005446
+
+  def initialize
+    @signature         = 0
+    @number_of_headers = 0
+    @offset_of_headers = 0
+    @offset_of_pool    = 0
+  end
+
+  attr_accessor :signature, :number_of_headers, :offset_of_headers, :offset_of_pool
+
+  def pack
+    return [@signature, @number_of_headers, @offset_of_headers, @offset_of_pool].pack('LSLL')
+  end
+
+end # Exerb::FileTable::Header
+
+#==============================================================================#
+
+class Exerb::FileTable::Entry
+
+  FLAG_TYPE_RUBY_SCRIPT       = 0x01
+  FLAG_TYPE_EXTENSION_LIBRARY = 0x02
+  FLAG_TYPE_DYNAMIC_LIBRARY   = 0x03
+  FLAG_TYPE_RESOURCE_LIBRARY  = 0x04
+  FLAG_TYPE_DATA_BINARY       = 0x05
+  FLAG_TYPE_COMPILED_SCRIPT   = 0x06
+  FLAG_NO_REPLACE_FUNCTION    = 0x08
+
+  def initialize(id, data, flag, zipd)
+    @id   = id
+    @data = data
+    @flag = flag
+    @zipd = zipd
+  end
+
+  attr_reader :id, :data, :flag
+
+  def pack_header(pool)
+    entry_header = Exerb::FileTable::Entry::Header.new
+    entry_header.id             = @id
+    entry_header.offset_of_file = pool.size
+    entry_header.size_of_file   = @data.size
+    entry_header.flag_of_file   = @flag
+    entry_header.zipd           = @zipd
+
+    return entry_header.pack
+  end
+
+  def pack_pool
+    return Exerb::Utility.alignment16(@data)
+  end
+
+end # Exerb::FileTable::Entry
+
+#==============================================================================#
+
+class Exerb::FileTable::Entry::Header
+
+  def initialize
+    @id             = 0
+    @offset_of_file = 0
+    @size_of_file   = 0
+    @flag_of_file   = 0
+    @zipd           = 0
+  end
+
+  attr_accessor :id, :offset_of_file, :size_of_file, :flag_of_file, :zipd
+
+  def pack
+    return [@id, @offset_of_file, @size_of_file, @flag_of_file, @zipd].pack('SLLCC')
+  end
+
+end # Exerb::FileTable::Entry::Header
+
+#==============================================================================#
+#==============================================================================#

data/lib/exerb/mkexy.rb

@@ -0,0 +1,81 @@
+
+#==============================================================================#
+# $Id: mkexy.rb,v 1.2 2004/03/25 09:35:25 yuya Exp $
+#==============================================================================#
+
+require 'exerb/utility2'
+
+#==============================================================================#
+
+BEGIN {
+  $exerb_pwd = Dir.pwd
+}
+
+END {
+  Dir.chdir($exerb_pwd)
+  if ENV['exy_zipd']
+    require 'zlib'
+    zipd = true
+  else
+    zipd = false
+  end
+
+  reject_list = [File.expand_path(__FILE__)]
+  file_list   = [['script', $0, $0]] + Exerb::Utility2.loaded_features(reject_list)
+  recipe_file = File.expand_path($0).sub(/(\.rbw?$|$)/i, '.exy')
+  core = $0 =~ /\.rbw$/i ? "gui" : "cui"
+
+  old_resource = nil
+  old_path = nil
+  old_recipe_file = ENV['old_exy'] || recipe_file
+  if File.exists?(old_recipe_file)
+    require 'yaml'
+    oldcfg = YAML.load(File.read(old_recipe_file))
+    msg = "# from old exy file"
+    if oldcfg['general'] && oldcfg['general']['core'] && core != oldcfg['general']['core']
+      core = oldcfg['general']['core'] + ' ' + msg
+    end
+    s_r = oldcfg['resource']
+    if s_r && !s_r.empty?
+      old_resource = ["", msg, "resource:"]
+      s_r.to_yaml.split("\n")[1..-1].each do |x|
+        old_resource << '  ' + x.chomp
+      end
+    end
+
+    s_p = oldcfg['path']
+    if s_p && !s_p.empty?
+      old_path = ["", msg,  "path:"]
+      s_p.to_yaml.split("\n")[1..-1].each do |x|
+        old_path << '  ' + x.chomp
+      end
+    end
+  end
+
+  File.open(recipe_file, 'w') { |file|
+    file.puts("# Generated by mkexy")
+    file.puts("# on #{Time.now.strftime('%Y-%m-%d %H:%M')}")
+    file.puts("")
+    file.puts("general:")
+    file.puts("  startup: #{$0}")
+    file.puts("  core: #{core}")
+    file.puts("  zipd: #{zipd}")
+    if RUBY_VERSION < "1.9"
+      file.puts("  kcode: #{$KCODE.downcase}")
+    else
+      file.puts("  kcode: none") #no KCODE in 1.9
+    end
+    file.puts(old_resource) if old_resource
+    file.puts(old_path) if old_path
+    file.puts("")
+    file.puts("file:")
+    file_list.each { |type, filename, filepath|
+      file.puts("  #{filename}:")
+      file.puts("    file: #{filepath}") if filename != filepath
+      file.puts("    type: #{type}") if type != "script"
+    }
+  }
+}
+
+#==============================================================================#
+#==============================================================================#

data/lib/exerb/name_table.rb

@@ -0,0 +1,120 @@
+
+#==============================================================================#
+# $Id: name_table.rb,v 1.4 2005/04/17 15:17:26 yuya Exp $
+#==============================================================================#
+
+require 'exerb/utility'
+
+#==============================================================================#
+
+module Exerb
+end # Exerb
+
+#==============================================================================#
+
+class Exerb::NameTable
+
+  def initialize
+    @entries = []
+  end
+
+  def add(name)
+    @entries.find { |entry|
+      if entry.name == name
+        return entry.id
+      end
+    }
+
+    @entries << Exerb::NameTable::Entry.new(@entries.size + 1, name)
+
+    return @entries.last.id
+  end
+
+  def pack
+    headers = ''
+    pool    = ''
+
+    @entries.each { |entry|
+      headers << entry.pack_header(pool)
+      pool    << entry.pack_pool
+    }
+
+    packed_headers = Exerb::Utility.alignment16(headers)
+    packed_pool    = Exerb::Utility.alignment16(pool)
+
+    table_header = Exerb::NameTable::Header.new
+    table_header.signature         = Exerb::NameTable::Header::SIGNATURE
+    table_header.number_of_headers = @entries.size
+    table_header.offset_of_headers = Exerb::Utility.alignment16(table_header.pack).size
+    table_header.offset_of_pool    = table_header.offset_of_headers + packed_headers.size
+
+    return Exerb::Utility.alignment16(table_header.pack) + packed_headers + packed_pool
+  end
+
+end # Exerb::NameTable
+
+#==============================================================================#
+
+class Exerb::NameTable::Header
+
+  SIGNATURE = 0x0100544E
+
+  def initialize
+    @signature         = 0
+    @number_of_headers = 0
+    @offset_of_headers = 0
+    @offset_of_pool    = 0
+  end
+
+  attr_accessor :signature, :number_of_headers, :offset_of_headers, :offset_of_pool
+
+  def pack
+    return [@signature, @number_of_headers, @offset_of_headers, @offset_of_pool].pack('LSLL')
+  end
+
+end # Exerb::NameTable::Header
+
+#==============================================================================#
+
+class Exerb::NameTable::Entry
+
+  def initialize(id, name)
+    @id   = id
+    @name = name
+  end
+
+  attr_reader :id, :name
+
+  def pack_header(pool)
+    entry_header = Exerb::NameTable::Entry::Header.new
+    entry_header.id             = @id
+    entry_header.offset_of_name = pool.size
+
+    return entry_header.pack
+  end
+
+  def pack_pool
+    return @name + "\0"
+  end
+
+end # Exerb::NameTable::Entry
+
+#==============================================================================#
+
+class Exerb::NameTable::Entry::Header
+
+  def initialize
+    @id             = 0
+    @offset_of_name = 0
+  end
+
+  attr_accessor :id, :offset_of_name
+
+  def pack
+    return [@id, @offset_of_name].pack('SL')
+  end
+
+end # Exerb::NameTable::Entry::Header
+
+#==============================================================================#
+#==============================================================================#

data/lib/exerb/recipe.rb

@@ -0,0 +1,465 @@
+#! /usr/bin/ruby
+
+#==============================================================================#
+# $Id: recipe.rb,v 1.24 2007/02/26 10:59:31 yuya Exp $
+#==============================================================================#
+
+require 'yaml'
+require 'exerb/error'
+require 'exerb/utility'
+require 'exerb/archive'
+
+#==============================================================================#
+
+module Exerb
+end # Exerb
+
+#==============================================================================#
+
+class Exerb::Recipe
+
+  def initialize(blocks, basedir = Dir.pwd, filename = '-')
+    @basedir  = basedir
+    @filename = filename
+    @general  = Exerb::Recipe::GeneralBlock.analyze(blocks, @filename)
+    @path     = Exerb::Recipe::PathBlock.analyze(blocks, @filename)
+    @resource = Exerb::Recipe::ResourceBlock.analyze(blocks, @filename)
+    @file     = Exerb::Recipe::FileBlock.analyze(blocks, @filename)
+    raise(Exerb::ExerbError, "#{@filename}: found unknown field in the recipe -- #{blocks.keys.join(', ')}") unless blocks.empty?
+  end
+
+  def self.load(filepath)
+    basedir  = File.dirname(File.expand_path(filepath))
+    filename = File.basename(filepath)
+
+    begin
+      blocks = YAML.load(File.read(filepath))
+    rescue Errno::ENOENT => e
+      raise(Exerb::ExerbError, "no such file -- #{filepath}")
+    rescue ArgumentError => e
+      msg = e.message.gsub(/\n/, '\n')
+      msg.gsub!(/\r/, '\r')
+      msg.gsub!(/\t/, '\t')
+      raise(Exerb::ExerbError, format('%s: %s', @filename, msg))
+    end
+
+    return self.new(blocks, basedir, filename)
+  end
+
+  def archive_filepath(filename = nil)
+    return self.output_filepath(filename).sub(/(\.exe)?$/i, '.exa')
+  end
+
+  def output_filepath(filename = nil)
+    filename ||= @general.output
+    filename ||= @filename.sub(/(\.exy)?$/i, '.exe')
+
+    return File.expand_path(filename, @basedir)
+  end
+
+  def core_filepath(filepath = nil)
+    unless @general.core.nil?
+      core   = Exerb::Utility.find_core_by_filepath(File.expand_path(@general.core, @basedir))
+      core ||= Exerb::Utility.find_core_by_filename(@general.core)
+      core ||= Exerb::Utility.find_core_by_name(@general.core)
+      raise(Exerb::ExerbError, "#{@filename}: specified core isn't found -- #{@general.core}") if core.nil?
+    end
+
+    filepath ||= core
+    filepath ||= Exerb::Utility.find_core_by_name('cui', true)
+
+    return filepath
+  end
+
+  def create_archive(kcode = nil)
+    archive = Exerb::Archive.new(kcode || @general.kcode)
+
+    search_path  = [@basedir]
+    search_path += @path.path.collect { |dir| File.expand_path(dir, @basedir) } if @path
+    search_path += $:
+
+    startup_entry = @file.delete(@general.startup)
+    raise(Exerb::ExerbError, "#{@filename}: specified startup script isn't found in the file block -- #{@general.startup}") if startup_entry.nil?
+    add_file_entry(archive, search_path, @general.startup, startup_entry)
+
+    @file.keys.sort.each { |internal_name|
+      add_file_entry(archive, search_path, internal_name, @file[internal_name])
+    }
+
+    return archive
+  end
+
+  def update_resource(rsrc)
+    if @resource
+      if @resource.icon
+        rsrc.remove(Exerb::Win32::Const::RT_ICON)
+        rsrc.remove(Exerb::Win32::Const::RT_GROUP_ICON)
+
+        group_icon = Exerb::Resource::GroupIcon.new
+
+        @resource.icon.entries.each_with_index { |entry, index|
+          id   = index + 1
+          icon = Exerb::Resource::Icon.read(entry.file, entry.width, entry.height, entry.color)
+          rsrc.add(Exerb::Win32::Const::RT_ICON, id, icon)
+          group_icon.add(id, icon)
+        }
+
+        rsrc.add(Exerb::Win32::Const::RT_GROUP_ICON, 1, group_icon)
+      end
+
+      if @resource.version
+        fv = (0..3).collect { |i| @resource.version.file_version_number[i]    || 0 }
+        pv = (0..3).collect { |i| @resource.version.product_version_number[i] || 0 }
+
+        ver = Exerb::Resource::VersionInfo.new
+        ver.file_version_number    = Exerb::Resource::VersionInfo.make_version(*fv)
+        ver.product_version_number = Exerb::Resource::VersionInfo.make_version(*pv)
+        ver.comments               = @resource.version.comments
+        ver.company_name           = @resource.version.company_name
+        ver.legal_copyright        = @resource.version.legal_copyright
+        ver.legal_trademarks       = @resource.version.legal_trademarks
+        ver.file_version           = @resource.version.file_version
+        ver.product_version        = @resource.version.product_version
+        ver.product_name           = @resource.version.product_name
+        ver.file_description       = @resource.version.file_description
+        ver.internal_name          = @resource.version.internal_name
+        ver.original_filename      = @resource.version.original_filename
+        ver.private_build          = @resource.version.private_build
+        ver.special_build          = @resource.version.special_build
+
+        rsrc.remove(Exerb::Win32::Const::RT_VERSION)
+        rsrc.add(Exerb::Win32::Const::RT_VERSION, 1, ver)
+      end
+    end
+  end
+
+  def add_file_entry(archive, search_path, internal_name, entry)
+    if entry.file
+      filepath = File.expand_path(entry.file, @basedir)
+      raise("#{@filename}: no such file -- #{entry.file}") unless File.exist?(filepath)
+    else
+      filepath = search_path.collect { |dir|
+        File.join(dir, internal_name)
+      }.find { |path|
+        File.exist?(path)
+      }
+      raise("#{@filename}: no such file -- #{internal_name}") unless filepath
+    end
+
+    flag = ([entry.type] + entry.flag).inject(0) { |a, b| a | b }
+
+    if entry.type == Exerb::FileTable::Entry::FLAG_TYPE_COMPILED_SCRIPT
+      src  = File.binread(filepath)
+      iseq = RubyVM::InstructionSequence.compile(src, internal_name)
+      bin  = Marshal.dump(iseq.to_a)
+      archive.add(internal_name, bin, flag)
+    else
+      archive.add_from_file(internal_name, filepath, flag)
+    end
+  end
+  protected :add_file_entry
+
+end # Exerb::Recipe
+
+#==============================================================================#
+
+class Exerb::Recipe::GeneralBlock
+
+  KCODE = ['none', 'euc', 'sjis', 'utf8']
+
+  def initialize(block, filename)
+    @startup = block.delete('startup') || ""
+    @output  = block.delete('output')  || ""
+    @core    = block.delete('core')    || ""
+    @kcode   = block.delete('kcode')   || "none"
+    @zipd    = block.delete('zipd')    || nil
+
+    @startup = nil if @startup.empty?
+    @output  = nil if @output.empty?
+    @core    = nil if @core.empty?
+    @kcode.downcase!
+    if @zipd
+      ENV['exy_zipd'] = 'true'
+    else
+      ENV['exy_zipd'] = nil
+    end
+
+    raise(Exerb::ExerbError, "#{filename}: unknown field at general block -- #{block.keys.join(', ')}") unless block.empty?
+    raise(Exerb::ExerbError, "#{filename}: startup field isn't specified at general block") if @startup.nil?
+    raise(Exerb::ExerbError, "#{filename}: unknown kcode at general block -- #{@kcode}") unless KCODE.include?(@kcode)
+  end
+
+  attr_reader :startup, :output, :core, :kcode
+
+  def self.analyze(blocks, filename)
+    block = blocks.delete("general")
+    raise(Exerb::ExerbError, "#{filename}: general block not found") if block.nil?
+    raise(Exerb::ExerbError, "#{filename}: general block must be Hash object -- #{block.class}") unless block.kind_of?(Hash)
+    return self.new(block, filename)
+  end
+
+end # Exerb::Recipe::GeneralBlock
+
+#==============================================================================#
+
+class Exerb::Recipe::PathBlock
+
+  def initialize(block, filename)
+    @path = block.collect { |entry|
+      raise(Exerb::ExerbError, "#{filename}: path block entries must be String object -- #{entry.type}") unless entry.kind_of?(String)
+      entry.strip
+    }
+  end
+
+  attr_reader :path
+
+  def self.analyze(blocks, filename)
+    block = blocks.delete("path")
+    return nil if block.nil?
+    raise(Exerb::ExerbError, "#{filename}: path block must be Array object -- #{block.class}") unless block.kind_of?(Array)
+    return self.new(block, filename)
+  end
+
+end # Exerb::Recipe::PathBlock
+
+#==============================================================================#
+
+class Exerb::Recipe::ResourceBlock
+
+  def initialize(block, filename)
+    @icon    = IconBlock.analyze(block, filename)
+    @version = VersionBlock.analyze(block, filename)
+    raise(Exerb::ExerbError, "#{filename}: unknown field at resource block -- #{block.keys.join(', ')}") unless block.empty?
+  end
+
+  attr_reader :icon, :version
+
+  def self.analyze(blocks, filename)
+    block = blocks.delete("resource")
+    return nil if block.nil?
+    raise(Exerb::ExerbError, "#{filename}: resource block must be Hash object -- #{block.type}") unless block.kind_of?(Hash)
+    return self.new(block, filename)
+  end
+
+  class IconBlock
+
+    def initialize(block, filename)
+      @entries = block.collect { |hash| Entry.analyze(hash, filename) }
+    end
+
+    attr_reader :entries
+
+    def self.analyze(blocks, filename)
+      block = blocks.delete("icon")
+      return nil if block.nil?
+      raise(Exerb::ExerbError, "#{filename}: icon block must be Array object -- #{block.type}") unless block.kind_of?(Array)
+      return self.new(block, filename)
+    end
+
+    class Entry
+
+      def initialize(block, filename)
+        @width  = block.delete("width")
+        @height = block.delete("height")
+        @color  = block.delete("color")
+        @file   = block.delete("file")
+
+        raise(Exerb::ExerbError, "#{filename}: unknown field at icon block entry -- #{block.keys.join(', ')}") unless block.empty?
+      end
+
+      attr_reader :width, :height, :color, :file
+
+      def self.analyze(block, filename)
+        raise(Exerb::ExerbError, "#{filename}: icon block entry must be Hash object -- #{block.type}") unless block.kind_of?(Hash)
+        return self.new(block, filename)
+      end
+
+    end # Entry
+  end # IconBlock
+
+  class VersionBlock
+
+    def initialize(block, filename)
+      @file_version_number    = self.parse_version((block.delete('file_version_number')    || "0.0.0.0"), filename)
+      @product_version_number = self.parse_version((block.delete('product_version_number') || "0.0.0.0"), filename)
+      @comments               = block.delete('comments')          || ""
+      @company_name           = block.delete('company_name')      || ""
+      @legal_copyright        = block.delete('legal_copyright')   || ""
+      @legal_trademarks       = block.delete('legal_trademarks')  || ""
+      @file_version           = block.delete('file_version')      || ""
+      @product_version        = block.delete('product_version')   || ""
+      @product_name           = block.delete('product_name')      || ""
+      @file_description       = block.delete('file_description')  || ""
+      @internal_name          = block.delete('internal_name')     || ""
+      @original_filename      = block.delete('original_filename') || ""
+      @private_build          = block.delete('private_build')     || ""
+      @special_build          = block.delete('special_build')     || ""
+
+      raise(Exerb::ExerbError, "#{filename}: unknown field in version block -- #{block.keys.join(', ')}") unless block.empty?
+    end
+
+    attr_reader :file_version_number, :product_version_number,
+      :comments, :company_name, :legal_copyright, :legal_trademarks, :file_version,
+      :product_version, :product_name, :file_description, :internal_name, :original_filename,
+      :private_build, :special_build
+
+    def self.analyze(blocks, filename)
+      block = blocks.delete("version")
+      return nil if block.nil?
+      raise(Exerb::ExerbError, "#{filename}: version block must be Hash object -- #{block.class}") unless block.kind_of?(Hash)
+      return self.new(block, filename)
+    end
+
+    def parse_version(version, filename)
+      case version.delete(" ").tr(",", ".")
+      when /^(\d+)\.(\d+)\.(\d+)\.(\d+)$/ then return [$1.to_i, $2.to_i, $3.to_i, $4.to_i]
+      when /^(\d+)\.(\d+)\.(\d+)$/        then return [$1.to_i, $2.to_i, $3.to_i, 0]
+      when /^(\d+)\.(\d+)$/               then return [$1.to_i, $2.to_i, 0,       0]
+      when /^(\d+)$/                      then return [$1.to_i, 0,       0,       0]
+      when ""                             then return [0,       0,       0,       0]
+      else raise(Exerb::ExerbError, "#{filename}: invalid version format in version block -- #{version}")
+      end
+    end
+
+  end # VersionBlock
+
+end # Exerb::Recipe::ResourceBlock
+
+#==============================================================================#
+
+class Exerb::Recipe::FileBlock
+
+  include Enumerable
+
+  def initialize(block, filename)
+    @file = {}
+
+    block.each { |internal_name, options|
+      @file[internal_name] = FileEntry.new(internal_name, options, filename)
+    }
+  end
+
+  def self.analyze(blocks, filename)
+    block = blocks.delete("file")
+    raise(Exerb::ExerbError, "#{filename}: file block not found") if block.nil?
+    raise(Exerb::ExerbError, "#{filename}: file block must be Hash object -- #{block.class}") unless block.kind_of?(Hash)
+    return self.new(block, filename)
+  end
+
+  def [](key)
+    return @file[key]
+  end
+
+  def each(&block)
+    return @file.each(&block)
+  end
+
+  def keys
+    return @file.keys
+  end
+
+  def delete(key)
+    return @file.delete(key)
+  end
+
+end # Exerb::Recipe::FileBlock
+
+#==============================================================================#
+
+class Exerb::Recipe::FileBlock::FileEntry
+
+  def initialize(internal_name, options, filename)
+    @file = nil
+    @type = Exerb::FileTable::Entry::FLAG_TYPE_RUBY_SCRIPT
+    @flag = []
+    self.analyze_options(internal_name, options || {}, filename)
+  end
+
+  attr_reader :file, :type, :flag
+
+  def analyze_options(internal_name, options, filename)
+    raise(Exerb::ExerbError, "#{filename}: file entry must be Hash object -- #{options.class}") unless options.kind_of?(Hash)
+    @file = self.analyze_option_file(options, filename)
+    @type = self.analyze_option_type(internal_name, options, filename)
+    @flag = self.analyze_option_flag(options, filename, @type)
+  end
+  protected :analyze_options
+
+  def analyze_option_file(options, filename)
+    return options['file']
+  end
+  protected :analyze_option_file
+
+  def analyze_option_type(internal_name, options, filename)
+    default_type = 
+      case internal_name
+      when /\.rb/i  then Exerb::FileTable::Entry::FLAG_TYPE_RUBY_SCRIPT
+      when /\.so/i  then Exerb::FileTable::Entry::FLAG_TYPE_EXTENSION_LIBRARY
+      when /\.dll/i then Exerb::FileTable::Entry::FLAG_TYPE_DYNAMIC_LIBRARY
+      when /\.res/i then Exerb::FileTable::Entry::FLAG_TYPE_RESOURCE_LIBRARY
+      when /\.dat/i then Exerb::FileTable::Entry::FLAG_TYPE_DATA_BINARY
+      else               Exerb::FileTable::Entry::FLAG_TYPE_RUBY_SCRIPT
+      end
+
+    type = options['type'].to_s.downcase
+
+    case type
+    when ''                  then return default_type
+    when 'script'            then return Exerb::FileTable::Entry::FLAG_TYPE_RUBY_SCRIPT
+    when 'extension-library' then return Exerb::FileTable::Entry::FLAG_TYPE_EXTENSION_LIBRARY
+    when 'dynamic-library'   then return Exerb::FileTable::Entry::FLAG_TYPE_DYNAMIC_LIBRARY
+    when 'resource-library'  then return Exerb::FileTable::Entry::FLAG_TYPE_RESOURCE_LIBRARY
+    when 'data'              then return Exerb::FileTable::Entry::FLAG_TYPE_DATA_BINARY
+    when 'compiled-script'   then return Exerb::FileTable::Entry::FLAG_TYPE_COMPILED_SCRIPT
+    else raise(Exerb::ExerbError, "#{filename}: [#{type}] is unknown type at file entry")
+    end
+  end
+  protected :analyze_option_type
+
+  def analyze_option_flag(options, filename, type)
+    case options['flag']
+    when nil    then flag = []
+    when String then flag = [options['flag']]
+    when Array  then flag = options['flag']
+    else raise(Exerb::ExerbError, "#{filename}: flag field of file entry must be String or Array object")
+    end
+
+    known_flags = 
+      case type
+      when Exerb::FileTable::Entry::FLAG_TYPE_RUBY_SCRIPT       then {} # {'compile_by_bruby' => ...}
+      when Exerb::FileTable::Entry::FLAG_TYPE_EXTENSION_LIBRARY then {'no_replace_function' => Exerb::FileTable::Entry::FLAG_NO_REPLACE_FUNCTION}
+      when Exerb::FileTable::Entry::FLAG_TYPE_DYNAMIC_LIBRARY   then {}
+      when Exerb::FileTable::Entry::FLAG_TYPE_RESOURCE_LIBRARY  then {}
+      when Exerb::FileTable::Entry::FLAG_TYPE_DATA_BINARY       then {}
+      when Exerb::FileTable::Entry::FLAG_TYPE_COMPILED_SCRIPT   then {}
+      end
+
+    selected_flags = known_flags.keys.select { |name|
+      flag.delete(name)
+    }.collect { |name|
+      known_flags[name]
+    }
+
+    unless flag.empty?
+      raise(Exerb::ExerbError, "#{filename}: found unknown flag in file entry -- #{flag.join(', ')}")
+    end
+
+    return selected_flags
+  end
+  protected :analyze_option_flag
+
+end # Exerb::Recipe::FileBlock::FileEntry
+
+#==============================================================================#
+
+if $0 == __FILE__
+  recipe = Exerb::Recipe.load(ARGV.shift)
+  p(recipe)
+  p(recipe.archive_filepath)
+  p(recipe.output_filepath)
+  p(recipe.core_filepath)
+  recipe.create_archive.write_to_file('tmp.exa')
+end
+
+#==============================================================================#
+#==============================================================================#