Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Browse files

Moved some building script from GNU make to Ruby script

Added minirake what's Rake subset
  • Loading branch information...
commit 06d242ae430ad37fd88fe6490980121ee26a1283 1 parent f2d3c4d
Yuichiro MASUI masuidrive authored
2  .gitignore
View
@@ -19,10 +19,12 @@ cscope.out
/bin
/mrblib/mrblib.c
/mrblib/*.*tmp
+/mrblib/mrblib.mrb
/test/mrbtest
/test/mrbtest.c
/test/*.*tmp
/test/mrubytest.*
+tools/mrbc/mrbc.mrb
CMakeFiles
CMakeCache.txt
/mrbgems/generator
2  .travis.yml
View
@@ -1,3 +1,3 @@
# no installation...
-script: "make all test"
+script: "./minirake all test"
107 Makefile
View
@@ -1,107 +0,0 @@
-# Makefile description.
-# basic build file for mruby
-
-# compiler, linker (gcc), archiver, parser generator
-export CC = gcc
-export LL = gcc
-export AR = ar
-export YACC = bison
-
-MRUBY_ROOT := $(realpath .)
-
-ifeq ($(strip $(ENABLE_GEMS)),)
- # by default GEMs are deactivated
- ENABLE_GEMS = false
-endif
-
-ifeq ($(strip $(ACTIVE_GEMS)),)
- # the default file which contains the active GEMs
- ACTIVE_GEMS = GEMS.active
-endif
-
-ifeq ($(strip $(COMPILE_MODE)),)
- # default compile option
- COMPILE_MODE = debug
-endif
-
-ifeq ($(COMPILE_MODE),debug)
- CFLAGS = -g -O3
-else ifeq ($(COMPILE_MODE),release)
- CFLAGS = -O3
-else ifeq ($(COMPILE_MODE),small)
- CFLAGS = -Os
-endif
-
-ALL_CFLAGS = -Wall -Werror-implicit-function-declaration $(CFLAGS)
-ifeq ($(OS),Windows_NT)
- MAKE_FLAGS = --no-print-directory CC=$(CC) LL=$(LL) ALL_CFLAGS='$(ALL_CFLAGS)' LDFLAGS='$(LDFLAGS)' ENABLE_GEMS='$(ENABLE_GEMS)' ACTIVE_GEMS='$(ACTIVE_GEMS)' MRUBY_ROOT='$(MRUBY_ROOT)'
-else
- MAKE_FLAGS = --no-print-directory CC='$(CC)' LL='$(LL)' ALL_CFLAGS='$(ALL_CFLAGS)' LDFLAGS='$(LDFLAGS)' ENABLE_GEMS='$(ENABLE_GEMS)' ACTIVE_GEMS='$(ACTIVE_GEMS)' MRUBY_ROOT='$(MRUBY_ROOT)'
-endif
-
-##############################
-# internal variables
-
-export MSG_BEGIN = @for line in
-export MSG_END = ; do echo "$$line"; done
-
-export CP := cp
-export RM_F := rm -f
-export CAT := cat
-
-##############################
-# generic build targets, rules
-
-.PHONY : all
-all :
- @$(MAKE) -C src $(MAKE_FLAGS)
- @$(MAKE) -C mrblib $(MAKE_FLAGS)
-ifeq ($(ENABLE_GEMS),true)
- @echo "-- MAKE mrbgems --"
- @$(MAKE) -C mrbgems $(MAKE_FLAGS)
-endif
- $(MAKE) -C tools/mruby $(MAKE_FLAGS)
- @$(MAKE) -C tools/mirb $(MAKE_FLAGS)
-
-# mruby test
-.PHONY : test
-test : all
- @$(MAKE) -C test $(MAKE_FLAGS)
-
-# clean up
-.PHONY : clean
-clean :
- @$(MAKE) clean -C src $(MAKE_FLAGS)
-ifeq ($(ENABLE_GEMS),true)
- @echo "-- CLEAN mrbgems --"
- @$(MAKE) clean -C mrbgems $(MAKE_FLAGS)
-endif
- @$(MAKE) clean -C tools/mruby $(MAKE_FLAGS)
- @$(MAKE) clean -C tools/mirb $(MAKE_FLAGS)
- @$(MAKE) clean -C test $(MAKE_FLAGS)
-
-# display help for build configuration and interesting targets
-.PHONY : showconfig
-showconfig :
- $(MSG_BEGIN) \
- "" \
- " CC = $(CC)" \
- " LL = $(LL)" \
- " MAKE = $(MAKE)" \
- "" \
- " CFLAGS = $(CFLAGS)" \
- " ALL_CFLAGS = $(ALL_CFLAGS)" \
- $(MSG_END)
-
-.PHONY : help
-help :
- $(MSG_BEGIN) \
- "" \
- " Basic mruby Makefile" \
- "" \
- "targets:" \
- " all (default): build all targets, install (locally) in-repo" \
- " clean: clean all built and in-repo installed artifacts" \
- " showconfig: show build config summary" \
- " test: run all mruby tests" \
- $(MSG_END)
101 Rakefile
View
@@ -0,0 +1,101 @@
+# Build description.
+# basic build file for mruby
+
+# compiler, linker (gcc), archiver, parser generator
+CC = ENV['CC'] || 'gcc'
+LL = ENV['LL'] || 'gcc'
+AR = ENV['AR'] || 'ar'
+YACC = ENV['YACC'] || 'bison'
+MAKE = ENV['MAKE'] || 'make'
+
+# mruby source root path
+MRUBY_ROOT = ENV['MRUBY_ROOT'] || File.expand_path(File.dirname(__FILE__))
+
+# by default GEMs are deactivated
+ENABLE_GEMS = false
+
+# the default file which contains the active GEMs
+ACTIVE_GEMS = File.join(File.dirname(__FILE__), 'mrbgems', 'GEMS.active')
+
+# default compile option
+COMPILE_MODE = :debug
+
+
+##############################
+# compile flags
+
+case COMPILE_MODE.to_s
+when 'debug'
+ CFLAGS = ['-g', '-O3']
+when 'release'
+ CFLAGS = ['-O3']
+when 'small'
+ CFLAGS = ['-Os']
+else
+ CFLAGS = [ENV['CFLAGS']]
+end
+LDFLAGS = [ENV['LDFLAGS']]
+
+CFLAGS << "-Wall" << "-Werror-implicit-function-declaration" << "-I#{MRUBY_ROOT}/include"
+if ENV['OS'] == 'Windows_NT'
+ MAKE_FLAGS = "--no-print-directory CC=#{CC} LL=#{LL} CFLAGS='#{CFLAGS.join(' ')}' LDFLAGS='#{LDFLAGS.join(' ')}' ENABLE_GEMS='#{ENABLE_GEMS}' MRUBY_ROOT='#{MRUBY_ROOT}'"
+else
+ MAKE_FLAGS = "--no-print-directory CC='#{CC}' LL='#{LL}' CFLAGS='#{CFLAGS.join(' ')}' LDFLAGS='#{LDFLAGS.join(' ')}' ENABLE_GEMS='#{ENABLE_GEMS}' MRUBY_ROOT='#{MRUBY_ROOT}'"
+end
+
+
+
+##############################
+# internal variables
+
+CP = ENV['CP'] ||= 'cp'
+RM_F = ENV['RM_F'] ||= 'rm -f'
+CAT = ENV['CAT'] ||= 'cat'
+
+
+##############################
+# generic build targets, rules
+if ENABLE_GEMS
+ require './mrbgems/build_tasks'
+end
+
+task :default => :all
+
+desc "build all targets, install (locally) in-repo"
+task :all do
+ sh "#{MAKE} -C src #{MAKE_FLAGS}"
+ sh "#{MAKE} -C mrblib #{MAKE_FLAGS}"
+ if ENABLE_GEMS
+ puts "-- MAKE mrbgems --"
+ Rake::Task['mrbgems_all'].invoke
+ end
+ sh "#{MAKE} -C tools/mruby #{MAKE_FLAGS}"
+ sh "#{MAKE} -C tools/mirb #{MAKE_FLAGS}"
+end
+
+desc "sh all mruby tests"
+task :test => [:all] do
+ sh "#{MAKE} -C test #{MAKE_FLAGS}"
+end
+
+desc "clean all built and in-repo installed artifacts"
+task :clean do
+ sh "#{MAKE} clean -C src #{MAKE_FLAGS}"
+ sh "#{MAKE} clean -C mrblib #{MAKE_FLAGS}"
+ if ENABLE_GEMS
+ puts "-- MAKE mrbgems --"
+ Rake::Task['mrbgems_clean'].invoke
+ end
+ sh "#{MAKE} clean -C tools/mruby #{MAKE_FLAGS}"
+ sh "#{MAKE} clean -C tools/mirb #{MAKE_FLAGS}"
+end
+
+desc "show build config summary"
+task :showconfig do
+ puts " CC = #{CC}"
+ puts " LL = #{LL}"
+ puts " MAKE = #{MAKE}"
+ puts ""
+ puts " CFLAGS = #{CFLAGS.join(' ')}"
+ puts " LDFLAGS = #{LDFLAGS.join(' ')}"
+end
3  doc/mrbgems/c_and_ruby_extension_example/.gitignore
View
@@ -0,0 +1,3 @@
+gem_mixlib.c
+*.ctmp
+*.rbtmp
3  doc/mrbgems/c_extension_example/.gitignore
View
@@ -0,0 +1,3 @@
+gem_srclib.c
+*.ctmp
+*.rbtmp
3  doc/mrbgems/ruby_extension_example/.gitignore
View
@@ -0,0 +1,3 @@
+gem_mrblib.c
+*.ctmp
+*.rbtmp
409 minirake
View
@@ -0,0 +1,409 @@
+#!/usr/bin/env ruby
+
+# Original is https://github.com/jimweirich/rake/
+# Copyright (c) 2003 Jim Weirich
+# License: MIT-LICENSE
+
+require 'getoptlong'
+
+module MiniRake
+ class Task
+ TASKS = Hash.new
+ RULES = Array.new
+
+ # List of prerequisites for a task.
+ attr_reader :prerequisites
+
+ # Source dependency for rule synthesized tasks. Nil if task was not
+ # sythesized from a rule.
+ attr_accessor :source
+
+ # Create a task named +task_name+ with no actions or prerequisites..
+ # use +enhance+ to add actions and prerequisites.
+ def initialize(task_name)
+ @name = task_name
+ @prerequisites = []
+ @actions = []
+ end
+
+ # Enhance a task with prerequisites or actions. Returns self.
+ def enhance(deps=nil, &block)
+ @prerequisites |= deps if deps
+ @actions << block if block_given?
+ self
+ end
+
+ # Name of the task.
+ def name
+ @name.to_s
+ end
+
+ # Invoke the task if it is needed. Prerequites are invoked first.
+ def invoke
+ puts "Invoke #{name} (already=[#{@already_invoked}], needed=[#{needed?}])" if $trace
+ return if @already_invoked
+ @already_invoked = true
+ @prerequisites.each { |n| Task[n].invoke }
+ execute if needed?
+ end
+
+ # Execute the actions associated with this task.
+ def execute
+ puts "Execute #{name}" if $trace
+ self.class.enhance_with_matching_rule(name) if @actions.empty?
+ unless $dryrun
+ @actions.each { |act| result = act.call(self) }
+ end
+ end
+
+ # Is this task needed?
+ def needed?
+ true
+ end
+
+ # Timestamp for this task. Basic tasks return the current time for
+ # their time stamp. Other tasks can be more sophisticated.
+ def timestamp
+ @prerequisites.collect { |p| Task[p].timestamp }.max || Time.now
+ end
+
+ # Class Methods ----------------------------------------------------
+
+ class << self
+
+ # Clear the task list. This cause rake to immediately forget all
+ # the tasks that have been assigned. (Normally used in the unit
+ # tests.)
+ def clear
+ TASKS.clear
+ RULES.clear
+ end
+
+ # List of all defined tasks.
+ def tasks
+ TASKS.keys.sort.collect { |tn| Task[tn] }
+ end
+
+ # Return a task with the given name. If the task is not currently
+ # known, try to synthesize one from the defined rules. If no
+ # rules are found, but an existing file matches the task name,
+ # assume it is a file task with no dependencies or actions.
+ def [](task_name)
+ task_name = task_name.to_s
+ if task = TASKS[task_name]
+ return task
+ end
+ if task = enhance_with_matching_rule(task_name)
+ return task
+ end
+ if File.exist?(task_name)
+ return FileTask.define_task(task_name)
+ end
+ fail "Don't know how to rake #{task_name}"
+ end
+
+ # Define a task given +args+ and an option block. If a rule with
+ # the given name already exists, the prerequisites and actions are
+ # added to the existing task.
+ def define_task(args, &block)
+ task_name, deps = resolve_args(args)
+ deps = [deps] if (Symbol === deps) || (String === deps)
+ deps = deps.collect {|d| d.to_s }
+ lookup(task_name).enhance(deps, &block)
+ end
+
+ # Define a rule for synthesizing tasks.
+ def create_rule(args, &block)
+ pattern, deps = resolve_args(args)
+ fail "Too many dependents specified in rule #{pattern}: #{deps.inspect}" if deps.size > 1
+ pattern = Regexp.new(Regexp.quote(pattern) + '$') if String === pattern
+ RULES << [pattern, deps, block]
+ end
+
+
+ # Lookup a task. Return an existing task if found, otherwise
+ # create a task of the current type.
+ def lookup(task_name)
+ name = task_name.to_s
+ TASKS[name] ||= self.new(name)
+ end
+
+ # If a rule can be found that matches the task name, enhance the
+ # task with the prerequisites and actions from the rule. Set the
+ # source attribute of the task appropriately for the rule. Return
+ # the enhanced task or nil of no rule was found.
+ def enhance_with_matching_rule(task_name)
+ RULES.each do |pattern, extensions, block|
+ if md = pattern.match(task_name)
+ ext = extensions.first
+ case ext
+ when String
+ source = task_name.sub(/\.[^.]*$/, ext)
+ when Proc
+ source = ext.call(task_name)
+ else
+ fail "Don't know how to handle rule dependent: #{ext.inspect}"
+ end
+ if File.exist?(source)
+ task = FileTask.define_task({task_name => [source]}, &block)
+ task.source = source
+ return task
+ end
+ end
+ end
+ nil
+ end
+
+ private
+
+ # Resolve the arguments for a task/rule.
+ def resolve_args(args)
+ case args
+ when Hash
+ fail "Too Many Task Names: #{args.keys.join(' ')}" if args.size > 1
+ fail "No Task Name Given" if args.size < 1
+ task_name = args.keys[0]
+ deps = args[task_name]
+ deps = [deps] if (String===deps) || (Regexp===deps) || (Proc===deps)
+ else
+ task_name = args
+ deps = []
+ end
+ [task_name, deps]
+ end
+ end
+ end
+
+
+ ######################################################################
+ class FileTask < Task
+ # Is this file task needed? Yes if it doesn't exist, or if its time
+ # stamp is out of date.
+ def needed?
+ return true unless File.exist?(name)
+ latest_prereq = @prerequisites.collect{|n| Task[n].timestamp}.max
+ return false if latest_prereq.nil?
+ timestamp < latest_prereq
+ end
+
+ # Time stamp for file task.
+ def timestamp
+ File.new(name.to_s).mtime
+ end
+ end
+end
+
+Rake = MiniRake
+
+
+######################################################################
+# Task Definition Functions ...
+
+# Declare a basic task.
+def task(args, &block)
+ MiniRake::Task.define_task(args, &block)
+end
+
+# Declare a file task.
+def file(args, &block)
+ MiniRake::FileTask.define_task(args, &block)
+end
+
+# Declare a set of files tasks to create the given directories on
+# demand.
+def directory(dir)
+ path = []
+ Sys.split_all(dir).each do |p|
+ path << p
+ FileTask.define_task(File.join(path)) do |t|
+ Sys.makedirs(t.name)
+ end
+ end
+end
+
+# Declare a rule for auto-tasks.
+def rule(args, &block)
+ MiniRake::Task.create_rule(args, &block)
+end
+
+# Write a message to standard out if $verbose is enabled.
+def log(msg)
+ print " " if $trace && $verbose
+ puts msg if $verbose
+end
+
+# Run the system command +cmd+.
+def sh(cmd)
+ log cmd
+ system(cmd) or fail "Command Failed: [#{cmd}]"
+end
+
+def desc(text)
+end
+
+######################################################################
+# Rake main application object. When invoking +rake+ from the command
+# line, a RakeApp object is created and run.
+#
+class RakeApp
+ RAKEFILES = ['rakefile', 'Rakefile']
+
+ OPTIONS = [
+ ['--dry-run', '-n', GetoptLong::NO_ARGUMENT,
+ "Do a dry run without executing actions."],
+ ['--help', '-H', GetoptLong::NO_ARGUMENT,
+ "Display this help message."],
+ ['--libdir', '-I', GetoptLong::REQUIRED_ARGUMENT,
+ "Include LIBDIR in the search path for required modules."],
+ ['--nosearch', '-N', GetoptLong::NO_ARGUMENT,
+ "Do not search parent directories for the Rakefile."],
+ ['--quiet', '-q', GetoptLong::NO_ARGUMENT,
+ "Do not log messages to standard output."],
+ ['--rakefile', '-f', GetoptLong::REQUIRED_ARGUMENT,
+ "Use FILE as the rakefile."],
+ ['--require', '-r', GetoptLong::REQUIRED_ARGUMENT,
+ "Require MODULE before executing rakefile."],
+ ['--tasks', '-T', GetoptLong::NO_ARGUMENT,
+ "Display the tasks and dependencies, then exit."],
+ ['--trace', '-t', GetoptLong::NO_ARGUMENT,
+ "Turn on invoke/execute tracing."],
+ ['--usage', '-h', GetoptLong::NO_ARGUMENT,
+ "Display usage."],
+ ['--verbose', '-v', GetoptLong::NO_ARGUMENT,
+ "Log message to standard output (default)."],
+ ]
+
+ # Create a RakeApp object.
+ def initialize
+ @rakefile = nil
+ @nosearch = false
+ end
+
+ # True if one of the files in RAKEFILES is in the current directory.
+ # If a match is found, it is copied into @rakefile.
+ def have_rakefile
+ RAKEFILES.each do |fn|
+ if File.exist?(fn)
+ @rakefile = fn
+ return true
+ end
+ end
+ return false
+ end
+
+ # Display the program usage line.
+ def usage
+ puts "rake [-f rakefile] {options} targets..."
+ end
+
+ # Display the rake command line help.
+ def help
+ usage
+ puts
+ puts "Options are ..."
+ puts
+ OPTIONS.sort.each do |long, short, mode, desc|
+ if mode == GetoptLong::REQUIRED_ARGUMENT
+ if desc =~ /\b([A-Z]{2,})\b/
+ long = long + "=#{$1}"
+ end
+ end
+ printf " %-20s (%s)\n", long, short
+ printf " %s\n", desc
+ end
+ end
+
+ # Display the tasks and dependencies.
+ def display_tasks
+ Task.tasks.each do |t|
+ puts "#{t.class} #{t.name}"
+ t.prerequisites.each { |pre| puts " #{pre}" }
+ end
+ end
+
+ # Return a list of the command line options supported by the
+ # program.
+ def command_line_options
+ OPTIONS.collect { |lst| lst[0..-2] }
+ end
+
+ # Do the option defined by +opt+ and +value+.
+ def do_option(opt, value)
+ case opt
+ when '--dry-run'
+ $dryrun = true
+ $trace = true
+ when '--help'
+ help
+ exit
+ when '--libdir'
+ $:.push(value)
+ when '--nosearch'
+ @nosearch = true
+ when '--quiet'
+ $verbose = false
+ when '--rakefile'
+ RAKEFILES.clear
+ RAKEFILES << value
+ when '--require'
+ require value
+ when '--tasks'
+ $show_tasks = true
+ when '--trace'
+ $trace = true
+ when '--usage'
+ usage
+ exit
+ when '--verbose'
+ $verbose = true
+ when '--version'
+ puts "rake, version #{RAKEVERSION}"
+ exit
+ else
+ fail "Unknown option: #{opt}"
+ end
+ end
+
+ # Read and handle the command line options.
+ def handle_options
+ $verbose = true
+ opts = GetoptLong.new(*command_line_options)
+ opts.each { |opt, value| do_option(opt, value) }
+ end
+
+ # Run the +rake+ application.
+ def run
+ handle_options
+ begin
+ here = Dir.pwd
+ while ! have_rakefile
+ Dir.chdir("..")
+ if Dir.pwd == here || @nosearch
+ fail "No Rakefile found (looking for: #{RAKEFILES.join(', ')})"
+ end
+ here = Dir.pwd
+ end
+ puts "(in #{Dir.pwd})"
+ $rakefile = @rakefile
+ load @rakefile
+ if $show_tasks
+ display_tasks
+ else
+ ARGV.push("default") if ARGV.size == 0
+ ARGV.each { |task_name| MiniRake::Task[task_name].invoke }
+ end
+ rescue Exception => ex
+ puts "rake aborted!"
+ puts ex.message
+ if $trace
+ puts ex.backtrace.join("\n")
+ else
+ puts ex.backtrace.find {|str| str =~ /#{@rakefile}/ } || ""
+ end
+ end
+ end
+end
+
+if __FILE__ == $0 then
+ RakeApp.new.run
+end
76 mrbgems/Makefile
View
@@ -1,76 +0,0 @@
-# makefile description.
-# add gems to the ruby library
-
-ifeq ($(strip $(MRUBY_ROOT)),)
- MRUBY_ROOT := $(realpath ..)
-endif
-
-LIBR := ../lib/libmruby.a
-RM_F := rm -f
-CC_FLAGS := -Wall -Werror-implicit-function-declaration -g -O3 -MMD -I. -I./../include
-
-export CC = gcc
-export LL = gcc
-export AR = ar
-
-GENERATOR := $(MRUBY_ROOT)/mrbgems/generator
-ifeq ($(OS),Windows_NT)
- GENERATOR_BIN := $(GENERATOR).exe
-else
- GENERATOR_BIN := $(GENERATOR)
-endif
-GEM_INIT := gem_init
-GEM_MAKEFILE := g/Makefile
-GEM_MAKEFILE_LIST := g/MakefileGemList
-GEMDLIB := g/mrbgemtest.ctmp
-
-ifeq ($(strip $(ACTIVE_GEMS)),)
- # the default file which contains the active GEMs
- ACTIVE_GEMS = GEMS.active
-endif
-
-##############################
-# generic build targets, rules
-
-.PHONY : all
-all : all_gems $(GEM_INIT).a
-
-$(GEM_INIT).a : $(GEM_INIT).o
- $(AR) rs gem_init.a $(GEM_INIT).o
-
-all_gems : $(GENERATOR_BIN)
- @echo "Generate Gem List Makefile"
- $(GENERATOR_BIN) makefile_list $(ACTIVE_GEMS) > $(GEM_MAKEFILE_LIST)
- @echo "Generate Gem Makefile"
- $(GENERATOR_BIN) makefile $(ACTIVE_GEMS) "$(MRUBY_ROOT)" > $(GEM_MAKEFILE)
- @echo "Build all gems"
- $(MAKE) -C g MRUBY_ROOT='$(MRUBY_ROOT)' ACTIVE_GEMS="$(ACTIVE_GEMS)"
-
-$(GEM_INIT).c : $(GENERATOR_BIN)
- @echo "Generate Gem driver"
- $(GENERATOR_BIN) $(GEM_INIT) $(ACTIVE_GEMS) > $@
-
-$(GEM_INIT).o : $(GEM_INIT).c
- @echo "Build the driver which initializes all gems"
- $(CC) $(CC_FLAGS) -MMD -c $< -o $@
-
-# Generator
-
-$(GENERATOR_BIN) : $(GENERATOR).o
- @echo "Build the generator which creates the driver and Gem Makefile"
- $(LL) -o $@ $(CC_FLAGS) $<
-
-$(GENERATOR).o : $(GENERATOR).c
- $(CC) $(CC_FLAGS) -MMD -c $< -o $@
-
-.PHONY : prepare-test
-prepare-test :
- @$(MAKE) prepare-test -C g ACTIVE_GEMS="$(ACTIVE_GEMS)" MRUBY_ROOT='$(MRUBY_ROOT)'
-
-# clean driver and all gems
-.PHONY : clean
-clean : $(GENERATOR_BIN)
- @echo "Cleanup Gems"
- $(GENERATOR_BIN) makefile $(ACTIVE_GEMS) "$(MRUBY_ROOT)" > $(GEM_MAKEFILE)
- $(MAKE) clean -C g ACTIVE_GEMS="$(ACTIVE_GEMS)" MRUBY_ROOT='$(MRUBY_ROOT)'
- -$(RM_F) $(GEM_INIT).c *.o *.d $(GENERATOR_BIN) $(GEM_MAKEFILE) $(GEM_MAKEFILE_LIST) gem_init.a
78 mrbgems/build_tasks.rb
View
@@ -0,0 +1,78 @@
+MRBGEMS_PATH = File.dirname(__FILE__)
+
+GEM_INIT = "#{MRBGEMS_PATH}/gem_init"
+GEM_MAKEFILE = "#{MRBGEMS_PATH}/g/Makefile"
+GEM_MAKEFILE_LIST = "#{MRBGEMS_PATH}/g/MakefileGemList"
+MAKEFILE_4_GEM = "#{MRUBY_ROOT}/mrbgems/Makefile4gem"
+
+GEM_MAKE_FLAGS = "#{MAKE_FLAGS} MAKEFILE_4_GEM='#{MAKEFILE_4_GEM}'"
+
+task :mrbgems_all => ["#{GEM_INIT}.a"] do
+ for_each_gem do |f|
+ sh "#{MAKE} -C #{f} #{GEM_MAKE_FLAGS}"
+ end
+end
+
+task :mrbgems_clean do
+ sh "cd #{MRUBY_ROOT}/mrbgems/g && #{RM_F} *.c *.d *.rbtmp *.ctmp *.o mrbtest"
+ for_each_gem do |f|
+ sh "#{MAKE} clean -C #{f} #{GEM_MAKE_FLAGS}"
+ end
+end
+
+task :mrbgems_prepare_test do
+ sh "#{CAT} #{for_each_gem{|f| "#{f}/test/*.rb "}} > #{MRUBY_ROOT}/mrbgems/g/mrbgemtest.rbtmp"
+ sh "#{MRUBY_ROOT}/bin/mrbc -Bmrbgemtest_irep -o#{MRUBY_ROOT}/mrbgems/g/mrbgemtest.ctmp #{MRUBY_ROOT}/mrbgems/g/mrbgemtest.rbtmp"
+end
+
+file "#{GEM_INIT}.a" => ["#{GEM_INIT}.c", "#{GEM_INIT}.o"] do |t|
+ sh "#{AR} rs #{t.name} #{t.prerequisites.join(' ')}"
+end
+
+rule ".o" => [".c"] do |t|
+ puts "Build the driver which initializes all gems"
+ sh "#{CC} #{CFLAGS.join(' ')} -I #{MRUBY_ROOT}/include -MMD -c #{t.source} -o #{t.name}"
+end
+
+file "#{GEM_INIT}.c" do |t|
+ puts "Generate Gem driver: #{t.name}"
+ open(t.name, 'w') do |f|
+ f.puts <<__EOF__
+/*
+ * This file contains a list of all
+ * initializing methods which are
+ * necessary to bootstrap all gems.
+ *
+ * IMPORTANT:
+ * This file was generated!
+ * All manual changes will get lost.
+ */
+
+#include "mruby.h"
+
+#{for_each_gem{|f| "void GENERATED_TMP_mrb_%s_gem_init(mrb_state*);\n" % [File.basename(f)]}}
+
+void
+mrb_init_mrbgems(mrb_state *mrb) {
+#{for_each_gem{|f| " GENERATED_TMP_mrb_%s_gem_init(mrb);\n" % [File.basename(f)]}}
+}
+__EOF__
+ end
+end
+
+def for_each_gem(&block)
+ IO.readlines(ACTIVE_GEMS).map { |line|
+ block.call(line.chomp)
+ }.join('')
+end
+
+task :mrbgems_generate_gem_makefile_list do
+ open(GEM_MAKEFILE_LIST, 'w') do |f|
+ f.puts <<__EOF__
+GEM_LIST := #{for_each_gem{|f| "#{f}/mrb-#{File.basename(f)}-gem.a"}}
+
+GEM_ARCHIVE_FILES := #{MRUBY_ROOT}/mrbgems/gem_init.a
+GEM_ARCHIVE_FILES += $(GEM_LIST)
+__EOF__
+ end
+end
4 test/Makefile
View
@@ -78,6 +78,8 @@ MRUBY= ../bin/mruby
EXE := $(TARGET)
endif
+RAKE = ../minirake
+
##############################
# generic build targets, rules
@@ -106,7 +108,7 @@ $(OBJS) : %.o : %.c
# Compile C source from merged mruby source
$(CLIB) : $(DLIB) $(INIT)
ifeq ($(ENABLE_GEMS),true)
- @$(MAKE) prepare-test -C $(GEMDIR)
+ @$(RAKE) mrbgems_prepare_test
endif
$(CAT) $(INIT) $(DLIB) $(GEMDLIB) > $@
Please sign in to comment.
Something went wrong with that request. Please try again.