aboutsummaryrefslogtreecommitdiff
path: root/externals/gridflow/configure
diff options
context:
space:
mode:
Diffstat (limited to 'externals/gridflow/configure')
-rwxr-xr-xexternals/gridflow/configure1136
1 files changed, 1136 insertions, 0 deletions
diff --git a/externals/gridflow/configure b/externals/gridflow/configure
new file mode 100755
index 00000000..d9b19139
--- /dev/null
+++ b/externals/gridflow/configure
@@ -0,0 +1,1136 @@
+#!/usr/bin/env ruby
+# $Id: configure,v 1.1 2005-10-04 02:12:43 matju Exp $
+=begin
+ GridFlow
+ Copyright (c) 2001,2002,2003,2004 by Mathieu Bouchard
+
+ This program 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.
+
+ See file ./COPYING for further informations on licensing terms.
+
+ This program 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 this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+=end
+
+require "rbconfig"
+require "mkmf"
+require "ftools"
+include Config
+require "win32/process" if CONFIG["arch"] =~ /mingw/
+LOG = File.open "./config.log", "w"
+
+$verbose=false
+LOG.puts "-"*64
+LOG.puts "Environment Variables: "
+ENV.each {|k,v| LOG.puts "#{k}=#{v}" }
+LOG.puts "-"*64
+
+puts
+if not File.exist?("./configure")
+ puts "Run me from the right directory please."
+ exit 1
+end
+
+begin
+ Dir.mkdir "tmp"
+rescue Errno::EEXIST
+end
+
+#----------------------------------------------------------------#
+
+class Or
+ attr_reader :a
+ class<<self; alias [] new end
+ def initialize(*a) @a=a end
+ def to_s; @a.join " or "; end
+end
+
+def launch2(log,*command)
+ log << command.join(" ") << "\n"
+ r,w = IO.pipe
+ child = launch(nil,w,w,*command)
+ w.close
+ log << r.readlines.join << "\n"
+ ret = join_pid(child)
+ ret = ret.to_int if RUBY_VERSION > "1.7"
+ log << "error \##{ret}\n" if ret>0
+ return ret<=0
+end
+
+$conf={
+ :LDSOFLAGS => ["-lm"],
+ :BRIDGE_LDFLAGS => ["-lm"],
+ :FEATURES => {},
+ :OPTIONS => [],
+ :DEFINES => {
+ :RUBY_PREFIX => CONFIG['prefix'],
+ :PREFIX => "/usr/local",
+ :CPU => nil,
+ :RUBY_ARCH => CONFIG['arch'],
+ },
+ :CC => "g++",
+ :OBJS => [],
+}
+
+def launch stdin,stdout,stderr,*command # -> returncode
+ child = fork
+ if not child then
+ STDIN .reopen stdin if stdin
+ STDOUT.reopen stdout if stdout
+ STDERR.reopen stderr if stderr
+ exec *command
+ #!@#$ what happens with exception upon exec ?
+ end
+ child
+end
+
+def join_pid pid
+ Process.waitpid2(pid)[1]
+end
+
+module Future; end
+
+class Feature
+ $features = []
+ def self.add(*a,&b) $features << Feature.new(*a,&b) end
+ def initialize(&b) instance_eval(&b) end
+ def self.attr2(sym,&b)
+ eval "def #{sym}(*args,&b)
+ raise args.inspect if args.length>1
+ if b then @#{sym}=b.extend Future
+ elsif args.length>0 then @#{sym}=args[0]
+ else if Future===@#{sym} then @#{sym}.call else @#{sym} end end end"
+ end
+ attr2 :tag
+ attr2 :name
+ attr2 :status #!@#$
+ attr2 :uses_so
+ attr2 :uses_bridge_so
+ attr2 :uses_o #!@#$
+ attr2 :uses_h
+ attr2 :uses_feature
+ attr2 :test
+ attr2 :options #!@#$
+ attr2 :unless_feature #!@#$
+ attr2 :action #!@#$
+ attr2 :defines #!@#$
+
+ def find_h name
+ $C_INCLUDE_PATH.find {|x| File.exist?(x+"/"+name)}
+ end
+
+ def c_test code, link=nil, options=[], feature=nil
+ link = (uses_so||[]).dup if not link
+ link=link.flatten
+ ldlpath = ENV["LD_LIBRARY_PATH"]
+ uses_h.each {|h|
+ find_h h or
+ /framework/ =~ (uses_so||[]).join(" ") or
+ raise "where is #{h} ?"
+ } if uses_h
+ ENV["LD_LIBRARY_PATH"] = ldlpath ? "./tmp:#{ldlpath}" : "./tmp"
+ link[0,0]=$conf[:LDSOFLAGS].find_all {|x| String===x and /^-L/ =~ x }.flatten
+ code=code.gsub(/#include#/) {
+ uses_h.map {|inc| "#include <#{inc}>\n" }.join""
+ }
+ log = ""
+ log << code << "\n"
+ binname = "tmp/#{$$}"
+ sourcename = binname+".cpp"
+ File.open(sourcename,"w") {|f| f.puts code }
+ command = ["/usr/bin/env", $conf[:CC]] +
+ $CFLAGS.split(/ /).reject{|x| x.length==0 }
+ if not launch2 log,*(command+options+[sourcename,
+ "-o", binname, *link])
+ pat = Regexp.new("^"+Regexp.quote(sourcename)+":\\d+: ")
+ errs = log.split("\n").find_all {|l| pat =~ l }
+ raise "gcc compilation error" if not errs or
+ errs.length==0
+ errs = errs[0].gsub(pat,"")
+ raise "gcc: #{errs}"
+ end
+ if not launch2 log,"tmp/#{$$}"
+ raise "runtime error"
+ end
+ return true
+ ensure
+ LOG.puts log
+ ENV["LD_LIBRARY_PATH"] = ldlpath if ldlpath
+ end
+
+ def asm_test code, *link
+ log = ""
+ log << code << "\n"
+ File.open("tmp/#{$$}.asm","w") {|f| f.puts code }
+ command = ["/usr/bin/env", "nasm",
+ "tmp/#{$$}.asm", "-f", "elf", "-o", "tmp/#{$$}.o"]
+ launch2 log,*command or return false
+ command = ["#{$conf[:CC]}","-o","tmp/#{$$}","tmp/#{$$}.o",*link]
+ launch2 log,*command or return false
+ command = ["tmp/#{$$}"]
+ launch2 log,*command or return false
+ true
+ ensure
+ LOG.puts log
+ end
+end
+
+#----------------------------------------------------------------#
+
+def make_expand(x)
+ y=x.gsub(/\$\(([^\)]*)\)/) {CONFIG[$1]}
+ if x!=y then make_expand y else y end
+end
+
+def read_ld_so_conf
+ return [] unless File.exist?("/etc/ld.so.conf")
+ x = File.open("/etc/ld.so.conf"){|f| f.read }.split("\s")
+ x.delete_if { x.length==0 }
+ x
+end
+
+$C_INCLUDE_PATH = (
+ (ENV["CPLUS_INCLUDE_PATH"]||"").split(":") +
+ (ENV["C_INCLUDE_PATH"]||"").split(":") +
+ ["/usr/include"]).uniq
+
+$LIBRARY_PATH = (
+ (ENV["LIBRARY_PATH"]||"").split(":") +
+ ["/usr/lib","/lib"]).uniq
+
+$LD_LIBRARY_PATH = (
+ (ENV["LD_LIBRARY_PATH"]||"").split(":") +
+ read_ld_so_conf +
+ ["/usr/lib","/lib"]).uniq
+
+# making it easier for everybody I hope:
+["/Applications/Pd.app/Contents/Resources","/sw","/usr/local",ENV["home"]].each do|base|
+ if not $LD_LIBRARY_PATH.include? "#{base}/lib" and
+ not $LIBRARY_PATH.include? "#{base}/lib" then
+ $conf[:LDSOFLAGS].unshift "-L#{base}/lib"
+ $LD_LIBRARY_PATH.unshift "#{base}/lib"
+ $LIBRARY_PATH.unshift "#{base}/lib"
+ end
+ #and not $CPLUS_INCLUDE_PATH.include? "#{base}/include"
+ if not $C_INCLUDE_PATH.include? "#{base}/include" then
+ $CFLAGS += " -I#{base}/include"
+ $C_INCLUDE_PATH.unshift "#{base}/include"
+ end
+end
+
+for var in [:$C_INCLUDE_PATH, :$LIBRARY_PATH, :$LD_LIBRARY_PATH] do
+ LOG.puts "#{var}: #{eval(var.to_s).inspect}"
+end
+
+$conf[:BINDIR] = make_expand CONFIG['bindir']
+
+LOG.puts "-"*64
+
+$CFLAGS += " -xc++ -fno-operator-names -fno-omit-frame-pointer"
+$CFLAGS += " -I/usr/X11R6/include"
+$C_INCLUDE_PATH.unshift "/usr/X11R6/include"
+
+ruby16a = "#{CONFIG['libdir']}/ruby/#{CONFIG['MAJOR']}.#{CONFIG['MINOR']}/"\
+"#{CONFIG['arch']}/#{CONFIG['LIBRUBY_A']}"
+ruby18a = "#{CONFIG['libdir']}/#{CONFIG['LIBRUBY_A']}"
+for x in [ruby16a,ruby18a] do
+ $LIBRUBY_A = make_expand x
+ break if File.exist? $LIBRUBY_A
+end
+
+FILES = [
+ [:directory, "base/",
+ [:ruby, "main.rb"],
+ [:ruby, "flow_objects.rb"],
+ [:ruby, "test.rb"],
+ [:ruby, "source_filter.rb"],
+ ],
+ [:directory, "bridge/",
+ [:ruby, "puredata.rb"],
+ [:ruby, "placebo.rb"],
+ ],
+ [:directory, "format/",
+ [:ruby, "main.rb"],
+ ],
+ [:directory, "extra/",
+ [:ruby, "smpte.rb"],
+ [:ruby, "server_2.rb"],
+ [:ruby, "server_1_grid.rb"],
+ [:ruby, "server_1_ppm.rb"],
+ [:ruby, "jmax_format.rb"],
+ [:ruby, "puredata_format.rb"],
+ ],
+]
+
+#----------------------------------------------------------------#
+Feature.add {
+ tag :fast
+ name "Compile for speed (and not debuggability)"
+}
+Feature.add {
+ tag :gcc3
+ name "GNU C++ Compiler 3"
+ options ["HAVE_GCC3"]
+ test proc {
+ pi=File.popen "#{$conf[:CC]} -v 2>&1", "r"
+ vline = pi.readlines.find {|l| /gcc version ([\d\.]+)/.match l }
+ version = $1
+ pi.close
+ if version < "3" then raise "version #{version} < 3" end
+ true
+ }
+}
+Feature.add {
+ tag :stl
+ name "C++ Standard Template Library"
+ test proc {
+ c_test %{
+ #include <vector>
+ int main () {
+ std::vector<int> foo;
+ }}
+ }
+}
+Feature.add {
+ tag :gcc64
+ name "GNU C++ in 64-bit mode"
+ options ["GCC64"]
+ test proc {
+ c_test %{
+ #include <stdio.h>
+ #include <stdlib.h>
+ #include <cstddef>
+ #define T(a) printf("%s:%d; ",#a,sizeof(a));
+ int main () {
+ T(void *)T(ptrdiff_t)T(off_t)T(size_t)puts("");
+ T(char)T(short)T(int)T(long)T(long long)puts("");
+ T(float)T(double)puts("");
+ return !( sizeof(void*)==8 );
+ }}
+ }
+}
+
+#----------------------------------------------------------------#
+
+$stack_end_test = %{
+ #include <stdio.h>
+ #include <ruby.h>
+ int main () {
+ void *bp;
+ printf("#define RUBY_STACK_END 0x%08lx",(long)&bp);
+ return rb_rescue==0;
+ }
+}
+Feature.add {
+ tag :libruby
+ name "Ruby as a dynamic library"
+ uses_bridge_so ["-lruby"]
+ #uses_h ["ruby.h"] # is in special directory
+ defines :RUBY_STACK_END => proc {
+ m = /RUBY_STACK_END\s+(.*)/.match(File.popen("tmp/#{$$}","r"){|f| f.read })
+ m[1]
+ }
+ test proc { c_test $stack_end_test, uses_bridge_so }
+}
+Feature.add {
+ tag :librubystatic
+ unless_feature [:libruby]
+ name "Ruby as a static library"
+ #uses_h ["ruby.h"] # is in special directory
+ uses_bridge_so {
+ lib = " #{$LIBRUBY_A} #{CONFIG['LIBS']} "
+ unless CONFIG["arch"] =~ /darwin/
+ lib = "-Wl,--whole-archive"+lib+"-Wl,--no-whole-archive"
+ end
+ [lib]
+ }
+ defines :RUBY_STACK_END => proc {
+ m = /RUBY_STACK_END\s+(.*)/.match(File.popen("tmp/#{$$}","r"){|f| f.read })
+ m[1]
+ }
+ test proc { c_test $stack_end_test, ["-xnone", $LIBRUBY_A, *(CONFIG['LIBS'].split)] }
+ options ["HAVE_STATIC_RUBY"] #!@#$ useless?
+}
+#----------------------------------------------------------------#
+Feature.add {
+ tag :pentium
+ name "Pentium-compatible CPU"
+ action proc { $conf[:DEFINES][:CPU] ||= "pentium" }
+ test proc {
+ (CONFIG["arch"] =~ /i\d86/) or raise "#{CONFIG["arch"]} instead"
+ c_test '
+ #include <stdio.h>
+ char get_cpuid[]={
+ 96,49,192,15,162,139,124,36,36,137,31,
+ 137,87,4,137,79,8,137,71,12,97,195};
+ main() {
+ char result[16];
+ int code;
+ ((void(*)(char*))get_cpuid)(result);
+ code = ((int*)result)[3];
+ result[12]=0;
+ fprintf(stderr,"cpuid: name=\"%12s\", flags=0x%08x\n",
+ result,code);
+ return 0;}'
+ }
+ options ["HAVE_PENTIUM"]
+}
+Feature.add {
+ tag :mmx
+ uses_feature [:pentium]
+ uses_o ["cpu/mmx.o","cpu/mmx_loader.o"]
+ name "MMX-compatible CPU (using NASM)"
+ test proc {
+ asm_test '
+ global main
+ extern exit
+ align 16
+ SECTION .data
+ foo: dd 42,0
+ SECTION .text
+ main:
+ lea esi,[foo]
+ movq mm0,qword[esi]
+ paddd mm0,qword[esi]
+ movq qword [esi],mm0
+ emms
+ cmp dword [foo], 84
+ je yes
+ push long 1
+ call exit
+ yes:
+ push long 0
+ call exit
+ ', '-lc'
+ }
+ options ["HAVE_MMX"]
+}
+Feature.add {
+ tag :simd
+ uses_feature [:pentium]
+ name "SIMD (MMX/SSE/Altivec) (using GCC)"
+ test proc {
+ c_test '
+ #include <stdio.h>
+ typedef int v8qi __attribute__ ((mode(V8QI)));
+ union vv8qi { v8qi v; char c[8]; };
+ int main () { return 0; }',nil,["-mmmx"]
+ }
+ options ["HAVE_SIMD"]
+}
+Feature.add {
+ tag :profiler
+ name "profiler (speed measurements)"
+ uses_feature [:pentium]
+ options ["HAVE_TSC_PROFILING"]
+}
+#----------------------------------------------------------------#
+Feature.add {
+ tag :usb
+ name "USB Library"
+ uses_h ["usb.h"]
+ uses_o ["optional/usb.o"]
+ uses_so ["-lusb"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return usb_open==0 || usb_get_busses==0;}
+ "
+ }
+ options ["HAVE_USB"]
+}
+#----------------------------------------------------------------#
+Feature.add {
+ tag :ieee1394
+ name "IEEE1394 Libraries for Linux (raw1394/dc1394)"
+ status :disabled
+ uses_o ["optional/ieee1394.o"]
+ uses_so ["-lraw1394","-ldc1394_control"]
+ uses_h ["libraw1394/raw1394.h","libdc1394/dc1394_control.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return raw1394_get_libversion==0 || dc1394_get_camera_info==0;}
+ "
+ }
+ options ["HAVE_1394"]
+ uses_o ["format/dc1394.o"]
+}
+Feature.add {
+ tag :x11
+ name "X11 Display Protocol"
+ uses_so ["-L/usr/X11R6/lib","-lX11","-lXext"]
+ uses_h ["X11/Xlib.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return XSetErrorHandler==0;}
+ "
+ }
+ uses_o ["format/x11.o"]
+}
+Feature.add {
+ tag :x11_shm
+ name "X11 acceleration through shared memory"
+ uses_feature [:x11]
+ uses_so ["-L/usr/X11R6/lib","-lX11","-lXext"]
+ uses_h ["X11/Xlib.h","sys/shm.h","X11/extensions/XShm.h"]
+ test proc {
+ c_test "
+ #include#
+ #include <X11/Xutil.h>
+ #include <X11/StringDefs.h>
+ #include <sys/ipc.h>
+ int main () {return XShmPutImage==0;}
+ "
+ }
+ options ["HAVE_X11_SHARED_MEMORY"]
+}
+=begin
+Feature.add {
+ tag :opengl
+ name "OpenGL (only as framebuffer)"
+ status :disabled
+ uses_so ["-L/usr/X11R6/lib","-lglut","-lGL","-lGLU"]
+ uses_h ["GL/glut.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return glutInit==0;}
+ "
+ }
+ uses_o ["format/opengl.o"]
+}
+=end
+Feature.add {
+ tag :sdl
+ name "Simple Directmedia Layer (experimental support)"
+ uses_so {
+ a=["-lSDL","-lpthread"]
+ a<<"-lobjc" if CONFIG["arch"] =~ /darwin/
+ a
+ }
+ uses_h ["SDL/SDL.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return SDL_MapRGB==0;}
+ "
+ }
+ uses_o ["format/sdl.o"]
+}
+Feature.add {
+ tag :objcpp
+ name "GNU/Apple ObjectiveC++ Compiler"
+ uses_h ["objc/Object.h"]
+ uses_so ["-lobjc"]
+ test proc {
+ c_test "
+ #include#
+ int main () { [[Object alloc] init]; }
+ ", nil, ["-xobjective-c++"]
+ }
+}
+Feature.add {
+ tag :quartz
+ name "Apple Quartz/Cocoa Display"
+ uses_so ["-lobjc",["-framework","Cocoa"]]
+ uses_feature [:objcpp]
+ uses_h ["objc/Object.h","Cocoa/Cocoa.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return CGImageRelease==0;}
+ ", nil, ["-xobjective-c++"]
+ }
+ uses_o ["format/quartz.o"]
+}
+Feature.add {
+ tag :aalib
+ name "Ascii Art Library"
+ uses_so ["-laa"]
+ uses_h ["aalib.h"]
+ test proc {
+ c_test "
+ #define aa_hardwareparams aa_hardware_params
+ extern \"C\" {
+ #include#
+ };
+ int main () {return aa_init==0;}
+ "
+ }
+ uses_o ["format/aalib.o"]
+}
+Feature.add {
+ tag :jpeg
+ name "JPEG Library"
+ uses_so ["-ljpeg"]
+ uses_h ["jpeglib.h"]
+ test proc {
+ c_test "
+ extern \"C\" {
+ #include <stdio.h>
+ #include#
+ };
+ int main () {
+ return jpeg_write_scanlines==0;}
+ "
+ }
+ uses_o ["format/jpeg.o"]
+}
+Feature.add {
+ tag :png
+ name "PNG Library"
+ uses_so ["-lpng","-lz"]
+ uses_h Or[["libpng12/png.h"],["png.h"]]
+ test proc {|f|
+ f.c_test %`
+ extern "C" {
+ #include <stdio.h>
+ #include#
+ };
+ int main () {
+ #define T(a) printf("%s:%d; ",#a,sizeof(a));
+ T(png_uint_32)T(long)puts("");
+ if (!png_check_sig) return 1;
+ return 0;}
+ `
+ }
+ uses_o ["format/png.o"]
+}
+Feature.add {
+ tag :videodev
+ name "Video4linux Digitizer Driver Interface"
+ uses_h ["linux/videodev.h"]
+ test proc {
+ c_test "
+ #include <stdlib.h>
+ #include#
+ int main () { struct video_window foo; return 0; }"
+ }
+ uses_o ["format/videodev.o"]
+}
+Feature.add {
+ tag :mpeg3
+ name "HeroineWarrior LibMPEG3"
+ uses_so ["-lmpeg3","-lpthread","-lm",
+ "-L/usr/X11R6/lib"]
+ uses_h Or["libmpeg3/libmpeg3.h","libmpeg3.h"]
+ test proc {|f|
+ f.c_test "
+ #include#
+ int main () { return mpeg3_open==0; }
+ "
+ }
+ uses_o ["format/mpeg3.o"]
+}
+Feature.add {
+ tag :quicktimeapple
+ name "Apple's QuickTime"
+ uses_so [["-framework","Quicktime"]]
+ uses_h ["Quicktime/quicktime.h","Quicktime/movies.h"]
+ test proc {
+ c_test "
+ #include#
+ int main () { return EnterMovies==0; }
+ "
+ }
+ uses_o ["format/quicktimeapple.o"]
+}
+Feature.add {
+ tag :quicktimehw
+ unless_feature :quicktimeapple
+ name "HeroineWarrior QuickTime4Linux (or LibQuickTime)"
+ uses_so Or[
+ ["-lquicktime","-lpthread","-lpng","-ldl","-lglib","-lz"],
+ ["-lquicktime","-lpthread","-lpng","-ldl","-lglib-1.2","-lz"]]
+ uses_h ["quicktime/quicktime.h","quicktime/lqt_version.h"]
+ test proc {|f|
+ f.c_test %`
+ #include <stdio.h>
+ #include#
+ int main () {
+ fprintf(stderr,"LQT_VERSION = %s\\n",
+ #ifdef LQT_VERSION
+ LQT_VERSION
+ #else
+ "(undefined)"
+ #endif
+ ); return quicktime_open==0; }
+ `
+ }
+ uses_o ["format/quicktimehw.o"]
+}
+Feature.add {
+ tag :xine
+ name "Xine movie decoder"
+ uses_so ["-lxine"]
+ uses_h ["xine.h"]
+ status :disabled
+ test proc {|f|
+ f.c_test %`
+ #include <stdio.h>
+ #include#
+ int main () {
+ fprintf(stderr,"Xine version = %d.%d.%d (%s)\\n",
+ XINE_MAJOR_VERSION, XINE_MINOR_VERSION,
+ XINE_SUB_VERSION, XINE_VERSION);
+ return xine_new==0; }`
+ }
+ uses_o ["format/xine.o"]
+}
+#Feature.add {
+# tag :example
+# name "example (example file optional/example.c)"
+# uses_o ["optional/example.o"]
+# test proc {|f|
+# c_test %`
+# #include <stdio.h>
+# int main () {
+# return 0 /* 0=ok, nonzero=bad */; }`
+# }
+#}
+#----------------------------------------------------------------#
+Feature.add {
+ tag :puredata
+ name "Miller Puckette's Pure Data"
+ uses_feature [Or[:libruby,:librubystatic]]
+ options ["HAVE_PUREDATA"]
+ defines {
+ path = $C_INCLUDE_PATH.find {|x| File.exist?(x+"/m_pd.h")}
+ m = /PD_VERSION_INT\s+(.*)/.match(File.popen("tmp/#{$$}","r"){|f| f.read })
+ {:PUREDATA_PATH => File.dirname(path)+"/lib/pd", :PD_VERSION_INT => m[1].to_i}
+ }
+ uses_h ["m_pd.h"]
+ test proc {
+ c_test %`
+ #include#
+ #include <stdio.h>
+ int main () {
+ printf("#define PD_VERSION_INT %d\\n",
+ #ifdef PD_MAJOR_VERSION
+ (int)(PD_MAJOR_VERSION*100+PD_MINOR_VERSION));
+ #else
+ (int)(PD_VERSION*100));
+ #endif
+ return 0;
+ }
+ `
+ }
+}
+
+$features_h = {}
+$features.each {|f| $features_h[f.tag]=f }
+
+#--------------------------------#
+
+def usage
+ log = ""
+ log << "usage: ./configure "
+ log << "[--use-compiler compiler] [--use-compiler-option option]* "
+ log << "[--use-cpu cpu] [--lite] [--debug] [--debug-harder]"
+ log << "[--ruby-prefix directory] "
+ $features_h.keys.map {|k| k.to_s }.sort.each {|k| log << "[--no-#{k}] " }
+ $features_h.keys.map {|k| k.to_s }.sort.each {|k| log << "[--force-#{k}] " }
+ puts
+ while log.length>0 do puts log.slice!(/^.{1,70} /) end
+end
+
+while ARGV.length>0 do
+ arg=ARGV.shift
+ case arg
+ when /=/
+ i=arg.index '='
+ ARGV.unshift arg[0..i-1], arg[i+1..-1]
+ when /^--no-/
+ name = arg[5..-1].intern
+ puts "there is no feature called #{name}" if not $features_h[name]
+ puts "--no: won't check for feature #{name}"
+ $features_h.delete name
+ when /^--force-/
+ name = arg[8..-1].intern
+ puts "there is no feature called #{name}" if not $features_h[name]
+ puts "--force: assuming #{name} is there"
+ $features_h[name].test nil
+ when "--static" # experimental
+ $conf[:STATIC]=true
+ $conf[:LDSOFLAGS] << "-static"
+# ARGV.unshift "--no-libruby"
+ when "--debug"
+ puts "Debug Mode (more error checking; less speed)"
+ $conf[:OPTIONS].push :HAVE_DEBUG
+ $CFLAGS += " -fno-inline"
+ when "--debug-harder"
+ puts "Debug Harder Mode (even more error checking; even less speed)"
+ $conf[:OPTIONS].push :HAVE_DEBUG
+ $conf[:OPTIONS].push :HAVE_DEBUG_HARDER
+ $CFLAGS += " -fno-inline"
+ when "--lite"
+ puts "Lite Mode (no float, no int64)"
+ $conf[:OPTIONS].push :HAVE_LITE
+ when "--help"; usage; exit 0
+ when "--prefix", "--ruby-prefix"
+ $conf[:DEFINES][:RUBY_PREFIX]=ARGV.shift
+ when "--use-compiler"
+ $conf[:CC] = ARGV.shift
+ when "--use-compiler-option"
+ $CFLAGS += " "+ARGV.shift
+ when "--use-cpu"
+ $conf[:DEFINES][:CPU] = ARGV.shift
+ when "--verbose"
+ $verbose=true
+ when "--bindir"
+ $conv[:BINDIR] = ARGV.shift
+ else puts "unknown option \"#{arg}\""; usage; exit 1
+ end
+end
+
+# the ||= lines are patches for old versions of ruby.
+CONFIG["ruby_version"] ||= "$(MAJOR).$(MINOR)"
+CONFIG["rubylibdir"] ||= "$(libdir)/ruby/$(ruby_version)"
+CONFIG["archdir"] ||= CONFIG["rubylibdir"] + "/" + CONFIG["arch"]
+
+$CFLAGS += " -I " + (make_expand CONFIG["archdir"])
+
+#--------------------------------#
+
+DUAL = Object.new
+DUAL.instance_eval {
+ def self.print x
+ LOG .puts x; LOG .flush
+ STDERR.print x; STDERR.flush
+ end
+ def self.puts x
+ self.print x+"\n"
+ end
+}
+
+def try feature
+ if Or===feature.uses_so
+ k=1
+ feature.uses_so.a.each {|i|
+ e=feature.dup; e.uses_so i; e.name(e.name+" (try \##{k})")
+ r=try e; return r if r
+ k+=1
+ }
+ return false
+ end
+ if Or===feature.uses_h
+ feature.uses_h.a.each {|i|
+ e=feature.dup; e.uses_h i; e.name(e.name+" <#{e.uses_h}>")
+ r=try e; return r if r
+ }
+ return false
+ end
+ LOG.puts "", "-"*64
+ DUAL.print "[#{feature.tag}] #{feature.name}: "
+ (feature.uses_feature||[]).find {|f|
+ if not (
+ if Or===f then f.a.find {|x| $conf[:FEATURES][x] } else $conf[:FEATURES][f] end
+ ) then
+ DUAL.puts "disabled (would need #{f})"
+ return
+ end
+ }
+ if feature.status==:disabled then DUAL.puts "disabled (by author)"; return end
+ if not $features_h[feature.tag] then DUAL.puts "disabled (by user)"; return end
+ fu = feature.unless_feature || []
+ fu = [fu] if not Array===fu
+ for f in fu || [] do
+ if $conf[:FEATURES][f] then
+ DUAL.puts "disabled (using #{f} instead)"
+ return
+ end
+ end
+
+ if feature.test
+ begin
+ tresult = feature.test.call(feature)
+ rescue StandardError => e
+ end
+ if tresult
+ DUAL.puts "found "+(if tresult!=true
+ then " (#{tresult})"
+ else "" end)
+ if tresult == "static"
+ feature.uses_so.map! {|x|
+ "-Wl,--whole-archive #{x} -Wl,--no-whole-archive"
+ } if feature.uses_so
+ feature.uses_bridge_so.map! {|x|
+ "-Wl,--whole-archive #{x} -Wl,--no-whole-archive"
+ } if feature.uses_bridge_so
+ end
+ else
+ DUAL.puts "missing "+(if e
+ then (if $verbose
+ then "(#{e} @ #{e.backtrace.join', '})"
+ else "(#{e})" end)
+ else "(return false)" end)
+ if e
+ LOG.puts e.inspect
+ LOG.puts e.backtrace
+ end
+ return false
+ end
+ else
+ puts "enabled"
+ $conf[:FEATURES][feature.tag] = feature
+ feature.action.call if feature.action
+ end
+ feature.action.call if feature.action
+ $conf[:FEATURES][feature.tag] = feature
+ $conf[:LDSOFLAGS].concat(feature.uses_so||[])
+ $conf[:BRIDGE_LDFLAGS].concat(feature.uses_bridge_so||[])
+ $conf[:OBJS].concat(feature.uses_o||[])
+ $conf[:OPTIONS].concat(feature.options||[])
+ for k,v in feature.defines||{} do
+ $conf[:DEFINES][k]=(if Proc===v then v[] else v end)
+ end
+ true
+end
+
+DUAL.puts "This is the GridFlow 0.8.0 configurator within Ruby version #{RUBY_VERSION}"
+
+begin
+ $features.each {|feature| try feature }
+ensure
+ #!@#$ note: see END{} (duplication)
+ system "/bin/rm -f tmp/#{$$} tmp/#{$$}.c tmp/#{$$}.o tmp/#{$$}.asm"
+end
+
+$conf[:LDSOFLAGS].uniq!
+$conf[:BRIDGE_LDFLAGS].uniq!
+
+$CFLAGS += " -falign-functions=4" if $conf[:FEATURES][:gcc3]
+
+#if not $conf[:FEATURES][:gcc3]
+# puts "You should install gcc 3.x; gcc 2.9.x is no longer supported"
+# puts "(you might use --force-gcc3 to pretend at your own risk)"
+# exit 1
+#end
+
+#--------------------------------#
+
+LOG.puts "-"*64
+for z in [:BRIDGE_LDFLAGS, :LDSOFLAGS, :OPTIONS, :DEFINES, :OBJS] do
+ LOG.puts "#{z}: #{$conf[z].inspect}"
+end
+LOG.puts "-"*64
+RUBY = "$(RUBY_INSTALL_NAME)"
+
+def my_install_files(f,base,entries,obase="$(sitelibdir)/gridflow/#{base}")
+ entries.each {|type,name,*rest|
+ if Array===name then name,oname=name else oname=name end
+ case type
+ when :ruby
+ f.puts "\t$(INSTALL_DATA) #{base+name} #{obase}/#{oname}"
+ when :directory
+ if oname[0,1]!="/" then oname="#{obase}/#{oname}" end
+ f.puts "\t$(INSTALL_DIR) #{oname}"
+ my_install_files(f,base+name,rest,oname)
+ end
+ }
+end
+
+def my_uninstall_files(f,base,entries,obase="$(sitelibdir)/gridflow/#{base}")
+ entries.each {|type,name,*rest|
+ if Array===name then name,oname=name else oname=name end
+ case type
+ when :ruby
+ f.puts "\trm #{obase}/#{oname}"
+ when :directory
+ my_uninstall_files(f,base+name,rest)
+ end
+ }
+end
+
+def make_makefile f
+ puts ""
+ f.puts "RUBY = #{RUBY}"
+ f.puts "ruby-all::", ""
+ f.puts "ruby-install::"
+ my_install_files(f,"",FILES)
+ f.puts "\tcp bin/jmax2pd $(gfbindir); chmod 755 $(gfbindir)/jmax2pd\n"
+ f.puts
+ f.puts "ruby-uninstall::"
+ my_uninstall_files(f,"",FILES)
+ f.puts
+end
+
+puts "generating ./config.make"
+
+File.open("./config.make","w") {|f| f.puts "
+
+RUBYARCH=#{CONFIG['arch']}
+"
+
+f.puts "BRIDGE_LDFLAGS = " + $conf[:BRIDGE_LDFLAGS].flatten.join(" ") + " " + $LDFLAGS
+
+if CONFIG["arch"] =~ /darwin/ then
+ f.puts "BRIDGE_LDFLAGS += -bundle -flat_namespace"
+else
+ f.puts "BRIDGE_LDFLAGS += -rdynamic -shared"
+end
+$CFLAGS += " -mcpu=$(CPU)" if $conf[:DEFINES][:CPU]
+$CFLAGS += " -march=$(CPU)" if $conf[:DEFINES][:CPU]
+#$CFLAGS += " -fforce-addr"
+#$CFLAGS += " -fprefetch-loop-arrays"
+#$CFLAGS += " -falign-jumps=4"
+#$CFLAGS += " -falign-loops=4"
+f.puts "CFLAGS += " + $CFLAGS
+
+for k in $conf[:OPTIONS] do f.puts "#{k}=yes" end
+for k,v in $conf[:DEFINES] do f.puts "#{k}=#{v}" end
+
+$sources = %w(
+base/grid.c base/main.c base/number.c base/bitpacking.c
+base/flow_objects.c
+base/flow_objects_for_image.c
+base/flow_objects_for_matrix.c
+)
+
+#for o in $conf[:OBJS] do
+# o=o.downcase.chomp(".o")
+# x = o.downcase+".c"
+# x = o.downcase+".m" if not File.exist?(x)
+# #raise "woops, missing file #{o.downcase}.*" if not File.exist?(x) and
+# # o!="cpu/mmx"
+# $sources << x
+#end
+
+f.puts "SOURCES = #{$sources.join(" ")} \\"
+f.puts ""
+} # end open config.make
+
+#--------------------------------#
+puts "generating config.h"
+File.open("config.h","w") {|f| f.puts "
+\#ifndef __CONFIG_H
+\#define __CONFIG_H
+/* this file was auto-generated by gridflow/configure */
+
+"
+f.puts "#define STARTUP_LIST(PRE) \\"
+f.puts $conf[:OBJS].map {|o| "PRE startup_#{File.basename(o,'.o')}();" }.join("\\\n")
+for k in $conf[:OPTIONS] do f.puts "\#define #{k}" end
+for k,v in $conf[:DEFINES] do f.puts "\#define #{k} "+v.inspect end
+if $conf[:FEATURES][:mpeg3]
+f.puts "
+\#ifdef LIBMPEG_INCLUDE_HERE
+\#include <#{$conf[:FEATURES][:mpeg3].uses_h}>
+\#endif
+"
+end
+f.puts "
+\#define RUBY_BINDIR #{make_expand(CONFIG['bindir']).inspect}
+\#endif /* __CONFIG_H */"
+}
+
+#--------------------------------#
+#puts "generating config.rb"
+#File.open("config.rb","w") {|f| f.puts %{
+#\# this file was auto-generated by gridflow/configure
+#}}
+#----------------------------------------------------------------#
+# Some fairly nontrivial abuse of black magic.
+
+$LOCAL_LIBS = $conf[:LDSOFLAGS].flatten.join(" ")
+
+$objs = $sources.collect{|i| i.sub(/.[cm]$/,".o") }
+$objs[$objs.index("base/number.o"),1] = (1..3).map {|i| "base/number.#{i}.o" }
+dir_config("gridflow")
+create_makefile("gridflow")
+mf = File.readlines("Makefile").join""
+
+common_deps1 = "$(COMMON_DEPS)"
+common_deps2 = common_deps1 + " base/grid.h.fcs"
+
+mf.sub!(/^.c.o:\s*\n\t(.*)\n/) {
+ comp=$1
+ comp.sub!(/\(CC\)/,'(CXX)')
+ comp << " -o $@" if not comp =~ /-o\s*\$@/
+ comp2 = comp.gsub /-c/,'-xobjective-c++ -c'
+
+ "%.h.fcs: %.h #{common_deps1}\n\truby -w base/source_filter.rb $< $@\n\n"+
+ "%.c.fcs: %.c #{common_deps2}\n\truby -w base/source_filter.rb $< $@\n\n"+
+ "%.m.fcs: %.m #{common_deps2}\n\truby -w base/source_filter.rb $< $@\n\n"+
+ "%.o: %.c.fcs #{common_deps2}\n\t#{comp}\n"+
+ "%.1.o: %.c.fcs #{common_deps2}\n\t#{comp.gsub /-c/,'-DPASS1 -c'}\n"+
+ "%.2.o: %.c.fcs #{common_deps2}\n\t#{comp.gsub /-c/,'-DPASS2 -c'}\n"+
+ "%.3.o: %.c.fcs #{common_deps2}\n\t#{comp.gsub /-c/,'-DPASS3 -c'}\n"+
+ "%.o: %.m.fcs #{common_deps2}\n\t#{comp2}\n"
+}
+mf.gsub!(/^.SUFFIXES:.*$/, ".SUFFIXES:\n\n") or mf<<".SUFFIXES:\n\n"
+mf << ".PRECIOUS: %.h.fcs %.c.fcs %.m.fcs\n"
+mf.gsub! /DESTDIR/, 'RUBYDESTDIR'
+mf.gsub! /\*\.o/, "*.o */*.o"
+
+# GAAAH!!!
+if RUBY_VERSION >= "1.8" then
+ mf.gsub!(/^((site-)?install:.*)/) {$1+" $(RUBYARCHDIR)/$(DLLIB) install2"}
+else
+ mf.gsub!(/^((site-)?install:.*)/) {$1+" install2"}
+end
+
+mf.gsub!(/^install:.*/) {"install:site-install"} # should i keep this line?
+mf.sub!(/^all:(.*)$/) { "all: #{$1} all2" }
+mf.sub! /^clean:/,"clean: clean2 "
+mf.sub! /CC = gcc\n/, "CC = gcc\nCXX = #{$conf[:CC]}\n"
+mf.sub! /^(OBJS = .*)$/, "\\1 #{$conf[:OBJS].join' '}"
+mf[0,0] = "COMMON_DEPS = config.make Makefile Makefile.gf base/source_filter.rb\n"+
+ "gfbindir = #{$conf[:BINDIR]}\n"
+mf.sub!(/^site-install:\s*install/,"site-install: ")
+mf.sub! /^prefix = .*$/, "prefix = " + make_expand($conf[:DEFINES][:RUBY_PREFIX])
+mf.sub! /^LDSHARED = g?cc/, "LDSHARED = $(CXX)"
+# Adam Lindsay's Mac attempts.
+mf.sub! /-no-precomp/, "-no-cpp-precomp"
+# for proper operation on Cygwin
+mf.sub! /--driver-name=gcc/, "--driver-name=#{$conf[:CC]}"
+# remove gcc3.2 warning about -I/usr/include
+mf.sub!(/^CPPFLAGS = (.*)$/) {
+ cpp = "CPPFLAGS = " +
+ make_expand($1).sub(%r"-I\s*/usr/include","")
+}
+
+f = File.open("Makefile","w")
+f.puts "include config.make"
+f.puts mf
+f.puts "include Makefile.gf"
+make_makefile f
+f.close
+
+#--------------------------------#
+
+puts "delegating to: devices4ruby/extconf.rb"
+r=$conf[:DEFINES][:RUBY_PREFIX]
+a=[]
+a<<"--prefix"<<r if r
+Dir.chdir "devices4ruby"
+system "/usr/bin/env", "ruby", "extconf.rb", *a
+Dir.chdir ".."
+puts "(back)"
+
+#--------------------------------#
+
+puts "",
+"\e[1mSee ./config.log if you want the details of the configuration tests.\e[0m",
+"\e[1mIf you are satisfied with that configuration, you may go on,\e[0m",
+"\e[1m and do \"make\" and then \"make install\".\e[0m",
+"\e[1mIf you get stuck, you could contact the author about it,\e[0m",
+"\e[1m but first make sure you read \"doc/install.html\". \e[0m",
+""
+
+#--------------------------------#
+
+END {
+ system "/bin/rm -f tmp/#{$$} tmp/#{$$}.c tmp/#{$$}.o tmp/#{$$}.asm"
+}
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-25 20:13:47 +0000