aboutsummaryrefslogtreecommitdiff
path: root/externals/gridflow/configure
diff options
context:
space:
mode:
Diffstat (limited to 'externals/gridflow/configure')
-rwxr-xr-xexternals/gridflow/configure854
1 files changed, 854 insertions, 0 deletions
diff --git a/externals/gridflow/configure b/externals/gridflow/configure
new file mode 100755
index 00000000..cdf3896e
--- /dev/null
+++ b/externals/gridflow/configure
@@ -0,0 +1,854 @@
+#!/usr/bin/env ruby
+# $Id: configure 3946 2008-06-26 15:36:22Z matju $
+=begin
+ GridFlow
+ Copyright (c) 2001-2007 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 "ftools"
+$CFLAGS = ""
+include Config
+OSX = !!( CONFIG["arch"] =~ /darwin/ )
+
+require "win32/process" if CONFIG["arch"] =~ /mingw/
+LOG = File.open "./config.log", "w"
+
+Red = "\e[0;1;31m"
+Green = "\e[0;1;32m"
+Light = "\e[0m"
+Dark = "\e[0;1;30m"
+Yellow = "\e[0;1;33;44m"
+
+$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 => [],
+ :FEATURES => {},
+ :OPTIONS => [],
+ :DEFINES => {
+ :CPU => nil,
+ :GEM_INCLUDE => "../Gem/src",
+ },
+ :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_o
+ attr2 :uses_h
+ attr2 :uses_feature
+ attr2 :test
+ attr2 :options
+ attr2 :unless_feature
+ attr2 :action
+ attr2 :defines
+ def find_h name
+ if name[0..0]=="/" then
+ File.exist?(name)
+ else
+ $C_INCLUDE_PATH.find {|x| File.exist?(x+"/"+name)}
+ end
+ 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 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
+
+def epath x; (ENV[x]||"").split(":") end
+
+$C_INCLUDE_PATH = (
+ epath("CPLUS_INCLUDE_PATH") +
+ epath("C_INCLUDE_PATH") +
+ ["/usr/include"]).uniq
+$LIBRARY_PATH = (
+ epath("LIBRARY_PATH") +
+ ["/usr/lib","/lib"]).uniq
+$LD_LIBRARY_PATH = (
+ epath("LD_LIBRARY_PATH") +
+ read_ld_so_conf +
+ ["/usr/lib","/lib"]).uniq
+$LIBX11DIR = [
+ "-L/usr/X11R6/lib", "-L/opt/gnome/lib",
+ "-L/usr/X11R6/lib64","-L/opt/gnome/lib64"]
+$LIBX11 = $LIBX11DIR + ["-lX11"]
+
+# making it easier for everybody I hope:
+def prepend_path base
+ bl = base+"/lib"
+ bi = base+"/include"
+ if not $LD_LIBRARY_PATH.include? bl and
+ not $LIBRARY_PATH.include? bl then
+ $conf[:LDSOFLAGS].unshift "-L"+bl
+ $LD_LIBRARY_PATH.unshift bl
+ $LIBRARY_PATH.unshift bl
+ end
+ #and not $CPLUS_INCLUDE_PATH.include? bi
+ if not $C_INCLUDE_PATH.include? bi then
+ $CFLAGS += " -I"+bi
+ $C_INCLUDE_PATH.unshift bi
+ end
+end
+prepend_path "/sw" if OSX
+prepend_path "/usr/local"
+prepend_path ENV["HOME"]
+$CFLAGS += " -I."
+$C_INCLUDE_PATH.unshift "."
+
+for var in [:$C_INCLUDE_PATH, :$LIBRARY_PATH, :$LD_LIBRARY_PATH] do
+ LOG.puts "#{var}: #{eval(var.to_s).inspect}"
+end
+
+LOG.puts "-"*64
+
+$CFLAGS += " -xc++ -fno-operator-names"
+$CFLAGS += " -I/usr/X11R6/include"
+$C_INCLUDE_PATH.unshift "/usr/X11R6/include"
+
+#----------------------------------------------------------------#
+Feature.add {
+ tag :gcc3
+ name "GNU C++ Compiler 3 (or 4)"
+ options ["HAVE_GCC3"]
+ defines :GCC_VERSION => proc {
+ m = /GCC_VERSION\s+(.*)/.match(File.popen("tmp/#{$$}","r"){|f| f.read })
+ m[1]
+ }
+ # how does this handle two test procs again?
+ 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
+ }
+ test proc {
+ c_test %{
+ #include <stdio.h>
+ int main () {
+ printf("GCC_VERSION %d.%d.%d\\n", __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__);
+ return !(__GNUC__>=3);
+ }}}}
+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>
+ #include <sys/types.h>
+ #define T(a) printf("%s:%ld; ",#a,(long)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 );
+ }}}}
+Feature.add {
+ tag :pentium
+ name "Pentium-compatible CPU"
+ action proc { $conf[:DEFINES][:CPU] ||= "pentium" }
+ options ["HAVE_PENTIUM"]
+ test proc {
+ (CONFIG["arch"] =~ /(i\d86|x86_64)/) 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;}'}}
+Feature.add {
+ tag :mmx
+ uses_feature [:pentium]
+ uses_o ["base/mmx.o","base/mmx_loader.o"]
+ name "MMX-compatible CPU (using NASM)"
+ options ["HAVE_MMX"]
+ test proc { #!@#$ isn't 64-bit-compatible
+ 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'}}
+Feature.add {
+ tag :x11
+ name "X11 Display Protocol"
+ uses_so $LIBX11
+ uses_h ["X11/Xlib.h"]
+ uses_o ["format/x11.o"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return XSetErrorHandler==0;}"}}
+Feature.add {
+ tag :x11_shm
+ name "X11 acceleration by shared memory (XSHM plugin)"
+ uses_feature [:x11]
+ uses_so $LIBX11+["-lXext"]
+ uses_h ["X11/Xlib.h","sys/shm.h","X11/extensions/XShm.h"]
+ options ["HAVE_X11_SHARED_MEMORY"]
+ test proc {
+ c_test "
+ #include#
+ #include <X11/Xutil.h>
+ #include <X11/StringDefs.h>
+ #include <sys/ipc.h>
+ int main () {return XShmPutImage==0;}"}}
+Feature.add {
+ tag :sdl
+ name "Simple Directmedia Layer (experimental support)"
+ uses_so {
+ a=["-lSDL","-lpthread"]
+ a << "-lobjc" if OSX
+ a
+ }
+ uses_h ["SDL/SDL.h"]
+ uses_o ["format/sdl.o"]
+ test proc {
+ c_test "
+ #include#
+ #undef main
+ int main () {return SDL_MapRGB==0;}"}}
+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"]
+ uses_o ["format/quartz.o"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return CGImageRelease==0;}
+ ", nil, ["-xobjective-c++"]}}
+Feature.add {
+ tag :aalib
+ name "Ascii Art Library"
+ uses_so ["-laa"]
+ uses_h ["aalib.h"]
+ uses_o ["format/aalib.o"]
+ test proc {
+ c_test "
+ #define aa_hardwareparams aa_hardware_params
+ extern \"C\" {
+ #include#
+ };
+ int main () {return aa_init==0;}"}}
+Feature.add {
+ tag :netpbm
+ name "NetPBM 10 Library"
+ uses_so ["-lnetpbm"]
+ uses_h ["pam.h"]
+ uses_o ["format/netpbm.o"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return pm_init==0;}"}}
+Feature.add {
+ tag :jpeg
+ name "JPEG Library"
+ uses_so ["-ljpeg"]
+ uses_h ["jpeglib.h"]
+ uses_o ["format/jpeg.o"]
+ test proc {
+ c_test "
+ extern \"C\" {
+ #include <stdio.h>
+ #include#
+ };
+ int main () {
+ return jpeg_write_scanlines==0;}"}}
+Feature.add {
+ tag :png
+ name "PNG Library"
+ uses_so ["-lpng","-lz"]
+ uses_h Or[["libpng12/png.h"],["png.h"]]
+ uses_o ["format/png.o"]
+ 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;}`}}
+Feature.add {
+ tag :videodev
+ name "Video4linux Digitizer Driver Interface"
+ uses_h ["linux/videodev.h"]
+ uses_o ["format/videodev.o"]
+ #uses_o ["format/videodev-old.o"]
+ test proc {
+ c_test "
+ #include <stdlib.h>
+ #include#
+ int main () { struct video_window foo; return 0; }"}}
+Feature.add {
+ tag :dc1394
+ name "DC1394 for Linux"
+ uses_so ["-ldc1394_control"]
+ uses_h ["libdc1394/dc1394_control.h"]
+ uses_o ["format/dc1394.o"]
+ options ["HAVE_DC1394"]
+ test proc {
+ c_test "
+ #include#
+ int main () {return dc1394_get_camera_port==0;}"}}
+Feature.add {
+ tag :mpeg3
+ name "HeroineWarrior LibMPEG3"
+ uses_so $LIBX11DIR+["-lmpeg3","-lpthread","-lm"]
+ uses_h Or["libmpeg3/libmpeg3.h","libmpeg3.h"]
+ uses_o ["format/mpeg3.o"]
+ test proc {|f|
+ f.c_test "
+ #include#
+ int main () { return mpeg3_open==0; }"}}
+Feature.add {
+ tag :quicktimeapple
+ name "Apple's QuickTime"
+ uses_so [["-framework","Quicktime"]]
+ uses_h ["QuickTime/QuickTime.h","QuickTime/Movies.h"]
+ uses_o ["format/quicktimeapple.o"]
+ test proc {
+ c_test "
+ #include#
+ int main () { return EnterMovies==0; }
+ "}}
+Feature.add {
+ tag :quicktimehw
+ unless_feature :quicktimeapple
+ name "Plaum's LibQuickTime"
+ uses_so Or[
+ $LIBX11DIR+["-lquicktime","-lpthread","-lpng","-ldl","-lglib","-lz"],
+ $LIBX11DIR+["-lquicktime","-lpthread","-lpng","-ldl","-lglib-1.2","-lz"]]
+ f = ["quicktime.h","colormodels.h","lqt.h","lqt_version.h","lqt_codecinfo.h"]
+ uses_h Or[
+ f.map{|x| "lqt/"+x },
+ f.map{|x| "quicktime/"+x }]
+ uses_o ["format/quicktimehw.o"]
+ 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; }
+ `}}
+Feature.add {
+ tag :puredata
+ name "PureData (or DesireData)"
+ 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 })
+ {: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;}`}}
+Feature.add {
+ tag :desiredata
+ name "DesireData"
+ uses_h ["m_pd.h"]
+ defines ["HAVE_DESIREDATA"]
+ test proc {
+ c_test %`
+ #include#
+ int main () {return !gobj_subscribe;}`}}
+Feature.add {
+ tag :gem09
+ name "PureData GEM (source code) with m_holdname"
+ uses_feature [:puredata]
+ uses_o ["optional/gem.o"]
+ options ["HAVE_GEM","HAVE_HOLDNAME"]
+ test proc {
+ # hack
+ $C_INCLUDE_PATH.unshift $conf[:DEFINES][ :GEM_INCLUDE]
+ $CFLAGS += " -I"+$conf[:DEFINES][ :GEM_INCLUDE]
+ c_test %`
+ #include "Base/GemBase.h"
+ int main () {CPPExtern::m_holdname; return 0;}`}}
+Feature.add {
+ tag :gem08
+ unless_feature:gem09
+ name "PureData GEM (source code) without m_holdname"
+ uses_feature [:puredata]
+ uses_o ["optional/gem.o"]
+ options ["HAVE_GEM"]
+ test proc {
+ # hack
+ $C_INCLUDE_PATH.unshift $conf[:DEFINES][ :GEM_INCLUDE]
+ $CFLAGS += " -I"+$conf[:DEFINES][ :GEM_INCLUDE]
+ c_test %`
+ #include "Base/GemBase.h"
+ int main () {return 0;}`}}
+Feature.add {
+ tag :opencv
+ name "Intel OpenCV"
+ uses_o ["optional/opencv.o"]
+ uses_so ["-lcv"]
+ options ["HAVE_OPENCV"]
+ defines {{:OPENCV_SHARE_PATH => File.dirname($C_INCLUDE_PATH.find {|x| File.exist?(x+"/opencv/cv.h")}) + "/share/opencv"}}
+ test proc {
+ c_test %`
+ #include <opencv/cv.h>
+ int main () {return 0;}`}}
+Feature.add {
+ tag :fftw
+ name "FFTW (Fastest Fourier Transform in the West)"
+ uses_o ["optional/fftw.o"]
+ uses_so ["-lfftw3f","-lfftw3"]
+ options ["HAVE_FFTW"]
+ test proc {
+ c_test %`
+ #include <fftw3.h>
+ int main () {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]"
+ log << "[--gem-include 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
+
+$debug=false
+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].untaint.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].untaint.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"
+ when "--debug"
+ puts "Debug Mode (more error checking; less speed)"
+ $debug=true
+ $conf[:OPTIONS].push :HAVE_DEBUG
+ when "--lite"
+ puts "Lite Mode (no float64, no int64)"
+ $conf[:OPTIONS].push :HAVE_LITE
+ when "--help"
+ usage; exit 0
+ when "--gem-include"
+ $conf[:DEFINES][ :GEM_INCLUDE]=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
+ else puts "unknown option \"#{arg}\""; usage; exit 1
+ end
+end
+
+if $debug
+ $CFLAGS += " -O0 -fno-inline"
+else
+ $CFLAGS += " -O3"
+end
+
+#--------------------------------#
+
+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 Proc===feature.uses_so then feature.uses_so(feature.uses_so[]) end
+ 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; k+=1; return r if r }
+ return false
+ end
+ if Proc===feature.uses_h then feature.uses_h(feature.uses_h[]) end
+ if Or===feature.uses_h
+ k=1; feature.uses_h.a.each {|i|
+ i=[i] if String===i
+ e=feature.dup; e.uses_h i; e.name(e.name+" <#{i[0]}>")
+ r=try e; k+=1; return r if r }
+ return false
+ end
+ LOG.puts "", "-"*64
+ line = "[#{feature.tag}] #{feature.name}: "
+ DUAL.print Light + "[#{Yellow}#{feature.tag}#{Light}] #{feature.name}: "
+ arrow = "-"*([78-line.length,0].max)+ "> "
+ #DUAL.print Dark + arrow +Red
+ (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 Red+arrow+"disabled (would need #{f})"
+ return
+ end
+ }
+ if feature.status==:disabled then DUAL.puts Dark+arrow+"disabled (by author)"; return end
+ if not $features_h[feature.tag] then DUAL.puts Dark+arrow+"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 Dark+arrow+"disabled (using #{f} instead)"; return end
+ end
+ if feature.test
+ begin tresult = feature.test.call(feature); rescue StandardError => e; end
+ if tresult
+ DUAL.puts Green+arrow+"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
+ end
+ else
+ DUAL.puts Red+arrow+"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 Green+arrow+"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[: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.9.4 configurator"
+
+begin
+ $features.each {|feature| try feature }
+ensure
+ #!@#$ note: see END{} (duplication)
+ system "/bin/rm -f tmp/#{$$} tmp/#{$$}.c tmp/#{$$}.o tmp/#{$$}.asm"
+end
+
+puts Light
+
+$conf[:LDSOFLAGS].uniq!
+
+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
+
+if not $conf[:FEATURES][:puredata]
+ puts "PureData support is required (since GridFlow 0.9.0)"
+end
+
+#--------------------------------#
+
+LOG.puts "-"*64
+for z in [:LDSOFLAGS, :OPTIONS, :DEFINES, :OBJS] do
+ LOG.puts "#{z}: #{$conf[z].inspect}"
+end
+LOG.puts "-"*64
+RUBY = "$(RUBY_INSTALL_NAME)"
+
+puts "generating ./config.make"
+File.open("./config.make","w") {|f|
+ $CFLAGS += " -mcpu=$(CPU)" if $conf[:DEFINES][:CPU] and $conf[:DEFINES][:GCC_VERSION] < "4"
+ $CFLAGS += " -mtune=$(CPU)" if $conf[:DEFINES][:CPU] and $conf[:DEFINES][:GCC_VERSION] >= "4"
+ $CFLAGS += " -march=$(CPU)" if $conf[:DEFINES][:CPU]
+ $CFLAGS += " -DMACOSX" if OSX
+ f.puts "CFLAGS += " + $CFLAGS
+ f.puts "LDSOFLAGS += " + $conf[:LDSOFLAGS].flatten.join(" ")
+ for k in $conf[:OPTIONS] do f.puts "#{k}=yes" end
+ for k,v in $conf[:DEFINES] do f.puts "#{k}=#{v}" end
+ f.puts "CXX = #{$conf[:CC]}"
+ f.puts "OBJS = #{$conf[:OBJS].join(" ")}"
+ f.puts "DLEXT = #{CONFIG['DLEXT']}"
+ f.puts ""
+ if OSX then
+ f.puts "OS = darwin"
+ else
+ f.puts "OS = linux"
+ end
+} # 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|
+ oo = File.basename(o,'.o').split(/-/)[0]
+ "PRE startup_#{oo}();"
+}.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
+
+def include_here(f,a,b)
+ return unless $conf[:FEATURES][b]
+ f.puts "\#ifdef #{a}_INCLUDE_HERE"
+ for inc in $conf[:FEATURES][b].uses_h.to_a do
+ f.puts "\#include <#{inc}>"
+ end
+ f.puts "\#endif"
+end
+include_here f,"LIBMPEG", :mpeg3
+include_here f,"QUICKTIMEHW",:quicktimehw
+
+f.puts "
+\#endif /* __CONFIG_H */"
+} # end open config.h
+
+#--------------------------------#
+for s in [
+"See ./config.log if you want the details of the configuration tests.",
+"If you are satisfied with that configuration, you may go on,",
+"and do \"make\". \"make install\" is not needed anymore,",
+"just move your gridflow directory to \"lib/pd/extra\".",
+"If you get stuck, you could contact the author about it,",
+"but first make sure you read \"doc/install.html\". ",
+""] do puts "\e[1m#{s}\e[0m" end
+
+#--------------------------------#
+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 16:23:49 +0000