diff -Nru jalv-0~svn3409/AUTHORS jalv-1.0.0~dfsg0/AUTHORS --- jalv-0~svn3409/AUTHORS 2011-05-30 23:19:28.000000000 +0000 +++ jalv-1.0.0~dfsg0/AUTHORS 2012-04-09 19:21:18.000000000 +0000 @@ -1,8 +1,5 @@ Author: David Robillard -GTK2 GUI and I18N support: - Lars Luthman - -Dynamic manifest support: - Stefano D'Angelo +GTK2 Generic Plugin UI: + Nick Lanham diff -Nru jalv-0~svn3409/COPYING jalv-1.0.0~dfsg0/COPYING --- jalv-0~svn3409/COPYING 2011-05-30 23:19:28.000000000 +0000 +++ jalv-1.0.0~dfsg0/COPYING 2012-04-19 02:41:35.000000000 +0000 @@ -1,4 +1,4 @@ -Copyright 2011 David Robillard +Copyright 2011-2012 David Robillard Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -10,4 +10,4 @@ ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF -OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. \ No newline at end of file +OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. diff -Nru jalv-0~svn3409/debian/changelog jalv-1.0.0~dfsg0/debian/changelog --- jalv-0~svn3409/debian/changelog 2011-06-20 12:16:43.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/changelog 2012-07-12 21:52:01.000000000 +0000 @@ -1,3 +1,40 @@ +jalv (1.0.0~dfsg0-2~11.10) oneiric; urgency=medium + + * Import from debian wheezy. + + -- DNS777 Thu, 12 Jul 2012 15:00:00 +0000 + +jalv (1.0.0~dfsg0-2) unstable; urgency=low + + * Tolerate loading presets with port values that aren't xsd:decimal. + Patch taken from upstream trunk. + + -- Alessio Treglia Mon, 18 Jun 2012 12:44:03 +0200 + +jalv (1.0.0~dfsg0-1) unstable; urgency=low + + * New upstream release. + * Remove 0001-manpage.patch, adopted upstream. + * debian/control: + - Replace old LV2 build-deps with lv2-dev. + - Tighten build-dep on lilv, add build-dependencies on + libserd-dev and libsratom-dev. + - Add build-dependency on sord. + - Update Homepage. + * Add patch to fix jalv.gtk's manpage section mismatch. + * Update debian/watch. + * Update debian/copyright. + * Bump Standards. + + -- Alessio Treglia Mon, 21 May 2012 11:12:23 +0200 + +jalv (0~svn3409+dfsg0-1) unstable; urgency=low + + * Repack upstream tarball to get rid of the waf binary (Closes: #654478). + * Adjust the clean target to properly clean the sources. + + -- Alessio Treglia Tue, 10 Jan 2012 10:12:50 +0100 + jalv (0~svn3409-1) unstable; urgency=low * New upstream release: diff -Nru jalv-0~svn3409/debian/control jalv-1.0.0~dfsg0/debian/control --- jalv-0~svn3409/debian/control 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/control 2012-06-18 10:33:25.000000000 +0000 @@ -2,26 +2,31 @@ Section: sound Priority: optional Maintainer: Debian Multimedia Maintainers -Uploaders: Alessio Treglia -Build-Depends: debhelper (>= 7.0.50~), +Uploaders: + Alessio Treglia +Build-Depends: + debhelper (>= 7.0.50~), libgtk2.0-dev, libjack-dev, - liblilv-dev, + liblilv-dev (>= 0.14.0~), libqt4-dev, + libserd-dev, + libsord-dev, + libsratom-dev, libsuil-dev, - lv2core, - lv2-extensions-good, + lv2-dev, pkg-config, python -Standards-Version: 3.9.2 -Homepage: http://dev.drobilla.net/browser/trunk/jalv +Standards-Version: 3.9.3 +Homepage: http://drobilla.net/software/jalv/ Vcs-Git: git://git.debian.org/git/pkg-multimedia/jalv.git Vcs-Browser: http://git.debian.org/?p=pkg-multimedia/jalv.git Package: jalv Architecture: any -Depends: ${shlibs:Depends}, - ${misc:Depends} +Depends: + ${misc:Depends}, + ${shlibs:Depends} Description: tool to run LV2 plugins as stand-alone applications jalv is a stand-alone version of lv2jack that supports plugin UIs via libsuil. It allows one to run an LV2 plugin as a JACK application. diff -Nru jalv-0~svn3409/debian/copyright jalv-1.0.0~dfsg0/debian/copyright --- jalv-0~svn3409/debian/copyright 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/copyright 2012-05-21 09:10:27.000000000 +0000 @@ -1,20 +1,21 @@ -Format: http://svn.debian.org/wsvn/dep/web/deps/dep5.mdwn?op=file&rev=174 +Format: http://www.debian.org/doc/packaging-manuals/copyright-format/1.0/ Upstream-Name: Jalv Upstream-Contact: David Robillard -Source: http://svn.drobilla.net/lad/trunk/jalv/ -Copyright: 2011 David Robillard +Source: http://download.drobilla.net/ +Copyright: 2008-2012 David Robillard License: ISC Files: * -Copyright: 2007-2011 David Robillard +Copyright: 2008-2012 David Robillard License: ISC Files: waf -Copyright: 2005-2010 Thomas Nagy + waflib/* +Copyright: 2005-2011 Thomas Nagy License: BSD-3-clause Files: debian/* -Copyright: 2011 Alessio Treglia +Copyright: 2011-2012 Alessio Treglia License: ISC License: ISC diff -Nru jalv-0~svn3409/debian/patches/0001-manpage.patch jalv-1.0.0~dfsg0/debian/patches/0001-manpage.patch --- jalv-0~svn3409/debian/patches/0001-manpage.patch 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/patches/0001-manpage.patch 1970-01-01 00:00:00.000000000 +0000 @@ -1,18 +0,0 @@ -Description: Missing section in TH header. -Author: Alessio Treglia -Forwarded: no ---- - doc/jalv.1 | 2 +- - 1 file changed, 1 insertion(+), 1 deletion(-) - ---- jalv-0~svn3395.orig/doc/jalv.1 -+++ jalv-0~svn3395/doc/jalv.1 -@@ -1,7 +1,7 @@ - .\" First parameter, NAME, should be all caps - .\" Second parameter, SECTION, should be 1-8, maybe w/ subsection - .\" other parameters are allowed: see man(7), man(1) --.TH JALV "11 Jun 2009" -+.TH JALV 1 "11 Jun 2009" - .\" Please adjust this date whenever revising the manpage. - .\" - .\" Some roff macros, for reference: diff -Nru jalv-0~svn3409/debian/patches/0001-presets_with_non_decimal_ports.patch jalv-1.0.0~dfsg0/debian/patches/0001-presets_with_non_decimal_ports.patch --- jalv-0~svn3409/debian/patches/0001-presets_with_non_decimal_ports.patch 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/patches/0001-presets_with_non_decimal_ports.patch 2012-06-18 10:43:06.000000000 +0000 @@ -0,0 +1,34 @@ +Description: Tolerate loading presets with port values that aren't xsd:decimal +Origin: http://dev.drobilla.net/changeset/4499 +--- + src/state.c | 15 +++++++++++---- + 1 file changed, 11 insertions(+), 4 deletions(-) + +--- jalv.orig/src/state.c ++++ jalv/src/state.c +@@ -132,14 +132,21 @@ set_port_value(const char* port_symbol, + return; + } + +- if (type != jalv->forge.Float) { +- fprintf(stderr, "error: Preset port `%s' value is a <%s>, not float\n", ++ float fvalue; ++ if (type == jalv->forge.Float) { ++ fvalue = *(float*)value; ++ } else if (type == jalv->forge.Double) { ++ fvalue = *(double*)value; ++ } else if (type == jalv->forge.Int) { ++ fvalue = *(int32_t*)value; ++ } else if (type == jalv->forge.Long) { ++ fvalue = *(int64_t*)value; ++ } else { ++ fprintf(stderr, "error: Preset `%s' value has bad type <%s>\n", + port_symbol, jalv->unmap.unmap(jalv->unmap.handle, type)); + return; + } + +- const float fvalue = *(float*)value; +- + // Send value to plugin + jalv_ui_write(jalv, port->index, sizeof(fvalue), 0, &fvalue); + diff -Nru jalv-0~svn3409/debian/patches/1001-manpages.patch jalv-1.0.0~dfsg0/debian/patches/1001-manpages.patch --- jalv-0~svn3409/debian/patches/1001-manpages.patch 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/patches/1001-manpages.patch 2012-06-18 10:33:25.000000000 +0000 @@ -0,0 +1,15 @@ +Description: Fix manpage section mismatch. +Author: Alessio Treglia +Forwarded: no +--- + doc/jalv.gtk.1 | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +--- jalv.orig/doc/jalv.gtk.1 ++++ jalv/doc/jalv.gtk.1 +@@ -1,4 +1,4 @@ +-.TH JALV.GTK "19 Apr 2012" ++.TH JALV.GTK 1 "19 Apr 2012" + + .SH NAME + .B jalv.gtk \- Run an LV2 plugin as a JACK application (Gtk version). diff -Nru jalv-0~svn3409/debian/patches/series jalv-1.0.0~dfsg0/debian/patches/series --- jalv-0~svn3409/debian/patches/series 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/patches/series 2012-06-18 10:41:52.000000000 +0000 @@ -1 +1,2 @@ -0001-manpage.patch +0001-presets_with_non_decimal_ports.patch +1001-manpages.patch diff -Nru jalv-0~svn3409/debian/rules jalv-1.0.0~dfsg0/debian/rules --- jalv-0~svn3409/debian/rules 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/rules 2012-01-10 09:12:25.000000000 +0000 @@ -17,7 +17,8 @@ $(WAF) override_dh_auto_clean: - $(WAF) distclean + $(WAF) clean || true + find -name "*.pyc" -delete rm -rf build .waf* dh_auto_clean diff -Nru jalv-0~svn3409/debian/watch jalv-1.0.0~dfsg0/debian/watch --- jalv-0~svn3409/debian/watch 2011-06-14 10:09:29.000000000 +0000 +++ jalv-1.0.0~dfsg0/debian/watch 2012-05-05 00:37:22.000000000 +0000 @@ -1 +1,3 @@ -# Sources are taken from http://svn.drobilla.net/lad/trunk/jalv/ +version=3 +opts="uversionmangle=s/-/./,dversionmangle=s/~dfsg.*//" \ +http://download.drobilla.net/jalv-(.*)\.tar\.bz2 diff -Nru jalv-0~svn3409/doc/jalv.1 jalv-1.0.0~dfsg0/doc/jalv.1 --- jalv-0~svn3409/doc/jalv.1 2011-06-12 00:19:52.000000000 +0000 +++ jalv-1.0.0~dfsg0/doc/jalv.1 2012-04-19 22:12:47.000000000 +0000 @@ -1,26 +1,33 @@ -.\" First parameter, NAME, should be all caps -.\" Second parameter, SECTION, should be 1-8, maybe w/ subsection -.\" other parameters are allowed: see man(7), man(1) -.TH JALV "11 Jun 2009" -.\" Please adjust this date whenever revising the manpage. -.\" -.\" Some roff macros, for reference: -.\" .nh disable hyphenation -.\" .hy enable hyphenation -.\" .ad l left justify -.\" .ad b justify to both left and right margins -.\" .nf disable filling -.\" .fi enable filling -.\" .br insert line break -.\" .sp insert n+1 empty lines -.\" for manpage-specific macros, see man(7) +.TH JALV 1 "19 Apr 2012" + .SH NAME -.B jalv \- Run an LV2 plugin as a JACK application. +.B jalv \- Run an LV2 plugin as a JACK application (console version). .SH SYNOPSIS -.B jalv PLUGIN_URI +.B jalv [OPTION]... PLUGIN_URI + +.SH OPTIONS + +.TP +\fB\-h\fR, \fB\-\-help\fR +Print the command line options. + +.TP +\fB\-u UUID\fR, \fB\-\-uuid UUID\fR +UUID for Jack session restoration. + +.TP +\fB\-l DIR\fR, \fB\-\-load DIR\fR +Load state from state directory. + +.TP +\fB\-d\fR, \fB\-\-dump\fR +Dump plugin <=> UI communication. .SH SEE ALSO +.BR jalv.gtk(1), +.BR jalv.gtkmm(1), +.BR jalv.qt(2), .BR lv2ls(1), .BR jackd(1) diff -Nru jalv-0~svn3409/doc/jalv.gtk.1 jalv-1.0.0~dfsg0/doc/jalv.gtk.1 --- jalv-0~svn3409/doc/jalv.gtk.1 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/doc/jalv.gtk.1 2012-04-19 22:10:56.000000000 +0000 @@ -0,0 +1,42 @@ +.TH JALV.GTK "19 Apr 2012" + +.SH NAME +.B jalv.gtk \- Run an LV2 plugin as a JACK application (Gtk version). + +.SH SYNOPSIS +.B jalv.gtk [OPTION]... PLUGIN_URI + +.SH OPTIONS + +.TP +\fB\-h\fR, \fB\-\-help\fR +Print the command line options. + +.TP +\fB\-u UUID\fR, \fB\-\-uuid UUID\fR +UUID for Jack session restoration. + +.TP +\fB\-l DIR\fR, \fB\-\-load DIR\fR +Load state from state directory. + +.TP +\fB\-d\fR, \fB\-\-dump\fR +Dump plugin <=> UI communication. + +.TP +\fB\-g\fR, \fB\-\-generic\-ui\fR +Use Jalv generic UI and not the plugin UI + +.SH SEE ALSO +.BR jalv(1), +.BR jalv.gtkmm(1), +.BR jalv.qt(2), +.BR lv2ls(1), +.BR jackd(1) + +.SH AUTHOR +jalv was written by David Robillard +.PP +This manual page was written by Jaromír Mikes +and David Robillard diff -Nru jalv-0~svn3409/doc/jalv.gtkmm.1 jalv-1.0.0~dfsg0/doc/jalv.gtkmm.1 --- jalv-0~svn3409/doc/jalv.gtkmm.1 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/doc/jalv.gtkmm.1 2012-04-19 22:12:54.000000000 +0000 @@ -0,0 +1,25 @@ +.TH JALV.GTKMM 1 "19 Apr 2012" + +.SH NAME +.B jalv.gtkmm \- Run an LV2 plugin as a JACK application (Gtkmm version). + +.SH SYNOPSIS +.B jalv.gtkmm PLUGIN_URI + +.SH DESCRIPTION + +This is a versionm of Jalv with a GUI implemented in Gtkmm. It is mainly for +developer testing purposes, for a production ready program use jalv.gtk. + +.SH SEE ALSO +.BR jalv(1), +.BR jalv.gtk(1), +.BR jalv.qt(2), +.BR lv2ls(1), +.BR jackd(1) + +.SH AUTHOR +jalv was written by David Robillard +.PP +This manual page was written by Jaromír Mikes +and David Robillard diff -Nru jalv-0~svn3409/doc/jalv.qt.1 jalv-1.0.0~dfsg0/doc/jalv.qt.1 --- jalv-0~svn3409/doc/jalv.qt.1 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/doc/jalv.qt.1 2012-04-19 22:12:43.000000000 +0000 @@ -0,0 +1,25 @@ +.TH JALV.QT 1 "19 Apr 2012" + +.SH NAME +.B jalv.qt \- Run an LV2 plugin as a JACK application (Qt version). + +.SH SYNOPSIS +.B jalv.qt PLUGIN_URI + +.SH DESCRIPTION + +This is a versionm of Jalv with a GUI implemented in Qt. It is mainly for +developer testing purposes, for a production ready program use jalv.gtk. + +.SH SEE ALSO +.BR jalv(1), +.BR jalv.gtkmm(1), +.BR jalv.qt(2), +.BR lv2ls(1), +.BR jackd(1) + +.SH AUTHOR +jalv was written by David Robillard +.PP +This manual page was written by Jaromír Mikes +and David Robillard diff -Nru jalv-0~svn3409/NEWS jalv-1.0.0~dfsg0/NEWS --- jalv-0~svn3409/NEWS 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/NEWS 2012-04-19 22:22:38.000000000 +0000 @@ -0,0 +1,6 @@ +jalv (UNRELEASED) stable; + + * Initial release + + -- David Robillard UNRELEASED + diff -Nru jalv-0~svn3409/README jalv-1.0.0~dfsg0/README --- jalv-0~svn3409/README 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/README 2012-04-19 23:09:34.000000000 +0000 @@ -0,0 +1,14 @@ +Jalv +---- + +Jalv is a simple but fully featured LV2 host for Jack. It runs LV2 plugins and +exposes their ports as Jack ports, essentially making any LV2 plugin function +as a Jack application. + +Jalv is a small program which is useful, but also intended to be an appropriate +test host for plugin development. It runs plugins from the command line with +no user interaction, is light enough to run in valgrind, and is capable of +dumping all plugin to/from UI communication in a human readable format. + +To make it simple to test plugins in hosts that use different toolkits, there +are several Jalv executables: jalv, jalv.gtk, jalv.gtkmm, and jalv.qt. \ No newline at end of file diff -Nru jalv-0~svn3409/src/jalv.c jalv-1.0.0~dfsg0/src/jalv.c --- jalv-0~svn3409/src/jalv.c 2011-06-20 02:19:24.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv.c 2012-04-19 22:42:52.000000000 +0000 @@ -1,5 +1,5 @@ /* - Copyright 2007-2011 David Robillard + Copyright 2007-2012 David Robillard Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -14,17 +14,21 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#define _XOPEN_SOURCE 500 - +#define _POSIX_C_SOURCE 200809L /* for mkdtemp */ +#define _DARWIN_C_SOURCE /* for mkdtemp on OSX */ +#include #include #include #include #include #include #include +#include +#include +#include +#include "jalv_config.h" #include "jalv_internal.h" -#include "jalv-config.h" #include #include @@ -32,37 +36,41 @@ # include #endif -#include "lv2/lv2plug.in/ns/ext/event/event-helpers.h" +#include "lv2/lv2plug.in/ns/ext/atom/atom.h" #include "lv2/lv2plug.in/ns/ext/event/event.h" +#include "lv2/lv2plug.in/ns/ext/presets/presets.h" +#include "lv2/lv2plug.in/ns/ext/time/time.h" #include "lv2/lv2plug.in/ns/ext/uri-map/uri-map.h" +#include "lv2/lv2plug.in/ns/ext/urid/urid.h" +#include "lv2/lv2plug.in/ns/ext/worker/worker.h" +#include "lv2/lv2plug.in/ns/extensions/ui/ui.h" #include "lilv/lilv.h" #include "suil/suil.h" -sem_t exit_sem; /**< Exit semaphore */ +#include "lv2_evbuf.h" +#include "worker.h" -#define MIDI_BUFFER_SIZE 1024 +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" -typedef struct { - uint32_t index; - float value; -} ControlChange; - -enum PortType { - CONTROL, - AUDIO, - EVENT -}; +#define USTR(str) ((const uint8_t*)str) -struct Port { - const LilvPort* lilv_port; - enum PortType type; - jack_port_t* jack_port; /**< For audio/MIDI ports, otherwise NULL */ - float control; /**< For control ports, otherwise 0.0f */ - LV2_Event_Buffer* ev_buffer; /**< For MIDI ports, otherwise NULL */ - bool is_input; -}; +ZixSem exit_sem; /**< Exit semaphore */ + +LV2_URID +map_uri(LV2_URID_Map_Handle handle, + const char* uri) +{ + return symap_map(((Jalv*)handle)->symap, uri); +} + +const char* +unmap_uri(LV2_URID_Unmap_Handle handle, + LV2_URID urid) +{ + return symap_unmap(((Jalv*)handle)->symap, urid); +} /** Map function for URI map extension. @@ -72,18 +80,28 @@ const char* map, const char* uri) { - Jalv* host = (Jalv*)callback_data; - return symap_map(host->symap, uri); + return symap_map(((Jalv*)callback_data)->symap, uri); } #define NS_EXT "http://lv2plug.in/ns/ext/" -static LV2_URI_Map_Feature uri_map = { NULL, &uri_to_id }; -static const LV2_Feature uri_map_feature = { NS_EXT "uri-map", &uri_map }; -static LV2_Feature instance_feature = { NS_EXT "instance-access", NULL }; +static LV2_URI_Map_Feature uri_map = { NULL, &uri_to_id }; -const LV2_Feature* features[3] = { - &uri_map_feature, &instance_feature, NULL +static LV2_Feature uri_map_feature = { NS_EXT "uri-map", &uri_map }; +static LV2_Feature map_feature = { NS_EXT "urid#map", NULL }; +static LV2_Feature unmap_feature = { NS_EXT "urid#unmap", NULL }; +static LV2_Feature instance_feature = { NS_EXT "instance-access", NULL }; +static LV2_Feature make_path_feature = { LV2_STATE__makePath, NULL }; +static LV2_Feature schedule_feature = { LV2_WORKER__schedule, NULL }; +static LV2_Feature log_feature = { LV2_LOG__log, NULL }; + +const LV2_Feature* features[9] = { + &uri_map_feature, &map_feature, &unmap_feature, + &instance_feature, + &make_path_feature, + &schedule_feature, + &log_feature, + NULL }; /** Abort and exit on error */ @@ -94,13 +112,11 @@ exit(EXIT_FAILURE); } -/** Creates a port and connects the plugin instance to its data location. - * - * For audio ports, creates a jack port and connects plugin port to buffer. - * - * For control ports, sets controls array to default value and connects plugin - * port to that element. - */ +/** + Create a port structure from data description. This is called before plugin + and Jack instantiation. The remaining instance-specific setup + (e.g. buffers) is done later in expose_port(). +*/ void create_port(Jalv* host, uint32_t port_index, @@ -110,157 +126,376 @@ port->lilv_port = lilv_plugin_get_port_by_index(host->plugin, port_index); port->jack_port = NULL; + port->evbuf = NULL; + port->index = port_index; port->control = 0.0f; - port->ev_buffer = NULL; - - lilv_instance_connect_port(host->instance, port_index, NULL); + port->flow = FLOW_UNKNOWN; /* Get the port symbol for console printing */ - const LilvNode* symbol = lilv_port_get_symbol(host->plugin, port->lilv_port); - const char* symbol_str = lilv_node_as_string(symbol); + const LilvNode* symbol = lilv_port_get_symbol(host->plugin, + port->lilv_port); const bool optional = lilv_port_has_property(host->plugin, port->lilv_port, - host->optional); + host->nodes.lv2_connectionOptional); - enum JackPortFlags jack_flags = 0; - if (lilv_port_is_a(host->plugin, port->lilv_port, host->input_class)) { - jack_flags = JackPortIsInput; - port->is_input = true; - } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->output_class)) { - jack_flags = JackPortIsOutput; - port->is_input = false; - } else if (optional) { - lilv_instance_connect_port(host->instance, port_index, NULL); - return; - } else { + /* Set the port flow (input or output) */ + if (lilv_port_is_a(host->plugin, port->lilv_port, host->nodes.lv2_InputPort)) { + port->flow = FLOW_INPUT; + } else if (lilv_port_is_a(host->plugin, port->lilv_port, + host->nodes.lv2_OutputPort)) { + port->flow = FLOW_OUTPUT; + } else if (!optional) { die("Mandatory port has unknown type (neither input nor output)"); } /* Set control values */ - if (lilv_port_is_a(host->plugin, port->lilv_port, host->control_class)) { - port->type = CONTROL; + if (lilv_port_is_a(host->plugin, port->lilv_port, host->nodes.lv2_ControlPort)) { + port->type = TYPE_CONTROL; port->control = isnan(default_value) ? 0.0 : default_value; - printf("%s = %f\n", symbol_str, host->ports[port_index].control); - } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->audio_class)) { - port->type = AUDIO; - } else if (lilv_port_is_a(host->plugin, port->lilv_port, host->event_class)) { - port->type = EVENT; - } else if (optional) { + } else if (lilv_port_is_a(host->plugin, port->lilv_port, + host->nodes.lv2_AudioPort)) { + port->type = TYPE_AUDIO; + } else if (lilv_port_is_a(host->plugin, port->lilv_port, + host->nodes.ev_EventPort)) { + port->type = TYPE_EVENT; + port->old_api = true; + } else if (lilv_port_is_a(host->plugin, port->lilv_port, + host->nodes.atom_AtomPort)) { + port->type = TYPE_EVENT; + port->old_api = false; + } else if (!optional) { + die("Mandatory port has unknown data type"); + } + + const size_t sym_len = strlen(lilv_node_as_string(symbol)); + if (sym_len > host->longest_sym) { + host->longest_sym = sym_len; + } +} + +/** + Create port structures from data (via create_port()) for all ports. +*/ +void +jalv_create_ports(Jalv* jalv) +{ + jalv->num_ports = lilv_plugin_get_num_ports(jalv->plugin); + jalv->ports = calloc((size_t)jalv->num_ports, sizeof(struct Port)); + float* default_values = calloc(lilv_plugin_get_num_ports(jalv->plugin), + sizeof(float)); + lilv_plugin_get_port_ranges_float(jalv->plugin, NULL, NULL, default_values); + + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + create_port(jalv, i, default_values[i]); + } + + free(default_values); +} + +/** + Allocate port buffers (only necessary for MIDI). +*/ +void +jalv_allocate_port_buffers(Jalv* jalv) +{ + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + struct Port* const port = &jalv->ports[i]; + switch (port->type) { + case TYPE_EVENT: + lv2_evbuf_free(port->evbuf); + port->evbuf = lv2_evbuf_new( + jalv->midi_buf_size, + port->old_api ? LV2_EVBUF_EVENT : LV2_EVBUF_ATOM, + jalv->map.map(jalv->map.handle, + lilv_node_as_string(jalv->nodes.atom_Chunk)), + jalv->map.map(jalv->map.handle, + lilv_node_as_string(jalv->nodes.atom_Sequence))); + lilv_instance_connect_port( + jalv->instance, i, lv2_evbuf_get_buffer(port->evbuf)); + default: break; + } + } +} + +/** + Get a port structure by symbol. + + TODO: Build an index to make this faster, currently O(n) which may be + a problem when restoring the state of plugins with many ports. +*/ +struct Port* +jalv_port_by_symbol(Jalv* jalv, const char* sym) +{ + for (uint32_t i = 0; i < jalv->num_ports; ++i) { + struct Port* const port = &jalv->ports[i]; + const LilvNode* port_sym = lilv_port_get_symbol(jalv->plugin, + port->lilv_port); + + if (!strcmp(lilv_node_as_string(port_sym), sym)) { + return port; + } + } + + return NULL; +} + +/** + Expose a port to Jack (if applicable) and connect it to its buffer. +*/ +void +activate_port(Jalv* host, + uint32_t port_index) +{ + struct Port* const port = &host->ports[port_index]; + + /* Get the port symbol for console printing */ + const LilvNode* symbol = lilv_port_get_symbol(host->plugin, + port->lilv_port); + const char* symbol_str = lilv_node_as_string(symbol); + + /* Connect unsupported ports to NULL (known to be optional by this point) */ + if (port->flow == FLOW_UNKNOWN || port->type == TYPE_UNKNOWN) { lilv_instance_connect_port(host->instance, port_index, NULL); return; - } else { - die("Mandatory port has unknown type (neither control nor audio nor event)"); } + /* Build Jack flags for port */ + enum JackPortFlags jack_flags = (port->flow == FLOW_INPUT) + ? JackPortIsInput + : JackPortIsOutput; + /* Connect the port based on its type */ switch (port->type) { - case CONTROL: + case TYPE_CONTROL: + printf("%-*s = %f\n", host->longest_sym, symbol_str, + host->ports[port_index].control); lilv_instance_connect_port(host->instance, port_index, &port->control); break; - case AUDIO: + case TYPE_AUDIO: port->jack_port = jack_port_register( - host->jack_client, symbol_str, JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0); + host->jack_client, symbol_str, + JACK_DEFAULT_AUDIO_TYPE, jack_flags, 0); break; - case EVENT: + case TYPE_EVENT: port->jack_port = jack_port_register( - host->jack_client, symbol_str, JACK_DEFAULT_MIDI_TYPE, jack_flags, 0); - port->ev_buffer = lv2_event_buffer_new(MIDI_BUFFER_SIZE, LV2_EVENT_AUDIO_STAMP); - lilv_instance_connect_port(host->instance, port_index, port->ev_buffer); + host->jack_client, symbol_str, + JACK_DEFAULT_MIDI_TYPE, jack_flags, 0); break; default: break; } } +/** Jack buffer size callback. */ +int +jack_buffer_size_cb(jack_nframes_t nframes, void* data) +{ + Jalv* const host = (Jalv*)data; + host->buf_size_set = true; +#ifdef jack_port_type_get_buffer_size + host->midi_buf_size = jack_port_type_get_buffer_size( + host->jack_client, JACK_DEFAULT_MIDI_TYPE); +#endif + jalv_allocate_port_buffers(host); + return 0; +} + /** Jack process callback. */ int jack_process_cb(jack_nframes_t nframes, void* data) { Jalv* const host = (Jalv*)data; +#if 0 + jack_position_t pos; + double speed = 0.0; + if (jack_transport_query(host->jack_client, &pos) == JackTransportRolling) { + speed = 1.0; + } + + if (pos.valid & JackPositionBBT) { + uint8_t buf[1024]; + lv2_atom_forge_set_buffer(&host->forge, buf, sizeof(buf)); + LV2_Atom_Forge* forge = &host->forge; + LV2_Atom_Forge_Frame frame; + lv2_atom_forge_blank(forge, &frame, 1, host->urids.time_Position); + lv2_atom_forge_property_head(forge, host->urids.time_barBeat, 0); + lv2_atom_forge_float(forge, pos.beat - 1 + (pos.tick / (float)pos.ticks_per_beat)); + lv2_atom_forge_property_head(forge, host->urids.time_bar, 0); + lv2_atom_forge_float(forge, pos.bar - 1); + lv2_atom_forge_property_head(forge, host->urids.time_beatUnit, 0); + lv2_atom_forge_float(forge, pos.beat_type); + lv2_atom_forge_property_head(forge, host->urids.time_beatsPerBar, 0); + lv2_atom_forge_float(forge, pos.beats_per_bar); + lv2_atom_forge_property_head(forge, host->urids.time_beatsPerMinute, 0); + lv2_atom_forge_float(forge, pos.beats_per_minute); + lv2_atom_forge_property_head(forge, host->urids.time_frame, 0); + lv2_atom_forge_int64(forge, pos.frame); + lv2_atom_forge_property_head(forge, host->urids.time_speed, 0); + lv2_atom_forge_float(forge, speed); + + SerdNode s = serd_node_from_string(SERD_BLANK, USTR("pos")); + SerdNode p = serd_node_from_string(SERD_URI, USTR(NS_RDF "value")); + char* str = atom_to_turtle(&host->unmap, &s, &p, (LV2_Atom*)frame.ref); + printf("\n## Position\n%s\n", str); + free(str); + } +#endif + + switch (host->play_state) { + case JALV_PAUSE_REQUESTED: + host->play_state = JALV_PAUSED; + zix_sem_post(&host->paused); + break; + case JALV_PAUSED: + for (uint32_t p = 0; p < host->num_ports; ++p) { + jack_port_t* jport = host->ports[p].jack_port; + if (jport && host->ports[p].flow == FLOW_OUTPUT) { + void* buf = jack_port_get_buffer(jport, nframes); + if (host->ports[p].type == TYPE_EVENT) { + jack_midi_clear_buffer(buf); + } else { + memset(buf, '\0', nframes * sizeof(float)); + } + } + } + return 0; + default: + break; + } + /* Prepare port buffers */ for (uint32_t p = 0; p < host->num_ports; ++p) { if (!host->ports[p].jack_port) continue; - if (host->ports[p].type == AUDIO) { + if (host->ports[p].type == TYPE_AUDIO) { /* Connect plugin port directly to Jack port buffer. */ lilv_instance_connect_port( host->instance, p, jack_port_get_buffer(host->ports[p].jack_port, nframes)); - } else if (host->ports[p].type == EVENT) { - /* Clear Jack event port buffer. */ - lv2_event_buffer_reset(host->ports[p].ev_buffer, - LV2_EVENT_AUDIO_STAMP, - (uint8_t*)(host->ports[p].ev_buffer + 1)); + } else if (host->ports[p].type == TYPE_EVENT) { + /* Prepare event ports. */ + if (host->ports[p].flow == FLOW_INPUT) { + lv2_evbuf_reset(host->ports[p].evbuf, true); - if (host->ports[p].is_input) { void* buf = jack_port_get_buffer(host->ports[p].jack_port, nframes); - LV2_Event_Iterator iter; - lv2_event_begin(&iter, host->ports[p].ev_buffer); - + LV2_Evbuf_Iterator iter = lv2_evbuf_begin(host->ports[p].evbuf); for (uint32_t i = 0; i < jack_midi_get_event_count(buf); ++i) { jack_midi_event_t ev; jack_midi_event_get(&ev, buf, i); - lv2_event_write(&iter, + lv2_evbuf_write(&iter, ev.time, 0, host->midi_event_id, ev.size, ev.buffer); } + } else { + lv2_evbuf_reset(host->ports[p].evbuf, false); } } } /* Read and apply control change events from UI */ - if (host->ui) { + if (host->has_ui) { ControlChange ev; - size_t ev_read_size = jack_ringbuffer_read_space(host->ui_events); - for (size_t i = 0; i < ev_read_size; i += sizeof(ev)) { + const size_t space = jack_ringbuffer_read_space(host->ui_events); + for (size_t i = 0; i < space; i += sizeof(ev) + ev.size) { jack_ringbuffer_read(host->ui_events, (char*)&ev, sizeof(ev)); - host->ports[ev.index].control = ev.value; + char body[ev.size]; + if (jack_ringbuffer_read(host->ui_events, body, ev.size) != ev.size) { + fprintf(stderr, "error: Error reading from UI ring buffer\n"); + break; + } + assert(ev.index < host->num_ports); + struct Port* const port = &host->ports[ev.index]; + if (ev.protocol == 0) { + assert(ev.size == sizeof(float)); + port->control = *(float*)body; + } else if (ev.protocol == host->urids.atom_eventTransfer) { + LV2_Evbuf_Iterator i = lv2_evbuf_end(port->evbuf); + const LV2_Atom* const atom = (const LV2_Atom*)body; + lv2_evbuf_write(&i, nframes, 0, + atom->type, atom->size, LV2_ATOM_BODY(atom)); + } else { + fprintf(stderr, "error: Unknown control change protocol %d\n", + ev.protocol); + } } } /* Run plugin for this cycle */ lilv_instance_run(host->instance, nframes); + /* Process any replies from the worker. */ + jalv_worker_emit_responses(host, &host->worker); + + /* Notify the plugin the run() cycle is finished */ + if (host->worker.iface && host->worker.iface->end_run) { + host->worker.iface->end_run(host->instance->lv2_handle); + } + /* Check if it's time to send updates to the UI */ host->event_delta_t += nframes; - bool send_ui_updates = false; - if (host->ui && (host->event_delta_t > host->sample_rate / JALV_UI_UPDATE_HZ)) { + bool send_ui_updates = false; + jack_nframes_t update_frames = host->sample_rate / JALV_UI_UPDATE_HZ; + if (host->has_ui && (host->event_delta_t > update_frames)) { send_ui_updates = true; host->event_delta_t = 0; } /* Deliver MIDI output and UI events */ for (uint32_t p = 0; p < host->num_ports; ++p) { - if (host->ports[p].jack_port - && !host->ports[p].is_input - && host->ports[p].type == EVENT) { - - void* buf = jack_port_get_buffer(host->ports[p].jack_port, - nframes); - + struct Port* const port = &host->ports[p]; + if (port->jack_port && port->flow == FLOW_OUTPUT + && port->type == TYPE_EVENT) { + void* buf = jack_port_get_buffer(port->jack_port, nframes); jack_midi_clear_buffer(buf); - LV2_Event_Iterator iter; - lv2_event_begin(&iter, host->ports[p].ev_buffer); + for (LV2_Evbuf_Iterator i = lv2_evbuf_begin(port->evbuf); + lv2_evbuf_is_valid(i); + i = lv2_evbuf_next(i)) { + uint32_t frames, subframes, type, size; + uint8_t* data; + lv2_evbuf_get(i, &frames, &subframes, &type, &size, &data); + if (type == host->midi_event_id) { + jack_midi_event_write(buf, frames, data, size); + } else { + fprintf(stderr, "Non-MIDI event output type %d\n", type); + } - for (uint32_t i = 0; i < iter.buf->event_count; ++i) { - uint8_t* data; - LV2_Event* ev = lv2_event_get(&iter, &data); - jack_midi_event_write(buf, ev->frames, data, ev->size); - lv2_event_increment(&iter); + /* TODO: Be more disciminate about what to send */ + if (!port->old_api) { + char buf[sizeof(ControlChange) + sizeof(LV2_Atom)]; + ControlChange* ev = (ControlChange*)buf; + ev->index = p; + ev->protocol = host->urids.atom_eventTransfer; + ev->size = sizeof(LV2_Atom) + size; + LV2_Atom* atom = (LV2_Atom*)ev->body; + atom->type = type; + atom->size = size; + if (jack_ringbuffer_write_space(host->plugin_events) + < sizeof(buf) + size) { + break; + } + jack_ringbuffer_write(host->plugin_events, buf, sizeof(buf)); + /* TODO: race, ensure reader handles this correctly */ + jack_ringbuffer_write(host->plugin_events, (void*)data, size); + } } } else if (send_ui_updates - && !host->ports[p].is_input - && host->ports[p].type == CONTROL) { - const ControlChange ev = { p, host->ports[p].control }; - jack_ringbuffer_write(host->plugin_events, (const char*)&ev, sizeof(ev)); + && port->flow != FLOW_INPUT + && port->type == TYPE_CONTROL) { + char buf[sizeof(ControlChange) + sizeof(float)]; + ControlChange* ev = (ControlChange*)buf; + ev->index = p; + ev->protocol = 0; + ev->size = sizeof(float); + *(float*)ev->body = port->control; + jack_ringbuffer_write(host->plugin_events, buf, sizeof(buf)); } } @@ -273,54 +508,125 @@ { Jalv* host = (Jalv*)arg; - char cmd[256]; - snprintf(cmd, sizeof(cmd), "jalv %s %s", - lilv_node_as_uri(lilv_plugin_get_uri(host->plugin)), - event->client_uuid); - - event->command_line = strdup(cmd); - jack_session_reply(host->jack_client, event); + #define MAX_CMD_LEN 256 + event->command_line = malloc(MAX_CMD_LEN); + snprintf(event->command_line, MAX_CMD_LEN, "%s -u %s -l '%s'", + host->prog_name, + event->client_uuid, + event->session_dir); switch (event->type) { case JackSessionSave: + case JackSessionSaveTemplate: + jalv_save(host, event->session_dir); break; case JackSessionSaveAndQuit: - sem_post(&exit_sem); - break; - case JackSessionSaveTemplate: + jalv_save(host, event->session_dir); + zix_sem_post(&exit_sem); break; } + jack_session_reply(host->jack_client, event); jack_session_event_free(event); } #endif /* JALV_JACK_SESSION */ -static void -lv2_ui_write(SuilController controller, - uint32_t port_index, - uint32_t buffer_size, - uint32_t format, - const void* buffer) +bool +jalv_ui_is_resizable(Jalv* jalv) { - if (format != 0) { - return; + if (!jalv->ui) { + return false; } + const LilvNode* s = lilv_ui_get_uri(jalv->ui); + LilvNode* p = lilv_new_uri(jalv->world, LV2_CORE__optionalFeature); + LilvNode* fs = lilv_new_uri(jalv->world, LV2_UI__fixedSize); + LilvNode* nrs = lilv_new_uri(jalv->world, LV2_UI__noUserResize); + + LilvNodes* fs_matches = lilv_world_find_nodes(jalv->world, s, p, fs); + LilvNodes* nrs_matches = lilv_world_find_nodes(jalv->world, s, p, nrs); + + lilv_nodes_free(nrs_matches); + lilv_nodes_free(fs_matches); + lilv_node_free(nrs); + lilv_node_free(fs); + lilv_node_free(p); + + return !fs_matches && !nrs_matches; +} + +void +jalv_ui_write(SuilController controller, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer) +{ Jalv* host = (Jalv*)controller; + if (!host->has_ui) { + return; + } + + if (protocol != 0 && protocol != host->urids.atom_eventTransfer) { + fprintf(stderr, "UI write with unsupported protocol %d (%s)\n", + protocol, symap_unmap(host->symap, protocol)); + return; + } + + if (port_index >= host->num_ports) { + fprintf(stderr, "UI write to out of range port index %d\n", + port_index); + return; + } - const ControlChange ev = { port_index, *(float*)buffer }; - jack_ringbuffer_write(host->ui_events, (const char*)&ev, sizeof(ev)); + if (host->opts.dump && protocol == host->urids.atom_eventTransfer) { + SerdNode s = serd_node_from_string(SERD_BLANK, USTR("msg")); + SerdNode p = serd_node_from_string(SERD_URI, USTR(NS_RDF "value")); + + const LV2_Atom* atom = (const LV2_Atom*)buffer; + char* str = sratom_to_turtle( + host->sratom, &host->unmap, "jalv:", &s, &p, + atom->type, atom->size, LV2_ATOM_BODY(atom)); + printf("\n## UI => Plugin (%u bytes) ##\n%s\n", atom->size, str); + free(str); + } + + char buf[sizeof(ControlChange) + buffer_size]; + ControlChange* ev = (ControlChange*)buf; + ev->index = port_index; + ev->protocol = protocol; + ev->size = buffer_size; + memcpy(ev->body, buffer, buffer_size); + jack_ringbuffer_write(host->ui_events, buf, sizeof(buf)); } bool jalv_emit_ui_events(Jalv* host) { ControlChange ev; - size_t ev_read_size = jack_ringbuffer_read_space(host->plugin_events); - for (size_t i = 0; i < ev_read_size; i += sizeof(ev)) { + const size_t space = jack_ringbuffer_read_space(host->plugin_events); + for (size_t i = 0; i < space; i += sizeof(ev) + ev.size) { jack_ringbuffer_read(host->plugin_events, (char*)&ev, sizeof(ev)); - suil_instance_port_event(host->ui_instance, ev.index, - sizeof(float), 0, &ev.value); + char buf[ev.size]; + jack_ringbuffer_read(host->plugin_events, buf, ev.size); + + if (host->opts.dump && ev.protocol == host->urids.atom_eventTransfer) { + SerdNode s = serd_node_from_string(SERD_BLANK, USTR("msg")); + SerdNode p = serd_node_from_string(SERD_URI, USTR(NS_RDF "value")); + LV2_Atom* atom = (LV2_Atom*)buf; + char* str = sratom_to_turtle( + host->sratom, &host->unmap, "jalv:", &s, &p, + atom->type, atom->size, LV2_ATOM_BODY(atom)); + printf("\n## Plugin => UI (%u bytes) ##\n%s\n", atom->size, str); + free(str); + } + + if (host->ui_instance) { + suil_instance_port_event(host->ui_instance, ev.index, + ev.size, ev.protocol, buf); + } else { + jalv_ui_port_event(host, ev.index, ev.size, ev.protocol, buf); + } } return true; @@ -329,31 +635,75 @@ static void signal_handler(int ignored) { - sem_post(&exit_sem); + zix_sem_post(&exit_sem); } int main(int argc, char** argv) { - jalv_init(&argc, &argv); - Jalv host; - host.jack_client = NULL; - host.num_ports = 0; - host.ports = NULL; - host.ui_events = NULL; - host.plugin_events = NULL; - host.event_delta_t = 0; + memset(&host, '\0', sizeof(Jalv)); + host.prog_name = argv[0]; + host.midi_buf_size = 1024; // Should be set by jack_buffer_size_cb + host.play_state = JALV_PAUSED; + + if (jalv_init(&argc, &argv, &host.opts)) { + return EXIT_FAILURE; + } + + if (host.opts.uuid) { + printf("UUID: %s\n", host.opts.uuid); + } host.symap = symap_new(); uri_map.callback_data = &host; - host.midi_event_id = uri_to_id(&host, - "http://lv2plug.in/ns/ext/event", - "http://lv2plug.in/ns/ext/midi#MidiEvent"); - sem_init(&exit_sem, 0, 0); + host.map.handle = &host; + host.map.map = map_uri; + map_feature.data = &host.map; + + host.unmap.handle = &host; + host.unmap.unmap = unmap_uri; + unmap_feature.data = &host.unmap; + + lv2_atom_forge_init(&host.forge, &host.map); + + host.sratom = sratom_new(&host.map); + + host.midi_event_id = uri_to_id( + &host, "http://lv2plug.in/ns/ext/event", LV2_MIDI__MidiEvent); + + host.urids.atom_eventTransfer = symap_map(host.symap, LV2_ATOM__eventTransfer); + host.urids.log_Trace = symap_map(host.symap, LV2_LOG__Trace); + host.urids.midi_MidiEvent = symap_map(host.symap, LV2_MIDI__MidiEvent); + host.urids.time_Position = symap_map(host.symap, LV2_TIME__Position); + host.urids.time_bar = symap_map(host.symap, LV2_TIME__bar); + host.urids.time_barBeat = symap_map(host.symap, LV2_TIME__barBeat); + host.urids.time_beatUnit = symap_map(host.symap, LV2_TIME__beatUnit); + host.urids.time_beatsPerBar = symap_map(host.symap, LV2_TIME__beatsPerBar); + host.urids.time_beatsPerMinute = symap_map(host.symap, LV2_TIME__beatsPerMinute); + host.urids.time_frame = symap_map(host.symap, LV2_TIME__frame); + host.urids.time_speed = symap_map(host.symap, LV2_TIME__speed); + + char* template = jalv_strdup("/tmp/jalv-XXXXXX"); + host.temp_dir = jalv_strjoin(mkdtemp(template), "/"); + free(template); + + LV2_State_Make_Path make_path = { &host, jalv_make_path }; + make_path_feature.data = &make_path; + + LV2_Worker_Schedule schedule = { &host, jalv_worker_schedule }; + schedule_feature.data = &schedule; + + LV2_Log_Log log = { &host, jalv_printf, jalv_vprintf }; + log_feature.data = &log; + + zix_sem_init(&exit_sem, 0); host.done = &exit_sem; + zix_sem_init(&host.paused, 0); + zix_sem_init(&host.worker.sem, 0); + signal(SIGINT, signal_handler); signal(SIGTERM, signal_handler); @@ -363,37 +713,54 @@ host.world = world; const LilvPlugins* plugins = lilv_world_get_all_plugins(world); - /* Set up the port classes this app supports */ - host.input_class = lilv_new_uri(world, LILV_URI_INPUT_PORT); - host.output_class = lilv_new_uri(world, LILV_URI_OUTPUT_PORT); - host.control_class = lilv_new_uri(world, LILV_URI_CONTROL_PORT); - host.audio_class = lilv_new_uri(world, LILV_URI_AUDIO_PORT); - host.event_class = lilv_new_uri(world, LILV_URI_EVENT_PORT); - host.midi_class = lilv_new_uri(world, LILV_URI_MIDI_EVENT); - host.optional = lilv_new_uri(world, LILV_NS_LV2 - "connectionOptional"); - -#ifdef JALV_JACK_SESSION - if (argc != 2 && argc != 3) { - fprintf(stderr, "Usage: %s PLUGIN_URI [JACK_UUID]\n", argv[0]); -#else - if (argc != 2) { - fprintf(stderr, "Usage: %s PLUGIN_URI\n", argv[0]); -#endif - lilv_world_free(world); + /* Cache URIs for concepts we'll use */ + host.nodes.atom_AtomPort = lilv_new_uri(world, LV2_ATOM__AtomPort); + host.nodes.atom_Chunk = lilv_new_uri(world, LV2_ATOM__Chunk); + host.nodes.atom_Sequence = lilv_new_uri(world, LV2_ATOM__Sequence); + host.nodes.ev_EventPort = lilv_new_uri(world, LV2_EVENT__EventPort); + host.nodes.lv2_AudioPort = lilv_new_uri(world, LV2_CORE__AudioPort); + host.nodes.lv2_ControlPort = lilv_new_uri(world, LV2_CORE__ControlPort); + host.nodes.lv2_InputPort = lilv_new_uri(world, LV2_CORE__InputPort); + host.nodes.lv2_OutputPort = lilv_new_uri(world, LV2_CORE__OutputPort); + host.nodes.lv2_connectionOptional = lilv_new_uri(world, LV2_CORE__connectionOptional); + host.nodes.midi_MidiEvent = lilv_new_uri(world, LV2_MIDI__MidiEvent); + host.nodes.pset_Preset = lilv_new_uri(world, LV2_PRESETS__Preset); + host.nodes.rdfs_label = lilv_new_uri(world, LILV_NS_RDFS "label"); + host.nodes.work_interface = lilv_new_uri(world, LV2_WORKER__interface); + host.nodes.work_schedule = lilv_new_uri(world, LV2_WORKER__schedule); + + /* Get plugin URI from loaded state or command line */ + LilvState* state = NULL; + LilvNode* plugin_uri = NULL; + if (host.opts.load) { + struct stat info; + stat(host.opts.load, &info); + if (S_ISDIR(info.st_mode)) { + char* path = jalv_strjoin(host.opts.load, "/state.ttl"); + state = lilv_state_new_from_file(host.world, &host.map, NULL, path); + free(path); + } else { + state = lilv_state_new_from_file(host.world, &host.map, NULL, + host.opts.load); + } + if (!state) { + fprintf(stderr, "Failed to load state from %s\n", host.opts.load); + return EXIT_FAILURE; + } + plugin_uri = lilv_node_duplicate(lilv_state_get_plugin_uri(state)); + } else if (argc > 1) { + plugin_uri = lilv_new_uri(world, argv[1]); + } else { + fprintf(stderr, "Missing plugin URI parameter\n"); return EXIT_FAILURE; } - const char* const plugin_uri_str = argv[1]; - - printf("Plugin: %s\n", plugin_uri_str); - - /* Get the plugin */ - LilvNode* plugin_uri = lilv_new_uri(world, plugin_uri_str); + /* Find plugin */ + printf("Plugin: %s\n", lilv_node_as_string(plugin_uri)); host.plugin = lilv_plugins_get_by_uri(plugins, plugin_uri); lilv_node_free(plugin_uri); if (!host.plugin) { - fprintf(stderr, "Failed to find plugin %s.\n", plugin_uri_str); + fprintf(stderr, "Failed to find plugin\n"); lilv_world_free(world); return EXIT_FAILURE; } @@ -402,14 +769,12 @@ LilvNode* native_ui_type = jalv_native_ui_type(&host); const LilvNode* ui_type = NULL; host.ui = NULL; - if (native_ui_type) { - LilvUIs* uis = lilv_plugin_get_uis(host.plugin); // FIXME: leak - LILV_FOREACH(uis, u, uis) { - const LilvUI* this_ui = lilv_uis_get(uis, u); - if (lilv_ui_is_supported(this_ui, - suil_ui_supported, - native_ui_type, - &ui_type)) { + if (!host.opts.generic_ui && native_ui_type) { + host.uis = lilv_plugin_get_uis(host.plugin); + LILV_FOREACH(uis, u, host.uis) { + const LilvUI* this_ui = lilv_uis_get(host.uis, u); + if (lilv_ui_is_supported( + this_ui, suil_ui_supported, native_ui_type, &ui_type)) { // TODO: Multiple UI support host.ui = this_ui; break; @@ -417,18 +782,22 @@ } } + /* Create ringbuffers for UI if necessary */ if (host.ui) { - fprintf(stderr, "UI: %s\n", + fprintf(stderr, "UI: %s\n", lilv_node_as_uri(lilv_ui_get_uri(host.ui))); - - host.ui_events = jack_ringbuffer_create(4096); - host.plugin_events = jack_ringbuffer_create(4096); - jack_ringbuffer_mlock(host.ui_events); - jack_ringbuffer_mlock(host.plugin_events); } else { fprintf(stderr, "No appropriate UI found\n"); } + host.ui_events = jack_ringbuffer_create(4096); + host.plugin_events = jack_ringbuffer_create(4096); + jack_ringbuffer_mlock(host.ui_events); + jack_ringbuffer_mlock(host.plugin_events); + + /* Create port structures (host.ports) */ + jalv_create_ports(&host); + /* Get the plugin's name */ LilvNode* name = lilv_plugin_get_name(host.plugin); const char* name_str = lilv_node_as_string(name); @@ -436,19 +805,18 @@ /* Truncate plugin name to suit JACK (if necessary) */ char* jack_name = NULL; if (strlen(name_str) >= (unsigned)jack_client_name_size() - 1) { - jack_name = calloc(jack_client_name_size(), sizeof(char)); + jack_name = calloc(jack_client_name_size(), 1); strncpy(jack_name, name_str, jack_client_name_size() - 1); } else { - jack_name = strdup(name_str); + jack_name = jalv_strdup(name_str); } /* Connect to JACK */ - printf("JACK Name: %s\n\n", jack_name); + printf("JACK Name: %s\n", jack_name); #ifdef JALV_JACK_SESSION - const char* const jack_uuid_str = (argc > 2) ? argv[2] : NULL; - if (jack_uuid_str) { + if (host.opts.uuid) { host.jack_client = jack_client_open(jack_name, JackSessionID, NULL, - jack_uuid_str); + host.opts.uuid); } #endif @@ -462,43 +830,73 @@ if (!host.jack_client) die("Failed to connect to JACK.\n"); +#ifdef HAVE_JACK_PORT_TYPE_GET_BUFFER_SIZE + host.midi_buf_size = jack_port_type_get_buffer_size( + host.jack_client, JACK_DEFAULT_MIDI_TYPE); +#else + host.midi_buf_size = 4096; + fprintf(stderr, "warning: No jack_port_type_get_buffer_size.\n"); +#endif + printf("MIDI buffers: %zu bytes\n", host.midi_buf_size); + /* Instantiate the plugin */ host.instance = lilv_plugin_instantiate( host.plugin, jack_get_sample_rate(host.jack_client), features); - if (!host.instance) + if (!host.instance) { die("Failed to instantiate plugin.\n"); + } + + fprintf(stderr, "\n"); + if (!host.buf_size_set) { + jalv_allocate_port_buffers(&host); + } + + /* Create thread and ringbuffers for worker if necessary */ + if (lilv_plugin_has_feature(host.plugin, host.nodes.work_schedule) + && lilv_plugin_has_extension_data(host.plugin, host.nodes.work_interface)) { + jalv_worker_init( + &host, &host.worker, + (LV2_Worker_Interface*)lilv_instance_get_extension_data( + host.instance, LV2_WORKER__interface)); + } + + /* Apply loaded state to plugin instance if necessary */ + if (state) { + jalv_apply_state(&host, state); + } /* Set instance for instance-access extension */ instance_feature.data = lilv_instance_get_handle(host.instance); /* Set Jack callbacks */ - jack_set_process_callback(host.jack_client, &jack_process_cb, (void*)(&host)); + jack_set_process_callback(host.jack_client, + &jack_process_cb, (void*)(&host)); + jack_set_buffer_size_callback(host.jack_client, + &jack_buffer_size_cb, (void*)(&host)); #ifdef JALV_JACK_SESSION - jack_set_session_callback(host.jack_client, &jack_session_cb, (void*)(&host)); + jack_set_session_callback(host.jack_client, + &jack_session_cb, (void*)(&host)); #endif - /* Create ports */ - host.num_ports = lilv_plugin_get_num_ports(host.plugin); - host.ports = calloc((size_t)host.num_ports, sizeof(struct Port)); - float* default_values = calloc(lilv_plugin_get_num_ports(host.plugin), - sizeof(float)); - lilv_plugin_get_port_ranges_float(host.plugin, NULL, NULL, default_values); - - for (uint32_t i = 0; i < host.num_ports; ++i) - create_port(&host, i, default_values[i]); - - free(default_values); + /* Create Jack ports and connect plugin ports to buffers */ + for (uint32_t i = 0; i < host.num_ports; ++i) { + activate_port(&host, i); + } - /* Activate plugin and JACK */ + /* Activate plugin */ lilv_instance_activate(host.instance); + + /* Activate Jack */ jack_activate(host.jack_client); host.sample_rate = jack_get_sample_rate(host.jack_client); + host.play_state = JALV_RUNNING; SuilHost* ui_host = NULL; if (host.ui) { /* Instantiate UI */ - ui_host = suil_host_new(lv2_ui_write, NULL, NULL, NULL); + ui_host = suil_host_new(jalv_ui_write, NULL, NULL, NULL); + host.has_ui = true; host.ui_instance = suil_instance_new( ui_host, &host, @@ -509,26 +907,44 @@ lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_bundle_uri(host.ui))), lilv_uri_to_path(lilv_node_as_uri(lilv_ui_get_binary_uri(host.ui))), features); + + if (!host.ui_instance) { + die("Failed to instantiate plugin.\n"); + } + + /* Set initial control values for UI */ + for (uint32_t i = 0; i < host.num_ports; ++i) { + if (host.ports[i].type == TYPE_CONTROL) { + suil_instance_port_event(host.ui_instance, i, + sizeof(float), 0, + &host.ports[i].control); + } + } } /* Run UI (or prompt at console) */ jalv_open_ui(&host, host.ui_instance); /* Wait for finish signal from UI or signal handler */ - sem_wait(&exit_sem); + zix_sem_wait(&exit_sem); + host.exit = true; fprintf(stderr, "Exiting...\n"); + /* Terminate the worker */ + jalv_worker_finish(&host.worker); + /* Deactivate JACK */ jack_deactivate(host.jack_client); for (uint32_t i = 0; i < host.num_ports; ++i) { - if (host.ports[i].ev_buffer) { - free(host.ports[i].ev_buffer); + if (host.ports[i].evbuf) { + lv2_evbuf_free(host.ports[i].evbuf); } } jack_client_close(host.jack_client); /* Deactivate plugin */ + suil_instance_free(host.ui_instance); lilv_instance_deactivate(host.instance); lilv_instance_free(host.instance); @@ -537,19 +953,19 @@ jack_ringbuffer_free(host.ui_events); jack_ringbuffer_free(host.plugin_events); lilv_node_free(native_ui_type); - lilv_node_free(host.input_class); - lilv_node_free(host.output_class); - lilv_node_free(host.control_class); - lilv_node_free(host.audio_class); - lilv_node_free(host.event_class); - lilv_node_free(host.midi_class); - lilv_node_free(host.optional); + for (LilvNode** n = (LilvNode**)&host.nodes; *n; ++n) { + lilv_node_free(*n); + } symap_free(host.symap); - suil_instance_free(host.ui_instance); suil_host_free(ui_host); + sratom_free(host.sratom); + lilv_uis_free(host.uis); lilv_world_free(world); - sem_destroy(&exit_sem); + zix_sem_destroy(&exit_sem); + + remove(host.temp_dir); + free(host.temp_dir); return 0; } diff -Nru jalv-0~svn3409/src/jalv_console.c jalv-1.0.0~dfsg0/src/jalv_console.c --- jalv-0~svn3409/src/jalv_console.c 2011-05-30 23:19:28.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv_console.c 2012-04-10 00:19:59.000000000 +0000 @@ -1,5 +1,5 @@ /* - Copyright 2007-2011 David Robillard + Copyright 2007-2012 David Robillard Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -14,16 +14,71 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ +#include +#include #include -#include "jalv-config.h" +#include "jalv_config.h" #include "jalv_internal.h" +static int +print_usage(const char* name, bool error) +{ + FILE* const os = error ? stderr : stdout; + fprintf(os, "Usage: %s [OPTION...] PLUGIN_URI\n", name); + fprintf(os, "Run an LV2 plugin as a Jack application.\n"); + fprintf(os, " -h Display this help and exit\n"); + fprintf(os, " -u UUID UUID for Jack session restoration\n"); + fprintf(os, " -l DIR Load state from save directory\n"); + fprintf(os, " -d DIR Dump plugin <=> UI communication\n"); + return error ? 1 : 0; +} + +int +jalv_ui_resize(Jalv* jalv, int width, int height) +{ + return 0; +} + void -jalv_init(int* argc, char*** argv) +jalv_ui_port_event(Jalv* jalv, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer) { } +int +jalv_init(int* argc, char*** argv, JalvOptions* opts) +{ + int a = 1; + for (; a < *argc && (*argv)[a][0] == '-'; ++a) { + if ((*argv)[a][1] == 'h') { + return print_usage((*argv)[0], false); + } else if ((*argv)[a][1] == 'u') { + if (++a == *argc) { + fprintf(stderr, "Missing argument for -u\n"); + return 1; + } + opts->uuid = jalv_strdup((*argv)[a]); + } else if ((*argv)[a][1] == 'l') { + if (++a == *argc) { + fprintf(stderr, "Missing argument for -l\n"); + return 1; + } + opts->load = jalv_strdup((*argv)[a]); + } else if ((*argv)[a][1] == 'd') { + opts->dump = true; + } else { + fprintf(stderr, "Unknown option %s\n", (*argv)[a]); + return print_usage((*argv)[0], true); + } + } + + return 0; +} + LilvNode* jalv_native_ui_type(Jalv* jalv) { @@ -37,12 +92,11 @@ #ifdef JALV_JACK_SESSION printf("\nPress Ctrl-C to quit: "); fflush(stdout); - //g_cond_wait(exit_cond, exit_mutex); #else printf("\nPress enter to quit: "); fflush(stdout); getc(stdin); - sem_post(jalv->done); + zix_sem_post(jalv->done); #endif printf("\n"); diff -Nru jalv-0~svn3409/src/jalv_gtk2.c jalv-1.0.0~dfsg0/src/jalv_gtk2.c --- jalv-0~svn3409/src/jalv_gtk2.c 2011-06-19 23:43:48.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv_gtk2.c 2012-04-19 05:00:37.000000000 +0000 @@ -1,5 +1,5 @@ /* - Copyright 2007-2011 David Robillard + Copyright 2007-2012 David Robillard Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -14,24 +14,48 @@ OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ +#include + #include +#include "lv2/lv2plug.in/ns/ext/port-props/port-props.h" + #include "jalv_internal.h" -static void destroy(GtkWidget* widget, - gpointer data) +static void +on_window_destroy(GtkWidget* widget, + gpointer data) { + Jalv* jalv = (Jalv*)data; + suil_instance_free(jalv->ui_instance); + jalv->ui_instance = NULL; gtk_main_quit(); } -void -jalv_init(int* argc, char*** argv) +int +jalv_init(int* argc, char*** argv, JalvOptions* opts) { + GOptionEntry entries[] = { + { "uuid", 'u', 0, G_OPTION_ARG_STRING, &opts->uuid, + "UUID for Jack session restoration", "UUID" }, + { "load", 'l', 0, G_OPTION_ARG_STRING, &opts->load, + "Load state from save directory", "DIR" }, + { "dump", 'd', 0, G_OPTION_ARG_NONE, &opts->dump, + "Dump plugin <=> UI communication", NULL }, + { "generic-ui", 'g', 0, G_OPTION_ARG_NONE, &opts->generic_ui, + "Use Jalv generic UI and not the plugin UI", NULL}, + { 0, 0, 0, 0, 0, 0, 0 } }; GError* error = NULL; - gtk_init_with_args( + const int err = gtk_init_with_args( argc, argv, - "PLUGIN_URI [JACK_UUID] - Run an LV2 plugin as a Jack application", - NULL, NULL, &error); + "PLUGIN_URI - Run an LV2 plugin as a Jack application", + entries, NULL, &error); + + if (!err) { + fprintf(stderr, "%s\n", error->message); + } + + return !err; } LilvNode* @@ -41,39 +65,524 @@ "http://lv2plug.in/ns/extensions/ui#GtkUI"); } -int -jalv_open_ui(Jalv* jalv, - SuilInstance* instance) +static void +on_save_activate(GtkWidget* widget, void* ptr) { - GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + Jalv* jalv = (Jalv*)ptr; + GtkWidget* dialog = gtk_file_chooser_dialog_new( + "Save State", + jalv->window, + GTK_FILE_CHOOSER_ACTION_CREATE_FOLDER, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + char* path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + char* base = g_build_filename(path, "/", NULL); + jalv_save(jalv, base); + g_free(path); + g_free(base); + } - g_signal_connect(window, "destroy", - G_CALLBACK(destroy), NULL); + gtk_widget_destroy(dialog); +} - gtk_container_set_border_width(GTK_CONTAINER(window), 8); +static void +on_quit_activate(GtkWidget* widget, gpointer data) +{ + GtkWidget* window = (GtkWidget*)data; + gtk_widget_destroy(window); +} + +typedef struct { + Jalv* jalv; + LilvNode* preset; +} PresetRecord; + +char* +symbolify(const char* in) +{ + const size_t len = strlen(in); + char* out = calloc(len + 1, 1); + for (size_t i = 0; i < len; ++i) { + if (g_ascii_isalnum(in[i])) { + out[i] = in[i]; + } else { + out[i] = '_'; + } + } + return out; +} + +static void +on_save_preset_activate(GtkWidget* widget, void* ptr) +{ + Jalv* jalv = (Jalv*)ptr; + + GtkWidget* dialog = gtk_file_chooser_dialog_new( + "Save Preset", + jalv->window, + GTK_FILE_CHOOSER_ACTION_SAVE, + GTK_STOCK_CANCEL, GTK_RESPONSE_REJECT, + GTK_STOCK_SAVE, GTK_RESPONSE_ACCEPT, + NULL); + + char* dot_lv2 = g_build_filename(g_get_home_dir(), ".lv2", NULL); + gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(dialog), dot_lv2); + free(dot_lv2); + + GtkWidget* content = gtk_dialog_get_content_area(GTK_DIALOG(dialog)); + GtkBox* box = GTK_BOX(gtk_hbox_new(FALSE, 8)); + GtkWidget* uri_label = gtk_label_new("URI (Optional):"); + GtkWidget* uri_entry = gtk_entry_new(); + + gtk_box_pack_start(box, uri_label, FALSE, TRUE, 2); + gtk_box_pack_start(box, uri_entry, TRUE, TRUE, 2); + gtk_box_pack_start(GTK_BOX(content), GTK_WIDGET(box), FALSE, FALSE, 6); + + gtk_widget_show_all(GTK_WIDGET(dialog)); + gtk_entry_set_activates_default(GTK_ENTRY(uri_entry), TRUE); + gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_ACCEPT); + if (gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) { + const char* path = gtk_file_chooser_get_filename(GTK_FILE_CHOOSER(dialog)); + const char* uri = gtk_entry_get_text(GTK_ENTRY(uri_entry)); + + char* dirname = g_path_get_dirname(path); + char* basename = g_path_get_basename(path); + char* sym = symbolify(basename); + char* bundle = g_strjoin(NULL, sym, ".lv2", NULL); + char* file = g_strjoin(NULL, sym, ".ttl", NULL); + char* dir = g_build_filename(dirname, bundle, NULL); + + jalv_save_preset(jalv, dir, (strlen(uri) ? uri : NULL), basename, file); + + g_free(dir); + g_free(file); + g_free(bundle); + free(sym); + g_free(basename); + g_free(dirname); + } + + gtk_widget_destroy(GTK_WIDGET(dialog)); +} - if (instance) { - GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(instance); - gtk_container_add(GTK_CONTAINER(window), widget); +static void +on_preset_activate(GtkWidget* widget, gpointer data) +{ + PresetRecord* record = (PresetRecord*)data; + jalv_apply_preset(record->jalv, record->preset); +} + +static void +on_preset_destroy(gpointer data, GClosure* closure) +{ + PresetRecord* record = (PresetRecord*)data; + lilv_node_free(record->preset); + free(record); +} + +static int +add_preset_to_menu(Jalv* jalv, + const LilvNode* node, + const LilvNode* title, + void* data) +{ + GtkWidget* presets_menu = GTK_WIDGET(data); + const char* label = lilv_node_as_string(title); + GtkWidget* item = gtk_menu_item_new_with_label(label); + + PresetRecord* record = (PresetRecord*)malloc(sizeof(PresetRecord)); + record->jalv = jalv; + record->preset = lilv_node_duplicate(node); + + g_signal_connect_data(G_OBJECT(item), "activate", + G_CALLBACK(on_preset_activate), + record, on_preset_destroy, + 0); + + gtk_menu_shell_append(GTK_MENU_SHELL(presets_menu), item); + return 0; +} + +void +jalv_ui_port_event(Jalv* jalv, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer) +{ + GtkWidget* widget = jalv->ports[port_index].widget; + if (!widget) { + return; + } + + if (GTK_IS_COMBO_BOX(widget)) { + GtkTreeModel* model = gtk_combo_box_get_model(GTK_COMBO_BOX(widget)); + GValue value = { 0, { { 0 } } }; + GtkTreeIter i; + bool valid = gtk_tree_model_get_iter_first(model, &i); + while (valid) { + gtk_tree_model_get_value(model, &i, 0, &value); + const double v = g_value_get_double(&value); + g_value_unset(&value); + if (fabs(v - *(float*)buffer) < FLT_EPSILON) { + gtk_combo_box_set_active_iter(GTK_COMBO_BOX(widget), &i); + return; + } + valid = gtk_tree_model_iter_next(model, &i); + } + } else if (GTK_IS_TOGGLE_BUTTON(widget)) { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget), + *(float*)buffer > 0.0f); + } else if (GTK_IS_RANGE(widget)) { + gtk_range_set_value(GTK_RANGE(widget), *(float*)buffer); } else { - GtkWidget* button = gtk_button_new_with_label("Close"); + fprintf(stderr, "Unknown widget type for port %d\n", port_index); + } +} - g_signal_connect_swapped(button, "clicked", - G_CALLBACK(gtk_widget_destroy), - window); +static gboolean +slider_changed(GtkRange* range, gpointer data) +{ + ((struct Port*)data)->control = gtk_range_get_value(range); + return FALSE; +} - gtk_container_add(GTK_CONTAINER(window), button); +static gboolean +log_slider_changed(GtkRange* range, gpointer data) +{ + ((struct Port*)data)->control = expf(gtk_range_get_value(range)); + return FALSE; +} + +static void +combo_changed(GtkComboBox* box, gpointer data) +{ + GtkTreeIter iter; + if (gtk_combo_box_get_active_iter(box, &iter)) { + GtkTreeModel* model = gtk_combo_box_get_model(box); + GValue value = { 0, { { 0 } } }; + + gtk_tree_model_get_value(model, &iter, 0, &value); + const double v = g_value_get_double(&value); + g_value_unset(&value); + + ((struct Port*)data)->control = v; } +} - // TODO: Check UI properties for resizable - gtk_window_set_resizable(GTK_WINDOW(window), false); +static gboolean +toggle_changed(GtkToggleButton* button, gpointer data) +{ + float fval = gtk_toggle_button_get_active(button) ? 1.0f : 0.0f; + ((struct Port*)data)->control = fval; + return FALSE; +} + +static gchar* +scale_format(GtkScale* scale, gdouble value, gpointer user_data) +{ + gpointer hval = g_hash_table_lookup(user_data, &value); + return hval ? g_strdup(hval) : + g_strdup_printf("%0.*f", gtk_scale_get_digits(scale), value); +} + +static gchar* +log_scale_format(GtkScale* scale, gdouble value, gpointer user_data) +{ + return g_strdup_printf("%0.6g", exp(gtk_range_get_value(GTK_RANGE(scale)))); +} + +static gint +dcmp(gconstpointer a, gconstpointer b) +{ + double y = *(double*)a; + double z = *(double*)b; + return y < z ? -1 : z < y ? 1 : 0; +} + +static GtkWidget* +make_combo(struct Port* port, GHashTable* points, int deft) +{ + GList* list = g_hash_table_get_keys(points); + GtkListStore* list_store = gtk_list_store_new( + 2, G_TYPE_DOUBLE, G_TYPE_STRING); + for (GList* cur = g_list_sort(list, dcmp); cur; cur = cur->next) { + GtkTreeIter iter; + gtk_list_store_append(list_store, &iter); + gtk_list_store_set(list_store, &iter, + 0, *(double*)cur->data, + 1, g_hash_table_lookup(points, cur->data), + -1); + } + g_list_free(list); + + GtkWidget* combo = gtk_combo_box_new_with_model(GTK_TREE_MODEL(list_store)); + gtk_combo_box_set_active(GTK_COMBO_BOX(combo), deft); + g_object_unref(list_store); + + GtkCellRenderer* cell = gtk_cell_renderer_text_new(); + gtk_cell_layout_pack_start(GTK_CELL_LAYOUT(combo), cell, TRUE); + gtk_cell_layout_set_attributes(GTK_CELL_LAYOUT(combo), cell, "text", 1, NULL); + + g_signal_connect(G_OBJECT(combo), + "changed", G_CALLBACK(combo_changed), port); + + return combo; +} + +static GtkWidget* +make_log_slider(struct Port* port, GHashTable* points, + float min, float max, float deft) +{ + float lmin = logf(min); + float lmax = logf(max); + float ldft = logf(deft); + GtkWidget* slider = gtk_hscale_new_with_range(lmin, lmax, 0.001); + gtk_scale_set_digits(GTK_SCALE(slider), 6); + gtk_range_set_value(GTK_RANGE(slider), ldft); + g_signal_connect(G_OBJECT(slider), + "format-value", G_CALLBACK(log_scale_format), points); + g_signal_connect(G_OBJECT(slider), + "value-changed", G_CALLBACK(log_slider_changed), port); + + return slider; +} + +static GtkWidget* +make_slider(struct Port* port, GHashTable* points, + bool is_int, float min, float max, float deft) +{ + const double step = is_int ? 1.0 : ((max - min) / 100.0); + GtkWidget* slider = gtk_hscale_new_with_range(min, max, step); + gtk_range_set_value(GTK_RANGE(slider), deft); + if (points) { + g_signal_connect(G_OBJECT(slider), + "format-value", G_CALLBACK(scale_format), points); + } - gtk_widget_show_all(window); + g_signal_connect(G_OBJECT(slider), + "value-changed", G_CALLBACK(slider_changed), port); + + return slider; +} + +static GtkWidget* +make_toggle(struct Port* port, float deft) +{ + GtkWidget* check = gtk_check_button_new(); + if (deft) { + gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(check), TRUE); + } + g_signal_connect(G_OBJECT(check), + "toggled", G_CALLBACK(toggle_changed), port); + return check; +} + +static GtkWidget* +build_control_widget(Jalv* jalv, GtkWidget* window) +{ + LilvNode* lv2_integer = lilv_new_uri(jalv->world, LV2_CORE__integer); + LilvNode* lv2_toggled = lilv_new_uri(jalv->world, LV2_CORE__toggled); + LilvNode* lv2_enum = lilv_new_uri(jalv->world, LV2_CORE__enumeration); + LilvNode* lv2_log = lilv_new_uri(jalv->world, LV2_PORT_PROPS__logarithmic); + LilvNode* rdfs_comment = lilv_new_uri(jalv->world, LILV_NS_RDFS "comment"); + GtkWidget* port_table = gtk_table_new(jalv->num_ports, 2, false); + float* defaults = calloc(jalv->num_ports, sizeof(float)); + float* mins = calloc(jalv->num_ports, sizeof(float)); + float* maxs = calloc(jalv->num_ports, sizeof(float)); + int num_controls = 0; + lilv_plugin_get_port_ranges_float(jalv->plugin, mins, maxs, defaults); + for (unsigned i = 0; i < jalv->num_ports; i++) { + if (jalv->ports[i].type != TYPE_CONTROL) { + continue; + } + ++num_controls; + + const LilvPort* port = jalv->ports[i].lilv_port; + LilvNode* name = lilv_port_get_name(jalv->plugin, port); + + /* Get scale points */ + LilvScalePoints* sp = lilv_port_get_scale_points(jalv->plugin, port); + GHashTable* points = NULL; + if (sp) { + points = g_hash_table_new(g_double_hash, g_double_equal); + gdouble* values = malloc(lilv_scale_points_size(sp) * sizeof(gdouble)); + int idx = 0; + LILV_FOREACH(scale_points, i, sp) { + const LilvScalePoint* p = lilv_scale_points_get(sp, i); + values[idx] = lilv_node_as_float(lilv_scale_point_get_value(p)); + char* label = g_strdup( + lilv_node_as_string(lilv_scale_point_get_label(p))); + g_hash_table_insert(points, values + idx, label); + ++idx; + } + lilv_scale_points_free(sp); + } + + /* Make control */ + GtkWidget* control = NULL; + bool is_integer = lilv_port_has_property( + jalv->plugin, port, lv2_integer); + if (lilv_port_has_property(jalv->plugin, port, lv2_toggled)) { + control = make_toggle(&jalv->ports[i], defaults[i]); + } else if (lilv_port_has_property(jalv->plugin, port, lv2_enum) + || (is_integer && points && + (g_hash_table_size(points) + == (unsigned)(maxs[i] - mins[i] + 1)))) { + control = make_combo(&jalv->ports[i], points, defaults[i]); + } else if (lilv_port_has_property(jalv->plugin, port, lv2_log)) { + control = make_log_slider(&jalv->ports[i], points, + mins[i], maxs[i], defaults[i]); + } else { + control = make_slider(&jalv->ports[i], points, is_integer, + mins[i], maxs[i], defaults[i]); + } + jalv->ports[i].widget = control; + + /* Set tooltip text */ + LilvNodes* comments = lilv_port_get_value( + jalv->plugin, port, rdfs_comment); + if (comments) { + gtk_widget_set_tooltip_text( + control, lilv_node_as_string(lilv_nodes_get_first(comments))); + } + lilv_nodes_free(comments); + + /* Add control table row */ + GtkWidget* label = gtk_label_new(NULL); + gchar* markup = g_markup_printf_escaped( + "%s:", + lilv_node_as_string(name)); + gtk_label_set_markup(GTK_LABEL(label), markup); + g_free(markup); + gtk_misc_set_alignment(GTK_MISC(label), 1.0, 0.5); + gtk_table_attach(GTK_TABLE(port_table), + label, + 0, 1, i, i + 1, + GTK_FILL, GTK_FILL | GTK_EXPAND, 15, 15); + gtk_table_attach(GTK_TABLE(port_table), control, + 1, 2, i, i + 1, + GTK_FILL | GTK_EXPAND, 0, 0, 0); + lilv_node_free(name); + } + + free(defaults); + free(mins); + free(maxs); + lilv_node_free(lv2_integer); + lilv_node_free(lv2_toggled); + lilv_node_free(lv2_enum); + lilv_node_free(rdfs_comment); + + if (num_controls > 0) { + gtk_window_set_resizable(GTK_WINDOW(window), TRUE); + GtkWidget* alignment = gtk_alignment_new(0.5, 0.0, 1.0, 0.0); + gtk_alignment_set_padding(GTK_ALIGNMENT(alignment), 0, 0, 8, 8); + gtk_container_add(GTK_CONTAINER(alignment), port_table); + return alignment; + } else { + gtk_widget_destroy(port_table); + GtkWidget* button = gtk_button_new_with_label("Close"); + g_signal_connect_swapped( + button, "clicked", G_CALLBACK(gtk_widget_destroy), window); + gtk_window_set_resizable(GTK_WINDOW(window), FALSE); + return button; + } +} + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance) +{ + GtkWidget* window = gtk_window_new(GTK_WINDOW_TOPLEVEL); + jalv->window = window; + + g_signal_connect(window, "destroy", + G_CALLBACK(on_window_destroy), jalv); + + LilvNode* name = lilv_plugin_get_name(jalv->plugin); + gtk_window_set_title(GTK_WINDOW(window), lilv_node_as_string(name)); + lilv_node_free(name); + + GtkWidget* vbox = gtk_vbox_new(FALSE, 0); + GtkWidget* menu_bar = gtk_menu_bar_new(); + GtkWidget* file = gtk_menu_item_new_with_mnemonic("_File"); + GtkWidget* file_menu = gtk_menu_new(); + + GtkAccelGroup* ag = gtk_accel_group_new(); + gtk_window_add_accel_group(GTK_WINDOW(window), ag); + + GtkWidget* save = gtk_image_menu_item_new_from_stock(GTK_STOCK_SAVE, ag); + GtkWidget* quit = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, ag); + + gtk_menu_item_set_submenu(GTK_MENU_ITEM(file), file_menu); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), save); + gtk_menu_shell_append(GTK_MENU_SHELL(file_menu), quit); + gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), file); + + GtkWidget* presets = gtk_menu_item_new_with_mnemonic("_Presets"); + GtkWidget* presets_menu = gtk_menu_new(); + GtkWidget* save_preset = gtk_menu_item_new_with_mnemonic( + "_Save Preset..."); + gtk_menu_item_set_submenu(GTK_MENU_ITEM(presets), presets_menu); + gtk_menu_shell_append(GTK_MENU_SHELL(presets_menu), save_preset); + gtk_menu_shell_append(GTK_MENU_SHELL(presets_menu), + gtk_separator_menu_item_new()); + gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), presets); + + jalv_load_presets(jalv, add_preset_to_menu, presets_menu); + + gtk_container_add(GTK_CONTAINER(window), vbox); + gtk_box_pack_start(GTK_BOX(vbox), menu_bar, FALSE, FALSE, 0); + + g_signal_connect(G_OBJECT(quit), "activate", + G_CALLBACK(on_quit_activate), window); + + g_signal_connect(G_OBJECT(save), "activate", + G_CALLBACK(on_save_activate), jalv); + + g_signal_connect(G_OBJECT(save_preset), "activate", + G_CALLBACK(on_save_preset_activate), jalv); + + if (instance && !jalv->opts.generic_ui) { + GtkWidget* alignment = gtk_alignment_new(0.5, 0.5, 1.0, 1.0); + GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(instance); + + gtk_box_pack_start(GTK_BOX(vbox), alignment, TRUE, TRUE, 0); + gtk_container_add(GTK_CONTAINER(alignment), widget); + gtk_window_set_resizable(GTK_WINDOW(window), jalv_ui_is_resizable(jalv)); + gtk_widget_show_all(vbox); + } else { + GtkWidget* controls = build_control_widget(jalv, window); + GtkWidget* scroll_win = gtk_scrolled_window_new(NULL, NULL); + gtk_scrolled_window_add_with_viewport( + GTK_SCROLLED_WINDOW(scroll_win), controls); + gtk_scrolled_window_set_policy( + GTK_SCROLLED_WINDOW(scroll_win), + GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC); + gtk_box_pack_start(GTK_BOX(vbox), scroll_win, TRUE, TRUE, 0); + gtk_widget_show_all(vbox); + + GtkRequisition controls_size, box_size; + gtk_widget_size_request(GTK_WIDGET(controls), &controls_size); + gtk_widget_size_request(GTK_WIDGET(vbox), &box_size); + + gtk_window_set_default_size( + GTK_WINDOW(window), + MAX(MAX(box_size.width, controls_size.width) + 24, 640), + box_size.height + controls_size.height); + } g_timeout_add(1000 / JALV_UI_UPDATE_HZ, (GSourceFunc)jalv_emit_ui_events, jalv); + jalv->has_ui = TRUE; + gtk_window_present(GTK_WINDOW(window)); + gtk_main(); - sem_post(jalv->done); + zix_sem_post(jalv->done); return 0; } diff -Nru jalv-0~svn3409/src/jalv_gtkmm2.cpp jalv-1.0.0~dfsg0/src/jalv_gtkmm2.cpp --- jalv-0~svn3409/src/jalv_gtkmm2.cpp 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv_gtkmm2.cpp 2012-04-19 22:08:26.000000000 +0000 @@ -0,0 +1,88 @@ +/* + Copyright 2007-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include + +#include "jalv_internal.h" + +Gtk::Main* jalv_gtk_main = NULL; + +int +jalv_init(int* argc, char*** argv, JalvOptions* opts) +{ + jalv_gtk_main = new Gtk::Main(*argc, *argv); + return 0; +} + +LilvNode* +jalv_native_ui_type(Jalv* jalv) +{ + return lilv_new_uri(jalv->world, + "http://lv2plug.in/ns/extensions/ui#GtkUI"); +} + +int +jalv_ui_resize(Jalv* jalv, int width, int height) +{ + if (jalv->ui_instance) { + GtkWidget* widget = GTK_WIDGET( + suil_instance_get_widget(jalv->ui_instance)); + if (widget) { + gtk_widget_set_size_request(GTK_WIDGET(widget), width, height); + } + } + return 0; +} + +void +jalv_ui_port_event(Jalv* jalv, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer) +{ +} + +int +jalv_open_ui(Jalv* jalv, + SuilInstance* instance) +{ + Gtk::Window* window = new Gtk::Window(); + + if (instance) { + GtkWidget* widget = (GtkWidget*)suil_instance_get_widget(instance); + Gtk::Widget* widgetmm = Glib::wrap(widget); + window->add(*Gtk::manage(widgetmm)); + widgetmm->show_all(); + + g_timeout_add(1000 / JALV_UI_UPDATE_HZ, + (GSourceFunc)jalv_emit_ui_events, jalv); + } else { + Gtk::Button* button = Gtk::manage(new Gtk::Button("Close")); + window->add(*Gtk::manage(button)); + } + + window->set_resizable(jalv_ui_is_resizable(jalv)); + window->show_all(); + + Gtk::Main::run(*window); + + delete window; + delete jalv_gtk_main; + zix_sem_post(jalv->done); + + return 0; +} diff -Nru jalv-0~svn3409/src/jalv_internal.h jalv-1.0.0~dfsg0/src/jalv_internal.h --- jalv-0~svn3409/src/jalv_internal.h 2011-06-19 23:43:48.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv_internal.h 2012-04-12 00:17:12.000000000 +0000 @@ -17,15 +17,30 @@ #ifndef JALV_INTERNAL_H #define JALV_INTERNAL_H -#include +#include +#include #include #include #include "lilv/lilv.h" - +#include "serd/serd.h" #include "suil/suil.h" +#include "lv2/lv2plug.in/ns/ext/atom/atom.h" +#include "lv2/lv2plug.in/ns/ext/atom/forge.h" +#include "lv2/lv2plug.in/ns/ext/log/log.h" +#include "lv2/lv2plug.in/ns/ext/midi/midi.h" +#include "lv2/lv2plug.in/ns/ext/state/state.h" +#include "lv2/lv2plug.in/ns/ext/urid/urid.h" +#include "lv2/lv2plug.in/ns/ext/worker/worker.h" + +#include "zix/sem.h" +#include "zix/thread.h" + +#include "sratom/sratom.h" + +#include "lv2_evbuf.h" #include "symap.h" #ifdef __cplusplus @@ -34,33 +49,140 @@ #define JALV_UI_UPDATE_HZ 15 +enum PortFlow { + FLOW_UNKNOWN, + FLOW_INPUT, + FLOW_OUTPUT +}; + +enum PortType { + TYPE_UNKNOWN, + TYPE_CONTROL, + TYPE_AUDIO, + TYPE_EVENT +}; + +struct Port { + const LilvPort* lilv_port; + enum PortType type; + enum PortFlow flow; + jack_port_t* jack_port; ///< For audio/MIDI ports, otherwise NULL + LV2_Evbuf* evbuf; ///< For MIDI ports, otherwise NULL + void* widget; ///< Control widget, if applicable + uint32_t index; ///< Port index + float control; ///< For control ports, otherwise 0.0f + bool old_api; ///< True for event, false for atom +}; + +/** + Control change event, sent through ring buffers for UI updates. +*/ +typedef struct { + uint32_t index; + uint32_t protocol; + uint32_t size; + uint8_t body[]; +} ControlChange; + +typedef struct { + char* uuid; + char* load; + bool dump; + bool generic_ui; +} JalvOptions; + +typedef struct { + LV2_URID atom_eventTransfer; + LV2_URID log_Trace; + LV2_URID midi_MidiEvent; + LV2_URID time_Position; + LV2_URID time_bar; + LV2_URID time_barBeat; + LV2_URID time_beatUnit; + LV2_URID time_beatsPerBar; + LV2_URID time_beatsPerMinute; + LV2_URID time_frame; + LV2_URID time_speed; +} JalvURIDs; + +typedef struct { + LilvNode* atom_AtomPort; + LilvNode* atom_Chunk; + LilvNode* atom_Sequence; + LilvNode* ev_EventPort; + LilvNode* lv2_AudioPort; + LilvNode* lv2_ControlPort; + LilvNode* lv2_InputPort; + LilvNode* lv2_OutputPort; + LilvNode* lv2_connectionOptional; + LilvNode* midi_MidiEvent; + LilvNode* pset_Preset; + LilvNode* rdfs_label; + LilvNode* work_interface; + LilvNode* work_schedule; +} JalvNodes; + +typedef enum { + JALV_RUNNING, + JALV_PAUSE_REQUESTED, + JALV_PAUSED +} JalvPlayState; + +typedef struct { + jack_ringbuffer_t* requests; ///< Requests to the worker + jack_ringbuffer_t* responses; ///< Responses from the worker + void* response; ///< Worker response buffer + ZixSem sem; ///< Worker semaphore + ZixThread thread; ///< Worker thread + const LV2_Worker_Interface* iface; ///< Plugin worker interface +} JalvWorker; + typedef struct { - LilvWorld* world; /**< Lilv World */ - Symap* symap; /**< Symbol (URI) map */ - jack_client_t* jack_client; /**< Jack client */ - jack_ringbuffer_t* ui_events; /**< Port events from UI */ - jack_ringbuffer_t* plugin_events; /**< Port events from plugin */ - sem_t* done; /**< Exit semaphore */ - const LilvPlugin* plugin; /**< Plugin class (RDF data) */ - const LilvUI* ui; /**< Plugin UI (RDF data) */ - LilvInstance* instance; /**< Plugin instance (shared library) */ - SuilInstance* ui_instance; /**< Plugin UI instance (shared library) */ - struct Port* ports; /**< Port array of size num_ports */ - uint32_t num_ports; /**< Size of the two following arrays: */ - jack_nframes_t sample_rate; /**< Sample rate */ - jack_nframes_t event_delta_t; /**< Frames since last update sent to UI */ - LilvNode* input_class; /**< Input port class (URI) */ - LilvNode* output_class; /**< Output port class (URI) */ - LilvNode* control_class; /**< Control port class (URI) */ - LilvNode* audio_class; /**< Audio port class (URI) */ - LilvNode* event_class; /**< Event port class (URI) */ - LilvNode* midi_class; /**< MIDI event class (URI) */ - LilvNode* optional; /**< lv2:connectionOptional port property */ - uint32_t midi_event_id; /**< MIDI event class ID */ + JalvOptions opts; ///< Command-line options + JalvURIDs urids; ///< URIDs + JalvNodes nodes; ///< Nodes + LV2_Atom_Forge forge; ///< Atom forge + const char* prog_name; ///< Program name (argv[0]) + LilvWorld* world; ///< Lilv World + LV2_URID_Map map; ///< URI => Int map + LV2_URID_Unmap unmap; ///< Int => URI map + Sratom* sratom; ///< Atom serialiser + Symap* symap; ///< Symbol (URI) map + jack_client_t* jack_client; ///< Jack client + jack_ringbuffer_t* ui_events; ///< Port events from UI + jack_ringbuffer_t* plugin_events; ///< Port events from plugin + JalvWorker worker; ///< Worker thread implementation + ZixSem* done; ///< Exit semaphore + ZixSem paused; ///< Paused signal from process thread + JalvPlayState play_state; ///< Current play state + char* temp_dir; ///< Temporary plugin state directory + char* save_dir; ///< Plugin save directory + const LilvPlugin* plugin; ///< Plugin class (RDF data) + LilvUIs* uis; ///< All plugin UIs (RDF data) + const LilvUI* ui; ///< Plugin UI (RDF data) + LilvInstance* instance; ///< Plugin instance (shared library) + SuilInstance* ui_instance; ///< Plugin UI instance (shared library) + void* window; ///< Window (if applicable) + struct Port* ports; ///< Port array of size num_ports + size_t midi_buf_size; ///< Size of MIDI port buffers + uint32_t num_ports; ///< Size of the two following arrays: + uint32_t longest_sym; ///< Longest port symbol + jack_nframes_t sample_rate; ///< Sample rate + jack_nframes_t event_delta_t; ///< Frames since last update sent to UI + uint32_t midi_event_id; ///< MIDI event class ID in event context + bool buf_size_set; ///< True iff buffer size callback fired + bool exit; ///< True iff execution is finished + bool has_ui; ///< True iff a control UI is present } Jalv; +int +jalv_init(int* argc, char*** argv, JalvOptions* opts); + void -jalv_init(int* argc, char*** argv); +jalv_create_ports(Jalv* jalv); + +struct Port* +jalv_port_by_symbol(Jalv* jalv, const char* sym); LilvNode* jalv_native_ui_type(Jalv* jalv); @@ -70,11 +192,102 @@ SuilInstance* instance); bool +jalv_ui_is_resizable(Jalv* jalv); + +void +jalv_ui_write(SuilController controller, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer); + +void +jalv_ui_port_event(Jalv* jalv, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer); + +bool jalv_emit_ui_events(Jalv* jalv); +int +jalv_ui_resize(Jalv* jalv, int width, int height); + +typedef int (*PresetSink)(Jalv* jalv, + const LilvNode* node, + const LilvNode* title, + void* data); + +int +jalv_load_presets(Jalv* jalv, PresetSink sink, void* data); + +int +jalv_apply_preset(Jalv* jalv, const LilvNode* preset); + +int +jalv_save_preset(Jalv* jalv, + const char* dir, + const char* uri, + const char* label, + const char* filename); + +void +jalv_save(Jalv* jalv, const char* dir); + +void +jalv_save_port_values(Jalv* jalv, + SerdWriter* writer, + const SerdNode* subject); +char* +jalv_make_path(LV2_State_Make_Path_Handle handle, + const char* path); + +void +jalv_apply_state(Jalv* jalv, LilvState* state); + +char* +atom_to_turtle(LV2_URID_Unmap* unmap, + const SerdNode* subject, + const SerdNode* predicate, + const LV2_Atom* atom); + +static inline char* +jalv_strdup(const char* str) +{ + const size_t len = strlen(str); + char* copy = (char*)malloc(len + 1); + memcpy(copy, str, len + 1); + return copy; +} + +static inline char* +jalv_strjoin(const char* a, const char* b) +{ + const size_t a_len = strlen(a); + const size_t b_len = strlen(b); + char* const out = (char*)malloc(a_len + b_len + 1); + + memcpy(out, a, a_len); + memcpy(out + a_len, b, b_len); + out[a_len + b_len] = '\0'; + + return out; +} + +int +jalv_printf(LV2_Log_Handle handle, + LV2_URID type, + const char* fmt, ...); + +int +jalv_vprintf(LV2_Log_Handle handle, + LV2_URID type, + const char* fmt, + va_list ap); #ifdef __cplusplus -} // extern "C" +} // extern "C" #endif -#endif // JALV_INTERNAL_H +#endif // JALV_INTERNAL_H diff -Nru jalv-0~svn3409/src/jalv_qt4.cpp jalv-1.0.0~dfsg0/src/jalv_qt4.cpp --- jalv-0~svn3409/src/jalv_qt4.cpp 2011-06-19 23:43:48.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/jalv_qt4.cpp 2012-04-10 00:18:32.000000000 +0000 @@ -25,10 +25,11 @@ extern "C" { -void -jalv_init(int* argc, char*** argv) +int +jalv_init(int* argc, char*** argv, JalvOptions* opts) { app = new QApplication(*argc, *argv, true); + return 0; } LilvNode* @@ -38,9 +39,30 @@ "http://lv2plug.in/ns/extensions/ui#Qt4UI"); } +int +jalv_ui_resize(Jalv* jalv, int width, int height) +{ + if (jalv->ui_instance && width > 0 && height > 0) { + QWidget* widget = (QWidget*)suil_instance_get_widget(jalv->ui_instance); + if (widget) { + widget->resize(width, height); + } + } + return 0; +} + +void +jalv_ui_port_event(Jalv* jalv, + uint32_t port_index, + uint32_t buffer_size, + uint32_t protocol, + const void* buffer) +{ +} + class Timer : public QTimer { public: - Timer(Jalv* j) : jalv(j) {} + explicit Timer(Jalv* j) : jalv(j) {} void timerEvent(QTimerEvent* e) { jalv_emit_ui_events(jalv); @@ -68,8 +90,8 @@ timer->start(1000 / JALV_UI_UPDATE_HZ); int ret = app->exec(); - sem_post(jalv->done); + zix_sem_post(jalv->done); return ret; } -} // extern "C" +} // extern "C" diff -Nru jalv-0~svn3409/src/log.c jalv-1.0.0~dfsg0/src/log.c --- jalv-0~svn3409/src/log.c 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/log.c 2012-04-05 21:13:03.000000000 +0000 @@ -0,0 +1,43 @@ +/* + Copyright 2007-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "jalv_internal.h" + +int +jalv_printf(LV2_Log_Handle handle, + LV2_URID type, + const char* fmt, ...) +{ + va_list args; + va_start(args, fmt); + const int ret = jalv_vprintf(handle, type, fmt, args); + va_end(args); + return ret; +} + +int +jalv_vprintf(LV2_Log_Handle handle, + LV2_URID type, + const char* fmt, + va_list ap) +{ + // TODO: Lock + Jalv* jalv = (Jalv*)handle; + if (type == jalv->urids.log_Trace && !jalv->opts.dump) { + return 0; + } + return vfprintf(stderr, fmt, ap); +} diff -Nru jalv-0~svn3409/src/lv2_evbuf.c jalv-1.0.0~dfsg0/src/lv2_evbuf.c --- jalv-0~svn3409/src/lv2_evbuf.c 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/lv2_evbuf.c 2012-04-11 20:06:01.000000000 +0000 @@ -0,0 +1,276 @@ +/* + Copyright 2008-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include +#include +#include + +#include "lv2/lv2plug.in/ns/ext/atom/atom.h" +#include "lv2/lv2plug.in/ns/ext/event/event.h" + +#include "lv2_evbuf.h" + +struct LV2_Evbuf_Impl { + LV2_Evbuf_Type type; + uint32_t capacity; + uint32_t atom_Chunk; + uint32_t atom_Sequence; + union { + LV2_Event_Buffer event; + LV2_Atom_Sequence atom; + } buf; +}; + +static inline uint32_t +lv2_evbuf_pad_size(uint32_t size) +{ + return (size + 7) & (~7); +} + +LV2_Evbuf* +lv2_evbuf_new(uint32_t capacity, + LV2_Evbuf_Type type, + uint32_t atom_Chunk, + uint32_t atom_Sequence) +{ + // FIXME: memory must be 64-bit aligned + LV2_Evbuf* evbuf = (LV2_Evbuf*)malloc( + sizeof(LV2_Evbuf) + sizeof(LV2_Atom_Sequence) + capacity); + evbuf->capacity = capacity; + evbuf->atom_Chunk = atom_Chunk; + evbuf->atom_Sequence = atom_Sequence; + lv2_evbuf_set_type(evbuf, type); + lv2_evbuf_reset(evbuf, true); + return evbuf; +} + +void +lv2_evbuf_free(LV2_Evbuf* evbuf) +{ + free(evbuf); +} + +void +lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type) +{ + evbuf->type = type; + switch (type) { + case LV2_EVBUF_EVENT: + evbuf->buf.event.data = (uint8_t*)(evbuf + 1); + evbuf->buf.event.capacity = evbuf->capacity; + break; + case LV2_EVBUF_ATOM: + break; + } + lv2_evbuf_reset(evbuf, true); +} + +void +lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input) +{ + switch (evbuf->type) { + case LV2_EVBUF_EVENT: + evbuf->buf.event.header_size = sizeof(LV2_Event_Buffer); + evbuf->buf.event.stamp_type = LV2_EVENT_AUDIO_STAMP; + evbuf->buf.event.event_count = 0; + evbuf->buf.event.size = 0; + break; + case LV2_EVBUF_ATOM: + if (input) { + evbuf->buf.atom.atom.size = sizeof(LV2_Atom_Sequence_Body); + evbuf->buf.atom.atom.type = evbuf->atom_Sequence; + } else { + evbuf->buf.atom.atom.size = evbuf->capacity; + evbuf->buf.atom.atom.type = evbuf->atom_Chunk; + } + } +} + +uint32_t +lv2_evbuf_get_size(LV2_Evbuf* evbuf) +{ + switch (evbuf->type) { + case LV2_EVBUF_EVENT: + return evbuf->buf.event.size; + case LV2_EVBUF_ATOM: + assert(evbuf->buf.atom.atom.type != evbuf->atom_Sequence + || evbuf->buf.atom.atom.size >= sizeof(LV2_Atom_Sequence_Body)); + return evbuf->buf.atom.atom.type == evbuf->atom_Sequence + ? evbuf->buf.atom.atom.size - sizeof(LV2_Atom_Sequence_Body) + : 0; + } + return 0; +} + +void* +lv2_evbuf_get_buffer(LV2_Evbuf* evbuf) +{ + switch (evbuf->type) { + case LV2_EVBUF_EVENT: + return &evbuf->buf.event; + case LV2_EVBUF_ATOM: + return &evbuf->buf.atom; + } + return NULL; +} + +LV2_Evbuf_Iterator +lv2_evbuf_begin(LV2_Evbuf* evbuf) +{ + LV2_Evbuf_Iterator iter = { evbuf, 0 }; + return iter; +} + +LV2_Evbuf_Iterator +lv2_evbuf_end(LV2_Evbuf* evbuf) +{ + const uint32_t size = lv2_evbuf_get_size(evbuf); + const LV2_Evbuf_Iterator iter = { evbuf, lv2_evbuf_pad_size(size) }; + return iter; +} + +bool +lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter) +{ + return iter.offset < lv2_evbuf_get_size(iter.evbuf); +} + +LV2_Evbuf_Iterator +lv2_evbuf_next(LV2_Evbuf_Iterator iter) +{ + if (!lv2_evbuf_is_valid(iter)) { + return iter; + } + + LV2_Evbuf* evbuf = iter.evbuf; + uint32_t offset = iter.offset; + uint32_t size; + switch (evbuf->type) { + case LV2_EVBUF_EVENT: + size = ((LV2_Event*)(evbuf->buf.event.data + offset))->size; + offset += lv2_evbuf_pad_size(sizeof(LV2_Event) + size); + break; + case LV2_EVBUF_ATOM: + size = ((LV2_Atom_Event*) + ((char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, &evbuf->buf.atom) + + offset))->body.size; + offset += lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); + break; + } + + LV2_Evbuf_Iterator next = { evbuf, offset }; + return next; +} + +bool +lv2_evbuf_get(LV2_Evbuf_Iterator iter, + uint32_t* frames, + uint32_t* subframes, + uint32_t* type, + uint32_t* size, + uint8_t** data) +{ + *frames = *subframes = *type = *size = 0; + *data = NULL; + + if (!lv2_evbuf_is_valid(iter)) { + return false; + } + + LV2_Event_Buffer* ebuf; + LV2_Event* ev; + LV2_Atom_Sequence* aseq; + LV2_Atom_Event* aev; + switch (iter.evbuf->type) { + case LV2_EVBUF_EVENT: + ebuf = &iter.evbuf->buf.event; + ev = (LV2_Event*)((char*)ebuf->data + iter.offset); + *frames = ev->frames; + *subframes = ev->subframes; + *type = ev->type; + *size = ev->size; + *data = (uint8_t*)ev + sizeof(LV2_Event); + break; + case LV2_EVBUF_ATOM: + aseq = (LV2_Atom_Sequence*)&iter.evbuf->buf.atom; + aev = (LV2_Atom_Event*)( + (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + + iter.offset); + *frames = aev->time.frames; + *subframes = 0; + *type = aev->body.type; + *size = aev->body.size; + *data = LV2_ATOM_BODY(&aev->body); + break; + } + + return true; +} + +bool +lv2_evbuf_write(LV2_Evbuf_Iterator* iter, + uint32_t frames, + uint32_t subframes, + uint32_t type, + uint32_t size, + const uint8_t* data) +{ + LV2_Event_Buffer* ebuf; + LV2_Event* ev; + LV2_Atom_Sequence* aseq; + LV2_Atom_Event* aev; + switch (iter->evbuf->type) { + case LV2_EVBUF_EVENT: + ebuf = &iter->evbuf->buf.event; + if (ebuf->capacity - ebuf->size < sizeof(LV2_Event) + size) { + return false; + } + + ev = (LV2_Event*)(ebuf->data + iter->offset); + ev->frames = frames; + ev->subframes = subframes; + ev->type = type; + ev->size = size; + memcpy((uint8_t*)ev + sizeof(LV2_Event), data, size); + + size = lv2_evbuf_pad_size(sizeof(LV2_Event) + size); + ebuf->size += size; + ebuf->event_count += 1; + iter->offset += size; + break; + case LV2_EVBUF_ATOM: + aseq = (LV2_Atom_Sequence*)&iter->evbuf->buf.atom; + if (iter->evbuf->capacity - sizeof(LV2_Atom) - aseq->atom.size + < sizeof(LV2_Atom_Event) + size) { + return false; + } + + aev = (LV2_Atom_Event*)( + (char*)LV2_ATOM_CONTENTS(LV2_Atom_Sequence, aseq) + + iter->offset); + aev->time.frames = frames; + aev->body.type = type; + aev->body.size = size; + memcpy(LV2_ATOM_BODY(&aev->body), data, size); + + size = lv2_evbuf_pad_size(sizeof(LV2_Atom_Event) + size); + aseq->atom.size += size; + iter->offset += size; + break; + } + + return true; +} diff -Nru jalv-0~svn3409/src/lv2_evbuf.h jalv-1.0.0~dfsg0/src/lv2_evbuf.h --- jalv-0~svn3409/src/lv2_evbuf.h 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/lv2_evbuf.h 2012-03-27 03:41:41.000000000 +0000 @@ -0,0 +1,164 @@ +/* + Copyright 2008-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef LV2_EVBUF_H +#define LV2_EVBUF_H + +#include + +#ifdef __cplusplus +extern "C" { +#else +#include +#endif + +/** + Format of actual buffer. +*/ +typedef enum { + /** + An (old) ev:EventBuffer (LV2_Event_Buffer). + */ + LV2_EVBUF_EVENT, + + /** + A (new) atom:Sequence (LV2_Atom_Sequence). + */ + LV2_EVBUF_ATOM +} LV2_Evbuf_Type; + +/** + An abstract/opaque LV2 event buffer. +*/ +typedef struct LV2_Evbuf_Impl LV2_Evbuf; + +/** + An iterator over an LV2_Evbuf. +*/ +typedef struct { + LV2_Evbuf* evbuf; + uint32_t offset; +} LV2_Evbuf_Iterator; + +/** + Allocate a new, empty event buffer. + URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM. +*/ +LV2_Evbuf* +lv2_evbuf_new(uint32_t capacity, + LV2_Evbuf_Type type, + uint32_t atom_Chunk, + uint32_t atom_Sequence); + +/** + Free an event buffer allocated with lv2_evbuf_new. +*/ +void +lv2_evbuf_free(LV2_Evbuf* evbuf); + +/** + Reset and change the type of an existing event buffer. + URIDs for atom:Chunk and atom:Sequence must be passed for LV2_EVBUF_ATOM. +*/ +void +lv2_evbuf_set_type(LV2_Evbuf* evbuf, LV2_Evbuf_Type type); + +/** + Clear and initialize an existing event buffer. + The contents of buf are ignored entirely and overwritten, except capacity + which is unmodified. + If input is false and this is an atom buffer, the buffer will be prepared + for writing by the plugin. This MUST be called before every run cycle. +*/ +void +lv2_evbuf_reset(LV2_Evbuf* evbuf, bool input); + +/** + Return the total padded size of the events stored in the buffer. +*/ +uint32_t +lv2_evbuf_get_size(LV2_Evbuf* evbuf); + +/** + Return the actual buffer implementation. + The format of the buffer returned depends on the buffer type. +*/ +void* +lv2_evbuf_get_buffer(LV2_Evbuf* evbuf); + +/** + Return an iterator to the start of @p buf. +*/ +LV2_Evbuf_Iterator +lv2_evbuf_begin(LV2_Evbuf* evbuf); + +/** + Return an iterator to the end of @a buf. +*/ +LV2_Evbuf_Iterator +lv2_evbuf_end(LV2_Evbuf* evbuf); + +/** + Check if @p iter is valid. + @return True if @p iter is valid, otherwise false (past end of buffer) +*/ +bool +lv2_evbuf_is_valid(LV2_Evbuf_Iterator iter); + +/** + Advance @p iter forward one event. + @p iter must be valid. + @return True if @p iter is valid, otherwise false (reached end of buffer) +*/ +LV2_Evbuf_Iterator +lv2_evbuf_next(LV2_Evbuf_Iterator iter); + +/** + Dereference an event iterator (i.e. get the event currently pointed to). + @p iter must be valid. + @p type Set to the type of the event. + @p size Set to the size of the event. + @p data Set to the contents of the event. + @return True on success. +*/ +bool +lv2_evbuf_get(LV2_Evbuf_Iterator iter, + uint32_t* frames, + uint32_t* subframes, + uint32_t* type, + uint32_t* size, + uint8_t** data); + +/** + Write an event at @p iter. + The event (if any) pointed to by @p iter will be overwritten, and @p iter + incremented to point to the following event (i.e. several calls to this + function can be done in sequence without twiddling iter in-between). + @return True if event was written, otherwise false (buffer is full). +*/ +bool +lv2_evbuf_write(LV2_Evbuf_Iterator* iter, + uint32_t frames, + uint32_t subframes, + uint32_t type, + uint32_t size, + const uint8_t* data); + +#ifdef __cplusplus +} +#endif + +#endif /* LV2_EVBUF_H */ diff -Nru jalv-0~svn3409/src/state.c jalv-1.0.0~dfsg0/src/state.c --- jalv-0~svn3409/src/state.c 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/state.c 2012-04-19 05:00:37.000000000 +0000 @@ -0,0 +1,210 @@ +/* + Copyright 2007-2011 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#define _POSIX_C_SOURCE 200112L /* for fileno */ +#define _BSD_SOURCE 1 /* for lockf */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_LV2_STATE +# include "lv2/lv2plug.in/ns/ext/state/state.h" +#endif + +#include "lilv/lilv.h" + +#include "jalv_config.h" +#include "jalv_internal.h" + +#define NS_JALV "http://drobilla.net/ns/jalv#" +#define NS_RDF "http://www.w3.org/1999/02/22-rdf-syntax-ns#" +#define NS_RDFS "http://www.w3.org/2000/01/rdf-schema#" +#define NS_XSD "http://www.w3.org/2001/XMLSchema#" + +#define USTR(s) ((const uint8_t*)s) + +char* +jalv_make_path(LV2_State_Make_Path_Handle handle, + const char* path) +{ + Jalv* jalv = (Jalv*)handle; + + // Create in save directory if saving, otherwise use temp directory + const char* dir = (jalv->save_dir) ? jalv->save_dir : jalv->temp_dir; + + char* fullpath = jalv_strjoin(dir, path); + fprintf(stderr, "MAKE PATH `%s' => `%s'\n", path, fullpath); + + return fullpath; +} + +const void* +get_port_value(const char* port_symbol, + void* user_data, + uint32_t* size, + uint32_t* type) +{ + Jalv* jalv = (Jalv*)user_data; + struct Port* port = jalv_port_by_symbol(jalv, port_symbol); + if (port && port->flow == FLOW_INPUT && port->type == TYPE_CONTROL) { + *size = sizeof(float); + *type = jalv->forge.Float; + return &port->control; + } + *size = *type = 0; + return NULL; +} + +void +jalv_save(Jalv* jalv, const char* dir) +{ + jalv->save_dir = jalv_strjoin(dir, "/"); + + LilvState* const state = lilv_state_new_from_instance( + jalv->plugin, jalv->instance, &jalv->map, + jalv->temp_dir, dir, dir, dir, + get_port_value, jalv, + LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL); + + lilv_state_save(jalv->world, &jalv->map, &jalv->unmap, state, NULL, + dir, "state.ttl"); + + lilv_state_free(state); + + free(jalv->save_dir); + jalv->save_dir = NULL; +} + +int +jalv_load_presets(Jalv* jalv, PresetSink sink, void* data) +{ + LilvNodes* presets = lilv_plugin_get_related(jalv->plugin, + jalv->nodes.pset_Preset); + LILV_FOREACH(nodes, i, presets) { + const LilvNode* preset = lilv_nodes_get(presets, i); + lilv_world_load_resource(jalv->world, preset); + LilvNodes* labels = lilv_world_find_nodes( + jalv->world, preset, jalv->nodes.rdfs_label, NULL); + if (labels) { + const LilvNode* label = lilv_nodes_get_first(labels); + sink(jalv, preset, label, data); + lilv_nodes_free(labels); + } else { + fprintf(stderr, "Preset <%s> has no rdfs:label\n", + lilv_node_as_string(lilv_nodes_get(presets, i))); + } + } + lilv_nodes_free(presets); + + return 0; +} + +static void +set_port_value(const char* port_symbol, + void* user_data, + const void* value, + uint32_t size, + uint32_t type) +{ + Jalv* jalv = (Jalv*)user_data; + struct Port* port = jalv_port_by_symbol(jalv, port_symbol); + if (!port) { + fprintf(stderr, "error: Preset port `%s' is missing\n", port_symbol); + return; + } + + if (type != jalv->forge.Float) { + fprintf(stderr, "error: Preset port `%s' value is a <%s>, not float\n", + port_symbol, jalv->unmap.unmap(jalv->unmap.handle, type)); + return; + } + + const float fvalue = *(float*)value; + + // Send value to plugin + jalv_ui_write(jalv, port->index, sizeof(fvalue), 0, &fvalue); + + // Update UI + if (jalv->has_ui) { + char buf[sizeof(ControlChange) + sizeof(fvalue)]; + ControlChange* ev = (ControlChange*)buf; + ev->index = port->index; + ev->protocol = 0; + ev->size = sizeof(fvalue); + *(float*)ev->body = fvalue; + jack_ringbuffer_write(jalv->plugin_events, buf, sizeof(buf)); + } +} + +void +jalv_apply_state(Jalv* jalv, LilvState* state) +{ + if (state) { + const bool must_pause = (jalv->play_state == JALV_RUNNING); + if (must_pause) { + jalv->play_state = JALV_PAUSE_REQUESTED; + zix_sem_wait(&jalv->paused); + } + + lilv_state_restore( + state, jalv->instance, set_port_value, jalv, 0, NULL); + + if (must_pause) { + jalv->play_state = JALV_RUNNING; + } + } +} + +int +jalv_apply_preset(Jalv* jalv, const LilvNode* preset) +{ + LilvState* state = lilv_state_new_from_world( + jalv->world, &jalv->map, preset); + jalv_apply_state(jalv, state); + lilv_state_free(state); + return 0; +} + +int +jalv_save_preset(Jalv* jalv, + const char* dir, + const char* uri, + const char* label, + const char* filename) +{ + LilvState* const state = lilv_state_new_from_instance( + jalv->plugin, jalv->instance, &jalv->map, + jalv->temp_dir, dir, dir, dir, + get_port_value, jalv, + LV2_STATE_IS_POD|LV2_STATE_IS_PORTABLE, NULL); + + if (label) { + lilv_state_set_label(state, label); + } + + int ret = lilv_state_save( + jalv->world, &jalv->map, &jalv->unmap, state, uri, dir, filename); + + lilv_state_free(state); + + return ret; +} diff -Nru jalv-0~svn3409/src/symap.c jalv-1.0.0~dfsg0/src/symap.c --- jalv-0~svn3409/src/symap.c 2011-06-19 21:16:32.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/symap.c 2012-03-27 03:41:41.000000000 +0000 @@ -1,5 +1,5 @@ /* - Copyright 2011 David Robillard + Copyright 2011-2012 David Robillard Permission to use, copy, modify, and/or distribute this software for any purpose with or without fee is hereby granted, provided that the above @@ -118,11 +118,11 @@ } upper = i - 1; } else { - lower = i + 1; + lower = ++i; } } - assert(strcmp(map->symbols[map->index[i] - 1], sym) > 0); + assert(!*exact || strcmp(map->symbols[map->index[i] - 1], sym) > 0); return i; } @@ -153,7 +153,7 @@ char* const str = symap_strdup(sym); /* Append new symbol to symbols array */ - map->symbols = realloc(map->symbols, map->size * sizeof(char*)); + map->symbols = realloc(map->symbols, map->size * sizeof(str)); map->symbols[id - 1] = str; /* Insert new index element into sorted index */ @@ -172,7 +172,9 @@ const char* symap_unmap(Symap* map, uint32_t id) { - if (id <= map->size) { + if (id == 0) { + return NULL; + } else if (id <= map->size) { return map->symbols[id - 1]; } return NULL; @@ -187,12 +189,12 @@ { fprintf(stderr, "{\n"); for (uint32_t i = 0; i < map->size; ++i) { - fprintf(stderr, "\t%u = %s\n", map->index[i], map->symbols[map->index[i] - 1]); + fprintf(stderr, "\t%u = %s\n", + map->index[i], map->symbols[map->index[i] - 1]); } fprintf(stderr, "}\n"); } - int main() { @@ -207,18 +209,18 @@ fprintf(stderr, "error: Symbol already mapped\n"); return 1; } - + const uint32_t id = symap_map(map, syms[i]); if (strcmp(map->symbols[id - 1], syms[i])) { fprintf(stderr, "error: Corrupt symbol table\n"); - return 1; + return 1; } if (symap_map(map, syms[i]) != id) { fprintf(stderr, "error: Remapped symbol to a different ID\n"); return 1; } - + symap_dump(map); } diff -Nru jalv-0~svn3409/src/symap.h jalv-1.0.0~dfsg0/src/symap.h --- jalv-0~svn3409/src/symap.h 2011-06-19 21:16:32.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/symap.h 2012-03-27 03:41:41.000000000 +0000 @@ -17,13 +17,12 @@ /** @file symap.h API for Symap, a basic symbol map (string interner). - Particularly useful and intended for implementation of the LV2 URI map and - URI unmap extensions. + Particularly useful for implementing LV2 URI mapping. - @see LV2 URI Map - @see LV2 URI Unmap + @see LV2 URID + @see LV2 URI Map */ - + #ifndef SYMAP_H #define SYMAP_H diff -Nru jalv-0~svn3409/src/worker.c jalv-1.0.0~dfsg0/src/worker.c --- jalv-0~svn3409/src/worker.c 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/worker.c 2012-04-09 17:36:22.000000000 +0000 @@ -0,0 +1,111 @@ +/* + Copyright 2007-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "worker.h" + +LV2_Worker_Status +jalv_worker_respond(LV2_Worker_Respond_Handle handle, + uint32_t size, + const void* data) +{ + Jalv* jalv = (Jalv*)handle; + jack_ringbuffer_write(jalv->worker.responses, + (const char*)&size, sizeof(size)); + jack_ringbuffer_write(jalv->worker.responses, data, size); + return LV2_WORKER_SUCCESS; +} + +static void* +worker_func(void* data) +{ + Jalv* jalv = (Jalv*)data; + void* buf = NULL; + while (true) { + zix_sem_wait(&jalv->worker.sem); + if (jalv->exit) { + break; + } + + uint32_t size = 0; + jack_ringbuffer_read(jalv->worker.requests, (char*)&size, sizeof(size)); + + buf = realloc(buf, size); + jack_ringbuffer_read(jalv->worker.requests, buf, size); + + jalv->worker.iface->work( + jalv->instance->lv2_handle, jalv_worker_respond, jalv, size, buf); + } + + free(buf); + return NULL; +} + +void +jalv_worker_init(Jalv* jalv, JalvWorker* worker, LV2_Worker_Interface* iface) +{ + worker->iface = iface; + zix_thread_create(&worker->thread, 4096, worker_func, jalv); + worker->requests = jack_ringbuffer_create(4096); + worker->responses = jack_ringbuffer_create(4096); + worker->response = malloc(4096); + jack_ringbuffer_mlock(worker->requests); + jack_ringbuffer_mlock(worker->responses); +} + +void +jalv_worker_finish(JalvWorker* worker) +{ + if (worker->requests) { + zix_sem_post(&worker->sem); + zix_thread_join(worker->thread, NULL); + jack_ringbuffer_free(worker->requests); + jack_ringbuffer_free(worker->responses); + free(worker->response); + } +} + +LV2_Worker_Status +jalv_worker_schedule(LV2_Worker_Schedule_Handle handle, + uint32_t size, + const void* data) +{ + Jalv* jalv = (Jalv*)handle; + jack_ringbuffer_write(jalv->worker.requests, + (const char*)&size, sizeof(size)); + jack_ringbuffer_write(jalv->worker.requests, data, size); + zix_sem_post(&jalv->worker.sem); + return LV2_WORKER_SUCCESS; +} + +void +jalv_worker_emit_responses(Jalv* jalv, JalvWorker* worker) +{ + if (worker->responses) { + uint32_t read_space = jack_ringbuffer_read_space(worker->responses); + while (read_space) { + uint32_t size = 0; + jack_ringbuffer_read(worker->responses, (char*)&size, sizeof(size)); + + jack_ringbuffer_read( + worker->responses, worker->response, size); + + worker->iface->work_response( + jalv->instance->lv2_handle, size, worker->response); + + read_space -= sizeof(size) + size; + } + } +} diff -Nru jalv-0~svn3409/src/worker.h jalv-1.0.0~dfsg0/src/worker.h --- jalv-0~svn3409/src/worker.h 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/worker.h 2012-03-31 03:32:27.000000000 +0000 @@ -0,0 +1,35 @@ +/* + Copyright 2007-2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#include "lv2/lv2plug.in/ns/ext/worker/worker.h" + +#include "jalv_internal.h" + +void +jalv_worker_init(Jalv* jalv, + JalvWorker* worker, + LV2_Worker_Interface* iface); + +void +jalv_worker_finish(JalvWorker* worker); + +LV2_Worker_Status +jalv_worker_schedule(LV2_Worker_Schedule_Handle handle, + uint32_t size, + const void* data); + +void +jalv_worker_emit_responses(Jalv* jalv, JalvWorker* worker); diff -Nru jalv-0~svn3409/src/zix/common.h jalv-1.0.0~dfsg0/src/zix/common.h --- jalv-0~svn3409/src/zix/common.h 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/zix/common.h 2012-03-27 03:41:41.000000000 +0000 @@ -0,0 +1,83 @@ +/* + Copyright 2011 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef ZIX_COMMON_H +#define ZIX_COMMON_H + +/** + @addtogroup zix + @{ +*/ + +/** @cond */ +#ifdef ZIX_SHARED +# ifdef _WIN32 +# define ZIX_LIB_IMPORT __declspec(dllimport) +# define ZIX_LIB_EXPORT __declspec(dllexport) +# else +# define ZIX_LIB_IMPORT __attribute__((visibility("default"))) +# define ZIX_LIB_EXPORT __attribute__((visibility("default"))) +# endif +# ifdef ZIX_INTERNAL +# define ZIX_API ZIX_LIB_EXPORT +# else +# define ZIX_API ZIX_LIB_IMPORT +# endif +#else +# define ZIX_API +#endif +/** @endcond */ + +#ifdef __cplusplus +extern "C" { +#else +# include +#endif + +typedef enum { + ZIX_STATUS_SUCCESS, + ZIX_STATUS_ERROR, + ZIX_STATUS_NO_MEM, + ZIX_STATUS_NOT_FOUND, + ZIX_STATUS_EXISTS, + ZIX_STATUS_BAD_ARG, + ZIX_STATUS_BAD_PERMS, +} ZixStatus; + +/** + Function for comparing two elements. +*/ +typedef int (*ZixComparator)(const void* a, const void* b, void* user_data); + +/** + Function for testing equality of two elements. +*/ +typedef bool (*ZixEqualFunc)(const void* a, const void* b); + +/** + Function to destroy an element. +*/ +typedef void (*ZixDestroyFunc)(void* ptr); + +/** + @} +*/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* ZIX_COMMON_H */ diff -Nru jalv-0~svn3409/src/zix/sem.h jalv-1.0.0~dfsg0/src/zix/sem.h --- jalv-0~svn3409/src/zix/sem.h 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/zix/sem.h 2012-03-27 03:41:41.000000000 +0000 @@ -0,0 +1,226 @@ +/* + Copyright 2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef ZIX_SEM_H +#define ZIX_SEM_H + +#ifdef __APPLE__ +# include +#elif defined(_WIN32) +# include +#else +# include +#endif + +#include "zix/common.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/** + @addtogroup zix + @{ + @name Semaphore + @{ +*/ + +/** + A counting semaphore. + + This is an integer that is always positive, and has two main operations: + increment (post) and decrement (wait). If a decrement can not be performed + (i.e. the value is 0) the caller will be blocked until another thread posts + and the operation can succeed. + + Semaphores can be created with any starting value, but typically this will + be 0 so the semaphore can be used as a simple signal where each post + corresponds to one wait. + + Semaphores are very efficient (much moreso than a mutex/cond pair). In + particular, at least on Linux, post is async-signal-safe, which means it + does not block and will not be interrupted. If you need to signal from + a realtime thread, this is the most appropriate primitive to use. +*/ +typedef struct ZixSemImpl ZixSem; + +/** + Create and initialize @c sem to @c initial. +*/ +static inline ZixStatus +zix_sem_init(ZixSem* sem, unsigned initial); + +/** + Destroy @c sem. +*/ +static inline void +zix_sem_destroy(ZixSem* sem); + +/** + Increment (and signal any waiters). + Realtime safe. +*/ +static inline void +zix_sem_post(ZixSem* sem); + +/** + Wait until count is > 0, then decrement. + Obviously not realtime safe. +*/ +static inline void +zix_sem_wait(ZixSem* sem); + +/** + Non-blocking version of wait(). + + @return true if decrement was successful (lock was acquired). +*/ +static inline bool +zix_sem_try_wait(ZixSem* sem); + +/** + @cond +*/ + +#ifdef __APPLE__ + +struct ZixSemImpl { + semaphore_t sem; +}; + +static inline ZixStatus +zix_sem_init(ZixSem* sem, unsigned initial) +{ + return semaphore_create(mach_task_self(), &sem->sem, SYNC_POLICY_FIFO, 0) + ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS; +} + +static inline void +zix_sem_destroy(ZixSem* sem) +{ + semaphore_destroy(mach_task_self(), sem->sem); +} + +static inline void +zix_sem_post(ZixSem* sem) +{ + semaphore_signal(sem->sem); +} + +static inline void +zix_sem_wait(ZixSem* sem) +{ + semaphore_wait(sem->sem); +} + +static inline bool +zix_sem_try_wait(ZixSem* sem) +{ + const mach_timespec_t zero = { 0, 0 }; + return semaphore_timedwait(sem->sem, zero) == KERN_SUCCESS; +} + +#elif defined(_WIN32) + +struct ZixSemImpl { + HANDLE sem; +}; + +static inline ZixStatus +zix_sem_init(ZixSem* sem, unsigned initial) +{ + sem->sem = CreateSemaphore(NULL, initial, LONG_MAX, NULL); + return (sem->sem) ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS; +} + +static inline void +zix_sem_destroy(ZixSem* sem) +{ + CloseHandle(sem->sem); +} + +static inline void +zix_sem_post(ZixSem* sem) +{ + ReleaseSemaphore(sem->sem, 1, NULL); +} + +static inline void +zix_sem_wait(ZixSem* sem) +{ + WaitForSingleObject(sem->sem, INFINITE); +} + +static inline bool +zix_sem_try_wait(ZixSem* sem) +{ + WaitForSingleObject(sem->sem, 0); +} + +#else /* !defined(__APPLE__) && !defined(_WIN32) */ + +struct ZixSemImpl { + sem_t sem; +}; + +static inline ZixStatus +zix_sem_init(ZixSem* sem, unsigned initial) +{ + return sem_init(&sem->sem, 0, initial) + ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS; +} + +static inline void +zix_sem_destroy(ZixSem* sem) +{ + sem_destroy(&sem->sem); +} + +static inline void +zix_sem_post(ZixSem* sem) +{ + sem_post(&sem->sem); +} + +static inline void +zix_sem_wait(ZixSem* sem) +{ + /* Note that sem_wait always returns 0 in practice, except in + gdb (at least), where it returns nonzero, so the while is + necessary (and is the correct/safe solution in any case). + */ + while (sem_wait(&sem->sem) != 0) {} +} + +static inline bool +zix_sem_try_wait(ZixSem* sem) +{ + return (sem_trywait(&sem->sem) == 0); +} + +#endif + +/** + @endcond + @} + @} +*/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* ZIX_SEM_H */ diff -Nru jalv-0~svn3409/src/zix/thread.h jalv-1.0.0~dfsg0/src/zix/thread.h --- jalv-0~svn3409/src/zix/thread.h 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/src/zix/thread.h 2012-03-27 03:41:41.000000000 +0000 @@ -0,0 +1,133 @@ +/* + Copyright 2012 David Robillard + + Permission to use, copy, modify, and/or distribute this software for any + purpose with or without fee is hereby granted, provided that the above + copyright notice and this permission notice appear in all copies. + + THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF + MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES + WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN + ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF + OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. +*/ + +#ifndef ZIX_THREAD_H +#define ZIX_THREAD_H + +#ifdef _WIN32 +# include +#else +# include +# include +#endif + +#include "zix/common.h" + +#ifdef __cplusplus +extern "C" { +#else +# include +#endif + +/** + @addtogroup zix + @{ + @name Thread + @{ +*/ + +#ifdef _WIN32 +typedef HANDLE ZixThread; +#else +typedef pthread_t ZixThread; +#endif + +/** + Initialize @c thread to a new thread. + + The thread will immediately be launched, calling @c function with @c arg + as the only parameter. +*/ +static inline ZixStatus +zix_thread_create(ZixThread* thread, + size_t stack_size, + void* (*function)(void*), + void* arg); + +/** + Join @c thread (block until @c thread exits). +*/ +static inline ZixStatus +zix_thread_join(ZixThread thread, void** retval); + +#ifdef _WIN32 + +static inline ZixStatus +zix_thread_create(ZixThread* thread, + size_t stack_size, + void* (*function)(void*), + void* arg) +{ + *thread = CreateThread(NULL, stack_size, + (LPTHREAD_START_ROUTINE)function, arg, + 0, NULL); + return *thread ? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR; +} + +static inline ZixStatus +zix_thread_join(ZixThread thread, void** retval) +{ + return WaitForSingleObject(thread, INFINITE) + ? ZIX_STATUS_SUCCESS : ZIX_STATUS_ERROR; +} + +#else /* !defined(_WIN32) */ + +static inline ZixStatus +zix_thread_create(ZixThread* thread, + size_t stack_size, + void* (*function)(void*), + void* arg) +{ + pthread_attr_t attr; + pthread_attr_init(&attr); + pthread_attr_setstacksize(&attr, stack_size); + + const int ret = pthread_create(thread, NULL, function, arg); + pthread_attr_destroy(&attr); + + if (ret == EAGAIN) { + return ZIX_STATUS_NO_MEM; + } else if (ret == EINVAL) { + return ZIX_STATUS_BAD_ARG; + } else if (ret == EPERM) { + return ZIX_STATUS_BAD_PERMS; + } else if (ret) { + return ZIX_STATUS_ERROR; + } + + return ZIX_STATUS_SUCCESS; +} + +static inline ZixStatus +zix_thread_join(ZixThread thread, void** retval) +{ + return pthread_join(thread, retval) + ? ZIX_STATUS_ERROR : ZIX_STATUS_SUCCESS; +} + +#endif + +/** + @} + @} +*/ + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* ZIX_THREAD_H */ Binary files /tmp/kVFSXUVmRN/jalv-0~svn3409/waf and /tmp/06VDuCX51v/jalv-1.0.0~dfsg0/waf differ diff -Nru jalv-0~svn3409/waflib/ansiterm.py jalv-1.0.0~dfsg0/waflib/ansiterm.py --- jalv-0~svn3409/waflib/ansiterm.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/ansiterm.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,173 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys,os +try: + if not(sys.stderr.isatty()and sys.stdout.isatty()): + raise ValueError('not a tty') + from ctypes import* + class COORD(Structure): + _fields_=[("X",c_short),("Y",c_short)] + class SMALL_RECT(Structure): + _fields_=[("Left",c_short),("Top",c_short),("Right",c_short),("Bottom",c_short)] + class CONSOLE_SCREEN_BUFFER_INFO(Structure): + _fields_=[("Size",COORD),("CursorPosition",COORD),("Attributes",c_short),("Window",SMALL_RECT),("MaximumWindowSize",COORD)] + class CONSOLE_CURSOR_INFO(Structure): + _fields_=[('dwSize',c_ulong),('bVisible',c_int)] + sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + csinfo=CONSOLE_CURSOR_INFO() + hconsole=windll.kernel32.GetStdHandle(-11) + windll.kernel32.GetConsoleScreenBufferInfo(hconsole,byref(sbinfo)) + if sbinfo.Size.X<9 or sbinfo.Size.Y<9:raise ValueError('small console') + windll.kernel32.GetConsoleCursorInfo(hconsole,byref(csinfo)) +except Exception: + pass +else: + import re,threading + try: + _type=unicode + except: + _type=str + to_int=lambda number,default:number and int(number)or default + wlock=threading.Lock() + STD_OUTPUT_HANDLE=-11 + STD_ERROR_HANDLE=-12 + class AnsiTerm(object): + def __init__(self): + self.encoding=sys.stdout.encoding + self.hconsole=windll.kernel32.GetStdHandle(STD_OUTPUT_HANDLE) + self.cursor_history=[] + self.orig_sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + self.orig_csinfo=CONSOLE_CURSOR_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(self.orig_sbinfo)) + windll.kernel32.GetConsoleCursorInfo(hconsole,byref(self.orig_csinfo)) + def screen_buffer_info(self): + sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(sbinfo)) + return sbinfo + def clear_line(self,param): + mode=param and int(param)or 0 + sbinfo=self.screen_buffer_info() + if mode==1: + line_start=COORD(0,sbinfo.CursorPosition.Y) + line_length=sbinfo.Size.X + elif mode==2: + line_start=COORD(sbinfo.CursorPosition.X,sbinfo.CursorPosition.Y) + line_length=sbinfo.Size.X-sbinfo.CursorPosition.X + else: + line_start=sbinfo.CursorPosition + line_length=sbinfo.Size.X-sbinfo.CursorPosition.X + chars_written=c_int() + windll.kernel32.FillConsoleOutputCharacterA(self.hconsole,c_wchar(' '),line_length,line_start,byref(chars_written)) + windll.kernel32.FillConsoleOutputAttribute(self.hconsole,sbinfo.Attributes,line_length,line_start,byref(chars_written)) + def clear_screen(self,param): + mode=to_int(param,0) + sbinfo=self.screen_buffer_info() + if mode==1: + clear_start=COORD(0,0) + clear_length=sbinfo.CursorPosition.X*sbinfo.CursorPosition.Y + elif mode==2: + clear_start=COORD(0,0) + clear_length=sbinfo.Size.X*sbinfo.Size.Y + windll.kernel32.SetConsoleCursorPosition(self.hconsole,clear_start) + else: + clear_start=sbinfo.CursorPosition + clear_length=((sbinfo.Size.X-sbinfo.CursorPosition.X)+sbinfo.Size.X*(sbinfo.Size.Y-sbinfo.CursorPosition.Y)) + chars_written=c_int() + windll.kernel32.FillConsoleOutputCharacterA(self.hconsole,c_wchar(' '),clear_length,clear_start,byref(chars_written)) + windll.kernel32.FillConsoleOutputAttribute(self.hconsole,sbinfo.Attributes,clear_length,clear_start,byref(chars_written)) + def push_cursor(self,param): + sbinfo=self.screen_buffer_info() + self.cursor_history.append(sbinfo.CursorPosition) + def pop_cursor(self,param): + if self.cursor_history: + old_pos=self.cursor_history.pop() + windll.kernel32.SetConsoleCursorPosition(self.hconsole,old_pos) + def set_cursor(self,param): + y,sep,x=param.partition(';') + x=to_int(x,1)-1 + y=to_int(y,1)-1 + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,x),sbinfo.Size.X),min(max(0,y),sbinfo.Size.Y)) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def set_column(self,param): + x=to_int(param,1)-1 + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,x),sbinfo.Size.X),sbinfo.CursorPosition.Y) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def move_cursor(self,x_offset=0,y_offset=0): + sbinfo=self.screen_buffer_info() + new_pos=COORD(min(max(0,sbinfo.CursorPosition.X+x_offset),sbinfo.Size.X),min(max(0,sbinfo.CursorPosition.Y+y_offset),sbinfo.Size.Y)) + windll.kernel32.SetConsoleCursorPosition(self.hconsole,new_pos) + def move_up(self,param): + self.move_cursor(y_offset=-to_int(param,1)) + def move_down(self,param): + self.move_cursor(y_offset=to_int(param,1)) + def move_left(self,param): + self.move_cursor(x_offset=-to_int(param,1)) + def move_right(self,param): + self.move_cursor(x_offset=to_int(param,1)) + def next_line(self,param): + sbinfo=self.screen_buffer_info() + self.move_cursor(x_offset=-sbinfo.CursorPosition.X,y_offset=to_int(param,1)) + def prev_line(self,param): + sbinfo=self.screen_buffer_info() + self.move_cursor(x_offset=-sbinfo.CursorPosition.X,y_offset=-to_int(param,1)) + def rgb2bgr(self,c): + return((c&1)<<2)|(c&2)|((c&4)>>2) + def set_color(self,param): + cols=param.split(';') + sbinfo=CONSOLE_SCREEN_BUFFER_INFO() + windll.kernel32.GetConsoleScreenBufferInfo(self.hconsole,byref(sbinfo)) + attr=sbinfo.Attributes + for c in cols: + c=to_int(c,0) + if c in range(30,38): + attr=(attr&0xfff0)|self.rgb2bgr(c-30) + elif c in range(40,48): + attr=(attr&0xff0f)|(self.rgb2bgr(c-40)<<4) + elif c==0: + attr=self.orig_sbinfo.Attributes + elif c==1: + attr|=0x08 + elif c==4: + attr|=0x80 + elif c==7: + attr=(attr&0xff88)|((attr&0x70)>>4)|((attr&0x07)<<4) + windll.kernel32.SetConsoleTextAttribute(self.hconsole,attr) + def show_cursor(self,param): + csinfo.bVisible=1 + windll.kernel32.SetConsoleCursorInfo(self.hconsole,byref(csinfo)) + def hide_cursor(self,param): + csinfo.bVisible=0 + windll.kernel32.SetConsoleCursorInfo(self.hconsole,byref(csinfo)) + ansi_command_table={'A':move_up,'B':move_down,'C':move_right,'D':move_left,'E':next_line,'F':prev_line,'G':set_column,'H':set_cursor,'f':set_cursor,'J':clear_screen,'K':clear_line,'h':show_cursor,'l':hide_cursor,'m':set_color,'s':push_cursor,'u':pop_cursor,} + ansi_tokens=re.compile('(?:\x1b\[([0-9?;]*)([a-zA-Z])|([^\x1b]+))') + def write(self,text): + try: + wlock.acquire() + for param,cmd,txt in self.ansi_tokens.findall(text): + if cmd: + cmd_func=self.ansi_command_table.get(cmd) + if cmd_func: + cmd_func(self,param) + else: + self.writeconsole(txt) + finally: + wlock.release() + def writeconsole(self,txt): + chars_written=c_int() + writeconsole=windll.kernel32.WriteConsoleA + if isinstance(txt,_type): + writeconsole=windll.kernel32.WriteConsoleW + TINY_STEP=3000 + for x in range(0,len(txt),TINY_STEP): + tiny=txt[x:x+TINY_STEP] + writeconsole(self.hconsole,tiny,len(tiny),byref(chars_written),None) + def flush(self): + pass + def isatty(self): + return True + sys.stderr=sys.stdout=AnsiTerm() + os.environ['TERM']='vt100' diff -Nru jalv-0~svn3409/waflib/Build.py jalv-1.0.0~dfsg0/waflib/Build.py --- jalv-0~svn3409/waflib/Build.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Build.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,731 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,errno,re,shutil +try:import cPickle +except:import pickle as cPickle +from waflib import Runner,TaskGen,Utils,ConfigSet,Task,Logs,Options,Context,Errors +import waflib.Node +CACHE_DIR='c4che' +CACHE_SUFFIX='_cache.py' +INSTALL=1337 +UNINSTALL=-1337 +SAVED_ATTRS='root node_deps raw_deps task_sigs'.split() +CFG_FILES='cfg_files' +POST_AT_ONCE=0 +POST_LAZY=1 +POST_BOTH=2 +class BuildContext(Context.Context): + '''executes the build''' + cmd='build' + variant='' + def __init__(self,**kw): + super(BuildContext,self).__init__(**kw) + self.is_install=0 + self.top_dir=kw.get('top_dir',Context.top_dir) + self.run_dir=kw.get('run_dir',Context.run_dir) + self.post_mode=POST_AT_ONCE + self.out_dir=kw.get('out_dir',Context.out_dir) + self.cache_dir=kw.get('cache_dir',None) + if not self.cache_dir: + self.cache_dir=self.out_dir+os.sep+CACHE_DIR + self.all_envs={} + self.task_sigs={} + self.node_deps={} + self.raw_deps={} + self.cache_dir_contents={} + self.task_gen_cache_names={} + self.launch_dir=Context.launch_dir + self.jobs=Options.options.jobs + self.targets=Options.options.targets + self.keep=Options.options.keep + self.cache_global=Options.cache_global + self.nocache=Options.options.nocache + self.progress_bar=Options.options.progress_bar + self.deps_man=Utils.defaultdict(list) + self.current_group=0 + self.groups=[] + self.group_names={} + def get_variant_dir(self): + if not self.variant: + return self.out_dir + return os.path.join(self.out_dir,self.variant) + variant_dir=property(get_variant_dir,None) + def __call__(self,*k,**kw): + kw['bld']=self + ret=TaskGen.task_gen(*k,**kw) + self.task_gen_cache_names={} + self.add_to_group(ret,group=kw.get('group',None)) + return ret + def __copy__(self): + raise Errors.WafError('build contexts are not supposed to be copied') + def install_files(self,*k,**kw): + pass + def install_as(self,*k,**kw): + pass + def symlink_as(self,*k,**kw): + pass + def load_envs(self): + node=self.root.find_node(self.cache_dir) + if not node: + raise Errors.WafError('The project was not configured: run "waf configure" first!') + lst=node.ant_glob('**/*%s'%CACHE_SUFFIX,quiet=True) + if not lst: + raise Errors.WafError('The cache directory is empty: reconfigure the project') + for x in lst: + name=x.path_from(node).replace(CACHE_SUFFIX,'').replace('\\','/') + env=ConfigSet.ConfigSet(x.abspath()) + self.all_envs[name]=env + for f in env[CFG_FILES]: + newnode=self.root.find_resource(f) + try: + h=Utils.h_file(newnode.abspath()) + except(IOError,AttributeError): + Logs.error('cannot find %r'%f) + h=Utils.SIG_NIL + newnode.sig=h + def init_dirs(self): + if not(os.path.isabs(self.top_dir)and os.path.isabs(self.out_dir)): + raise Errors.WafError('The project was not configured: run "waf configure" first!') + self.path=self.srcnode=self.root.find_dir(self.top_dir) + self.bldnode=self.root.make_node(self.variant_dir) + self.bldnode.mkdir() + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.execute_build() + def execute_build(self): + Logs.info("Waf: Entering directory `%s'"%self.variant_dir) + self.recurse([self.run_dir]) + self.pre_build() + self.timer=Utils.Timer() + if self.progress_bar: + sys.stderr.write(Logs.colors.cursor_off) + try: + self.compile() + finally: + if self.progress_bar==1: + c=len(self.returned_tasks)or 1 + self.to_log(self.progress_line(c,c,Logs.colors.BLUE,Logs.colors.NORMAL)) + print('') + sys.stdout.flush() + sys.stderr.write(Logs.colors.cursor_on) + Logs.info("Waf: Leaving directory `%s'"%self.variant_dir) + self.post_build() + def restore(self): + try: + env=ConfigSet.ConfigSet(os.path.join(self.cache_dir,'build.config.py')) + except(IOError,OSError): + pass + else: + if env['version']').ljust(cols) + msg=Utils.indicator%(left,bar,right) + return msg + def declare_chain(self,*k,**kw): + return TaskGen.declare_chain(*k,**kw) + def pre_build(self): + for m in getattr(self,'pre_funs',[]): + m(self) + def post_build(self): + for m in getattr(self,'post_funs',[]): + m(self) + def add_pre_fun(self,meth): + try: + self.pre_funs.append(meth) + except AttributeError: + self.pre_funs=[meth] + def add_post_fun(self,meth): + try: + self.post_funs.append(meth) + except AttributeError: + self.post_funs=[meth] + def get_group(self,x): + if not self.groups: + self.add_group() + if x is None: + return self.groups[self.current_group] + if x in self.group_names: + return self.group_names[x] + return self.groups[x] + def add_to_group(self,tgen,group=None): + assert(isinstance(tgen,TaskGen.task_gen)or isinstance(tgen,Task.TaskBase)) + tgen.bld=self + self.get_group(group).append(tgen) + def get_group_name(self,g): + if not isinstance(g,list): + g=self.groups[g] + for x in self.group_names: + if id(self.group_names[x])==id(g): + return x + return'' + def get_group_idx(self,tg): + se=id(tg) + for i in range(len(self.groups)): + for t in self.groups[i]: + if id(t)==se: + return i + return None + def add_group(self,name=None,move=True): + if name and name in self.group_names: + Logs.error('add_group: name %s already present'%name) + g=[] + self.group_names[name]=g + self.groups.append(g) + if move: + self.current_group=len(self.groups)-1 + def set_group(self,idx): + if isinstance(idx,str): + g=self.group_names[idx] + for i in range(len(self.groups)): + if id(g)==id(self.groups[i]): + self.current_group=i + else: + self.current_group=idx + def total(self): + total=0 + for group in self.groups: + for tg in group: + try: + total+=len(tg.tasks) + except AttributeError: + total+=1 + return total + def get_targets(self): + to_post=[] + min_grp=0 + for name in self.targets.split(','): + tg=self.get_tgen_by_name(name) + if not tg: + raise Errors.WafError('target %r does not exist'%name) + m=self.get_group_idx(tg) + if m>min_grp: + min_grp=m + to_post=[tg] + elif m==min_grp: + to_post.append(tg) + return(min_grp,to_post) + def post_group(self): + if self.targets=='*': + for tg in self.groups[self.cur]: + try: + f=tg.post + except AttributeError: + pass + else: + f() + elif self.targets: + if self.cur%r'%(src,tgt)) + Utils.check_dir(d) + srclbl=src.replace(self.srcnode.abspath()+os.sep,'') + if not Options.options.force: + try: + st1=os.stat(tgt) + st2=os.stat(src) + except OSError: + pass + else: + if st1.st_mtime+2>=st2.st_mtime and st1.st_size==st2.st_size: + if not self.progress_bar: + Logs.info('- install %s (from %s)'%(tgt,srclbl)) + return False + if not self.progress_bar: + Logs.info('+ install %s (from %s)'%(tgt,srclbl)) + try: + os.remove(tgt) + except OSError: + pass + try: + shutil.copy2(src,tgt) + os.chmod(tgt,chmod) + except IOError: + try: + os.stat(src) + except(OSError,IOError): + Logs.error('File %r does not exist'%src) + raise Errors.WafError('Could not install the file %r'%tgt) + def do_link(self,src,tgt): + d,_=os.path.split(tgt) + Utils.check_dir(d) + link=False + if not os.path.islink(tgt): + link=True + elif os.readlink(tgt)!=src: + link=True + if link: + try:os.remove(tgt) + except OSError:pass + if not self.progress_bar: + Logs.info('+ symlink %s (to %s)'%(tgt,src)) + os.symlink(src,tgt) + else: + if not self.progress_bar: + Logs.info('- symlink %s (to %s)'%(tgt,src)) + def run_task_now(self,tsk,postpone): + tsk.post() + if not postpone: + if tsk.runnable_status()==Task.ASK_LATER: + raise self.WafError('cannot post the task %r'%tsk) + tsk.run() + def install_files(self,dest,files,env=None,chmod=Utils.O644,relative_trick=False,cwd=None,add=True,postpone=True): + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.path=cwd or self.path + tsk.chmod=chmod + if isinstance(files,waflib.Node.Node): + tsk.source=[files] + else: + tsk.source=Utils.to_list(files) + tsk.dest=dest + tsk.exec_task=tsk.exec_install_files + tsk.relative_trick=relative_trick + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk + def install_as(self,dest,srcfile,env=None,chmod=Utils.O644,cwd=None,add=True,postpone=True): + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.path=cwd or self.path + tsk.chmod=chmod + tsk.source=[srcfile] + tsk.dest=dest + tsk.exec_task=tsk.exec_install_as + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk + def symlink_as(self,dest,src,env=None,cwd=None,add=True,postpone=True): + if Utils.is_win32: + return + tsk=inst(env=env or self.env) + tsk.bld=self + tsk.dest=dest + tsk.path=cwd or self.path + tsk.source=[] + tsk.link=src + tsk.exec_task=tsk.exec_symlink_as + if add:self.add_to_group(tsk) + self.run_task_now(tsk,postpone) + return tsk +class UninstallContext(InstallContext): + '''removes the targets installed''' + cmd='uninstall' + def __init__(self,**kw): + super(UninstallContext,self).__init__(**kw) + self.is_install=UNINSTALL + def do_install(self,src,tgt,chmod=Utils.O644): + if not self.progress_bar: + Logs.info('- remove %s'%tgt) + self.uninstall.append(tgt) + try: + os.remove(tgt) + except OSError ,e: + if e.errno!=errno.ENOENT: + if not getattr(self,'uninstall_error',None): + self.uninstall_error=True + Logs.warn('build: some files could not be uninstalled (retry with -vv to list them)') + if Logs.verbose>1: + Logs.warn('could not remove %s (error code %r)'%(e.filename,e.errno)) + while tgt: + tgt=os.path.dirname(tgt) + try: + os.rmdir(tgt) + except OSError: + break + def do_link(self,src,tgt): + try: + if not self.progress_bar: + Logs.info('- unlink %s'%tgt) + os.remove(tgt) + except OSError: + pass + while tgt: + tgt=os.path.dirname(tgt) + try: + os.rmdir(tgt) + except OSError: + break + def execute(self): + try: + def runnable_status(self): + return Task.SKIP_ME + setattr(Task.Task,'runnable_status_back',Task.Task.runnable_status) + setattr(Task.Task,'runnable_status',runnable_status) + super(UninstallContext,self).execute() + finally: + setattr(Task.Task,'runnable_status',Task.Task.runnable_status_back) +class CleanContext(BuildContext): + '''cleans the project''' + cmd='clean' + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.recurse([self.run_dir]) + try: + self.clean() + finally: + self.store() + def clean(self): + Logs.debug('build: clean called') + if self.bldnode!=self.srcnode: + lst=[self.root.find_or_declare(f)for f in self.env[CFG_FILES]] + for n in self.bldnode.ant_glob('**/*',excl='lock* *conf_check_*/** config.log c4che/*',quiet=True): + if n in lst: + continue + n.delete() + self.root.children={} + for v in'node_deps task_sigs raw_deps'.split(): + setattr(self,v,{}) +class ListContext(BuildContext): + '''lists the targets to execute''' + cmd='list' + def execute(self): + self.restore() + if not self.all_envs: + self.load_envs() + self.recurse([self.run_dir]) + self.pre_build() + self.timer=Utils.Timer() + for g in self.groups: + for tg in g: + try: + f=tg.post + except AttributeError: + pass + else: + f() + try: + self.get_tgen_by_name('') + except: + pass + lst=list(self.task_gen_cache_names.keys()) + lst.sort() + for k in lst: + Logs.pprint('GREEN',k) +class StepContext(BuildContext): + '''executes tasks in a step-by-step fashion, for debugging''' + cmd='step' + def __init__(self,**kw): + super(StepContext,self).__init__(**kw) + self.files=Options.options.files + def compile(self): + if not self.files: + Logs.warn('Add a pattern for the debug build, for example "waf step --files=main.c,app"') + BuildContext.compile(self) + return + for g in self.groups: + for tg in g: + try: + f=tg.post + except AttributeError: + pass + else: + f() + for pat in self.files.split(','): + matcher=self.get_matcher(pat) + for tg in g: + if isinstance(tg,Task.TaskBase): + lst=[tg] + else: + lst=tg.tasks + for tsk in lst: + do_exec=False + for node in getattr(tsk,'inputs',[]): + if matcher(node,output=False): + do_exec=True + break + for node in getattr(tsk,'outputs',[]): + if matcher(node,output=True): + do_exec=True + break + if do_exec: + ret=tsk.run() + Logs.info('%s -> exit %r'%(str(tsk),ret)) + def get_matcher(self,pat): + inn=True + out=True + if pat.startswith('in:'): + out=False + pat=pat.replace('in:','') + elif pat.startswith('out:'): + inn=False + pat=pat.replace('out:','') + anode=self.root.find_node(pat) + pattern=None + if not anode: + if not pat.startswith('^'): + pat='^.+?%s'%pat + if not pat.endswith('$'): + pat='%s$'%pat + pattern=re.compile(pat) + def match(node,output): + if output==True and not out: + return False + if output==False and not inn: + return False + if anode: + return anode==node + else: + return pattern.match(node.abspath()) + return match +BuildContext.store=Utils.nogc(BuildContext.store) +BuildContext.restore=Utils.nogc(BuildContext.restore) diff -Nru jalv-0~svn3409/waflib/ConfigSet.py jalv-1.0.0~dfsg0/waflib/ConfigSet.py --- jalv-0~svn3409/waflib/ConfigSet.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/ConfigSet.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,151 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import copy,re,os +from waflib import Logs,Utils +re_imp=re.compile('^(#)*?([^#=]*?)\ =\ (.*?)$',re.M) +class ConfigSet(object): + __slots__=('table','parent') + def __init__(self,filename=None): + self.table={} + if filename: + self.load(filename) + def __contains__(self,key): + if key in self.table:return True + try:return self.parent.__contains__(key) + except AttributeError:return False + def keys(self): + keys=set() + cur=self + while cur: + keys.update(cur.table.keys()) + cur=getattr(cur,'parent',None) + keys=list(keys) + keys.sort() + return keys + def __str__(self): + return"\n".join(["%r %r"%(x,self.__getitem__(x))for x in self.keys()]) + def __getitem__(self,key): + try: + while 1: + x=self.table.get(key,None) + if not x is None: + return x + self=self.parent + except AttributeError: + return[] + def __setitem__(self,key,value): + self.table[key]=value + def __delitem__(self,key): + self[key]=[] + def __getattr__(self,name): + if name in self.__slots__: + return object.__getattr__(self,name) + else: + return self[name] + def __setattr__(self,name,value): + if name in self.__slots__: + object.__setattr__(self,name,value) + else: + self[name]=value + def __delattr__(self,name): + if name in self.__slots__: + object.__delattr__(self,name) + else: + del self[name] + def derive(self): + newenv=ConfigSet() + newenv.parent=self + return newenv + def detach(self): + tbl=self.get_merged_dict() + try: + delattr(self,'parent') + except AttributeError: + pass + else: + keys=tbl.keys() + for x in keys: + tbl[x]=copy.deepcopy(tbl[x]) + self.table=tbl + def get_flat(self,key): + s=self[key] + if isinstance(s,str):return s + return' '.join(s) + def _get_list_value_for_modification(self,key): + try: + value=self.table[key] + except KeyError: + try:value=self.parent[key] + except AttributeError:value=[] + if isinstance(value,list): + value=value[:] + else: + value=[value] + else: + if not isinstance(value,list): + value=[value] + self.table[key]=value + return value + def append_value(self,var,val): + current_value=self._get_list_value_for_modification(var) + if isinstance(val,str): + val=[val] + current_value.extend(val) + def prepend_value(self,var,val): + if isinstance(val,str): + val=[val] + self.table[var]=val+self._get_list_value_for_modification(var) + def append_unique(self,var,val): + if isinstance(val,str): + val=[val] + current_value=self._get_list_value_for_modification(var) + for x in val: + if x not in current_value: + current_value.append(x) + def get_merged_dict(self): + table_list=[] + env=self + while 1: + table_list.insert(0,env.table) + try:env=env.parent + except AttributeError:break + merged_table={} + for table in table_list: + merged_table.update(table) + return merged_table + def store(self,filename): + try: + os.makedirs(os.path.split(filename)[0]) + except OSError: + pass + f=None + try: + f=open(filename,'w') + merged_table=self.get_merged_dict() + keys=list(merged_table.keys()) + keys.sort() + for k in keys: + if k!='undo_stack': + f.write('%s = %r\n'%(k,merged_table[k])) + finally: + if f: + f.close() + def load(self,filename): + tbl=self.table + code=Utils.readf(filename) + for m in re_imp.finditer(code): + g=m.group + tbl[g(2)]=eval(g(3)) + Logs.debug('env: %s'%str(self.table)) + def update(self,d): + for k,v in d.items(): + self[k]=v + def stash(self): + self.undo_stack=self.undo_stack+[self.table] + self.table=self.table.copy() + def revert(self): + self.table=self.undo_stack.pop(-1) diff -Nru jalv-0~svn3409/waflib/Configure.py jalv-1.0.0~dfsg0/waflib/Configure.py --- jalv-0~svn3409/waflib/Configure.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Configure.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,315 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shlex,sys,time +from waflib import ConfigSet,Utils,Options,Logs,Context,Build,Errors +try: + from urllib import request +except: + from urllib import urlopen +else: + urlopen=request.urlopen +BREAK='break' +CONTINUE='continue' +WAF_CONFIG_LOG='config.log' +autoconfig=False +conf_template='''# project %(app)s configured on %(now)s by +# waf %(wafver)s (abi %(abi)s, python %(pyver)x on %(systype)s) +# using %(args)s +#''' +def download_check(node): + pass +def download_tool(tool,force=False,ctx=None): + for x in Utils.to_list(Context.remote_repo): + for sub in Utils.to_list(Context.remote_locs): + url='/'.join((x,sub,tool+'.py')) + try: + web=urlopen(url) + try: + if web.getcode()!=200: + continue + except AttributeError: + pass + except Exception: + continue + else: + tmp=ctx.root.make_node(os.sep.join((Context.waf_dir,'waflib','extras',tool+'.py'))) + tmp.write(web.read()) + Logs.warn('Downloaded %s from %s'%(tool,url)) + download_check(tmp) + try: + module=Context.load_tool(tool) + except: + Logs.warn('The tool %s from %s is unusable'%(tool,url)) + try: + tmp.delete() + except: + pass + continue + return module + raise Errors.WafError('Could not load the Waf tool') +class ConfigurationContext(Context.Context): + '''configures the project''' + cmd='configure' + error_handlers=[] + def __init__(self,**kw): + super(ConfigurationContext,self).__init__(**kw) + self.environ=dict(os.environ) + self.all_envs={} + self.top_dir=None + self.out_dir=None + self.tools=[] + self.hash=0 + self.files=[] + self.tool_cache=[] + self.setenv('') + def setenv(self,name,env=None): + if name not in self.all_envs or env: + if not env: + env=ConfigSet.ConfigSet() + self.prepare_env(env) + else: + env=env.derive() + self.all_envs[name]=env + self.variant=name + def get_env(self): + return self.all_envs[self.variant] + def set_env(self,val): + self.all_envs[self.variant]=val + env=property(get_env,set_env) + def init_dirs(self): + top=self.top_dir + if not top: + top=Options.options.top + if not top: + top=getattr(Context.g_module,Context.TOP,None) + if not top: + top=self.path.abspath() + top=os.path.abspath(top) + self.srcnode=(os.path.isabs(top)and self.root or self.path).find_dir(top) + assert(self.srcnode) + out=self.out_dir + if not out: + out=Options.options.out + if not out: + out=getattr(Context.g_module,Context.OUT,None) + if not out: + out=Options.lockfile.replace('.lock-waf_%s_'%sys.platform,'').replace('.lock-waf','') + self.bldnode=(os.path.isabs(out)and self.root or self.path).make_node(out) + self.bldnode.mkdir() + if not os.path.isdir(self.bldnode.abspath()): + conf.fatal('could not create the build directory %s'%self.bldnode.abspath()) + def execute(self): + self.init_dirs() + self.cachedir=self.bldnode.make_node(Build.CACHE_DIR) + self.cachedir.mkdir() + path=os.path.join(self.bldnode.abspath(),WAF_CONFIG_LOG) + self.logger=Logs.make_logger(path,'cfg') + app=getattr(Context.g_module,'APPNAME','') + if app: + ver=getattr(Context.g_module,'VERSION','') + if ver: + app="%s (%s)"%(app,ver) + now=time.ctime() + pyver=sys.hexversion + systype=sys.platform + args=" ".join(sys.argv) + wafver=Context.WAFVERSION + abi=Context.ABI + self.to_log(conf_template%vars()) + self.msg('Setting top to',self.srcnode.abspath()) + self.msg('Setting out to',self.bldnode.abspath()) + if id(self.srcnode)==id(self.bldnode): + Logs.warn('Setting top == out (remember to use "update_outputs")') + elif id(self.path)!=id(self.srcnode): + if self.srcnode.is_child_of(self.path): + Logs.warn('Are you certain that you do not want to set top="." ?') + super(ConfigurationContext,self).execute() + self.store() + Context.top_dir=self.srcnode.abspath() + Context.out_dir=self.bldnode.abspath() + env=ConfigSet.ConfigSet() + env['argv']=sys.argv + env['options']=Options.options.__dict__ + env.run_dir=Context.run_dir + env.top_dir=Context.top_dir + env.out_dir=Context.out_dir + env['hash']=self.hash + env['files']=self.files + env['environ']=dict(self.environ) + if not self.env.NO_LOCK_IN_RUN: + env.store(Context.run_dir+os.sep+Options.lockfile) + if not self.env.NO_LOCK_IN_TOP: + env.store(Context.top_dir+os.sep+Options.lockfile) + if not self.env.NO_LOCK_IN_OUT: + env.store(Context.out_dir+os.sep+Options.lockfile) + def prepare_env(self,env): + if not env.PREFIX: + env.PREFIX=os.path.abspath(os.path.expanduser(Options.options.prefix)) + if not env.BINDIR: + env.BINDIR=Utils.subst_vars('${PREFIX}/bin',env) + if not env.LIBDIR: + env.LIBDIR=Utils.subst_vars('${PREFIX}/lib',env) + def store(self): + n=self.cachedir.make_node('build.config.py') + n.write('version = 0x%x\ntools = %r\n'%(Context.HEXVERSION,self.tools)) + if not self.all_envs: + self.fatal('nothing to store in the configuration context!') + for key in self.all_envs: + tmpenv=self.all_envs[key] + tmpenv.store(os.path.join(self.cachedir.abspath(),key+Build.CACHE_SUFFIX)) + def load(self,input,tooldir=None,funs=None,download=True): + tools=Utils.to_list(input) + if tooldir:tooldir=Utils.to_list(tooldir) + for tool in tools: + mag=(tool,id(self.env),funs) + if mag in self.tool_cache: + self.to_log('(tool %s is already loaded, skipping)'%tool) + continue + self.tool_cache.append(mag) + module=None + try: + module=Context.load_tool(tool,tooldir) + except ImportError ,e: + if Options.options.download: + module=download_tool(tool,ctx=self) + if not module: + self.fatal('Could not load the Waf tool %r or download a suitable replacement from the repository (sys.path %r)\n%s'%(tool,sys.path,e)) + else: + self.fatal('Could not load the Waf tool %r from %r (try the --download option?):\n%s'%(tool,sys.path,e)) + except Exception ,e: + self.to_log('imp %r (%r & %r)'%(tool,tooldir,funs)) + self.to_log(Utils.ex_stack()) + raise + if funs is not None: + self.eval_rules(funs) + else: + func=getattr(module,'configure',None) + if func: + if type(func)is type(Utils.readf):func(self) + else:self.eval_rules(func) + self.tools.append({'tool':tool,'tooldir':tooldir,'funs':funs}) + def post_recurse(self,node): + super(ConfigurationContext,self).post_recurse(node) + self.hash=hash((self.hash,node.read('rb'))) + self.files.append(node.abspath()) + def eval_rules(self,rules): + self.rules=Utils.to_list(rules) + for x in self.rules: + f=getattr(self,x) + if not f:self.fatal("No such method '%s'."%x) + try: + f() + except Exception ,e: + ret=self.err_handler(x,e) + if ret==BREAK: + break + elif ret==CONTINUE: + continue + else: + raise + def err_handler(self,fun,error): + pass +def conf(f): + def fun(*k,**kw): + mandatory=True + if'mandatory'in kw: + mandatory=kw['mandatory'] + del kw['mandatory'] + try: + return f(*k,**kw) + except Errors.ConfigurationError ,e: + if mandatory: + raise e + setattr(ConfigurationContext,f.__name__,fun) + setattr(Build.BuildContext,f.__name__,fun) + return f +def add_os_flags(self,var,dest=None): + try:self.env.append_value(dest or var,shlex.split(self.environ[var])) + except KeyError:pass +def cmd_to_list(self,cmd): + if isinstance(cmd,str)and cmd.find(' '): + try: + os.stat(cmd) + except OSError: + return shlex.split(cmd) + else: + return[cmd] + return cmd +def check_waf_version(self,mini='1.6.0',maxi='1.7.0'): + self.start_msg('Checking for waf version in %s-%s'%(str(mini),str(maxi))) + ver=Context.HEXVERSION + if Utils.num2ver(mini)>ver: + self.fatal('waf version should be at least %r (%r found)'%(Utils.num2ver(mini),ver)) + if Utils.num2ver(maxi) %r'%(filename,path_list,var,ret)) + if not ret: + self.fatal(kw.get('errmsg','')or'Could not find the program %s'%','.join(filename)) + if var: + self.env[var]=ret + return ret +def find_perl_program(self,filename,path_list=[],var=None,environ=None,exts=''): + try: + app=self.find_program(filename,path_list=path_list,var=var,environ=environ,exts=exts) + except: + self.find_program('perl',var='PERL') + app=self.find_file(filename,os.environ['PATH'].split(os.pathsep)) + if not app: + raise + if var: + self.env[var]=Utils.to_list(self.env['PERL'])+[app] + self.msg('Checking for %r'%filename,app) + +conf(add_os_flags) +conf(cmd_to_list) +conf(check_waf_version) +conf(find_file) +conf(find_program) +conf(find_perl_program) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Context.py jalv-1.0.0~dfsg0/waflib/Context.py --- jalv-0~svn3409/waflib/Context.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Context.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,299 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,imp,sys +from waflib import Utils,Errors,Logs +import waflib.Node +HEXVERSION=0x1060a00 +WAFVERSION="1.6.10" +WAFREVISION="a7e69d6b81b04729804754c4d5214da063779a65" +ABI=98 +DBFILE='.wafpickle-%d'%ABI +APPNAME='APPNAME' +VERSION='VERSION' +TOP='top' +OUT='out' +WSCRIPT_FILE='wscript' +launch_dir='' +run_dir='' +top_dir='' +out_dir='' +waf_dir='' +local_repo='' +remote_repo='http://waf.googlecode.com/git/' +remote_locs=['branches/waf-%s/waflib/extras'%WAFVERSION,'trunk/waflib/extras','trunk/waflib/Tools'] +g_module=None +STDOUT=1 +STDERR=-1 +BOTH=0 +classes=[] +def create_context(cmd_name,*k,**kw): + global classes + for x in classes: + if x.cmd==cmd_name: + return x(*k,**kw) + ctx=Context(*k,**kw) + ctx.fun=cmd_name + return ctx +class store_context(type): + def __init__(cls,name,bases,dict): + super(store_context,cls).__init__(name,bases,dict) + name=cls.__name__ + if name=='ctx'or name=='Context': + return + try: + cls.cmd + except AttributeError: + raise Errors.WafError('Missing command for the context class %r (cmd)'%name) + if not getattr(cls,'fun',None): + cls.fun=cls.cmd + global classes + classes.insert(0,cls) +ctx=store_context('ctx',(object,),{}) +class Context(ctx): + errors=Errors + tools={} + def __init__(self,**kw): + try: + rd=kw['run_dir'] + except KeyError: + global run_dir + rd=run_dir + class node_class(waflib.Node.Node): + pass + self.node_class=node_class + self.node_class.__module__="waflib.Node" + self.node_class.__name__="Nod3" + self.node_class.ctx=self + self.root=self.node_class('',None) + self.cur_script=None + self.path=self.root.find_dir(rd) + self.stack_path=[] + self.exec_dict={'ctx':self,'conf':self,'bld':self,'opt':self} + self.logger=None + def __hash__(self): + return id(self) + def load(self,tool_list,*k,**kw): + tools=Utils.to_list(tool_list) + path=Utils.to_list(kw.get('tooldir','')) + for t in tools: + module=load_tool(t,path) + fun=getattr(module,kw.get('name',self.fun),None) + if fun: + fun(self) + def execute(self): + global g_module + self.recurse([os.path.dirname(g_module.root_path)]) + def pre_recurse(self,node): + self.stack_path.append(self.cur_script) + self.cur_script=node + self.path=node.parent + def post_recurse(self,node): + self.cur_script=self.stack_path.pop() + if self.cur_script: + self.path=self.cur_script.parent + def recurse(self,dirs,name=None,mandatory=True,once=True): + try: + cache=self.recurse_cache + except: + cache=self.recurse_cache={} + for d in Utils.to_list(dirs): + if not os.path.isabs(d): + d=os.path.join(self.path.abspath(),d) + WSCRIPT=os.path.join(d,WSCRIPT_FILE) + WSCRIPT_FUN=WSCRIPT+'_'+(name or self.fun) + node=self.root.find_node(WSCRIPT_FUN) + if node and(not once or node not in cache): + cache[node]=True + self.pre_recurse(node) + try: + function_code=node.read('rU') + exec(compile(function_code,node.abspath(),'exec'),self.exec_dict) + finally: + self.post_recurse(node) + elif not node: + node=self.root.find_node(WSCRIPT) + tup=(node,name or self.fun) + if node and(not once or tup not in cache): + cache[tup]=True + self.pre_recurse(node) + try: + wscript_module=load_module(node.abspath()) + user_function=getattr(wscript_module,(name or self.fun),None) + if not user_function: + if not mandatory: + continue + raise Errors.WafError('No function %s defined in %s'%(name or self.fun,node.abspath())) + user_function(self) + finally: + self.post_recurse(node) + elif not node: + if not mandatory: + continue + raise Errors.WafError('No wscript file in directory %s'%d) + def exec_command(self,cmd,**kw): + subprocess=Utils.subprocess + kw['shell']=isinstance(cmd,str) + Logs.debug('runner: %r'%cmd) + Logs.debug('runner_env: kw=%s'%kw) + try: + if self.logger: + self.logger.info(cmd) + kw['stdout']=kw['stderr']=subprocess.PIPE + p=subprocess.Popen(cmd,**kw) + (out,err)=p.communicate() + if out: + self.logger.debug('out: %s'%out.decode(sys.stdout.encoding or'iso8859-1')) + if err: + self.logger.error('err: %s'%err.decode(sys.stdout.encoding or'iso8859-1')) + return p.returncode + else: + p=subprocess.Popen(cmd,**kw) + return p.wait() + except OSError: + return-1 + def cmd_and_log(self,cmd,**kw): + subprocess=Utils.subprocess + kw['shell']=isinstance(cmd,str) + Logs.debug('runner: %r'%cmd) + if'quiet'in kw: + quiet=kw['quiet'] + del kw['quiet'] + else: + quiet=None + if'output'in kw: + to_ret=kw['output'] + del kw['output'] + else: + to_ret=STDOUT + kw['stdout']=kw['stderr']=subprocess.PIPE + if quiet is None: + self.to_log(cmd) + try: + p=subprocess.Popen(cmd,**kw) + (out,err)=p.communicate() + except Exception ,e: + raise Errors.WafError('Execution failure: %s'%str(e),ex=e) + if not isinstance(out,str): + out=out.decode(sys.stdout.encoding or'iso8859-1') + if not isinstance(err,str): + err=err.decode(sys.stdout.encoding or'iso8859-1') + if out and quiet!=STDOUT and quiet!=BOTH: + self.to_log('out: %s'%out) + if err and quiet!=STDERR and quiet!=BOTH: + self.to_log('err: %s'%err) + if p.returncode: + e=Errors.WafError('Command %r returned %r'%(cmd,p.returncode)) + e.returncode=p.returncode + e.stderr=err + e.stdout=out + raise e + if to_ret==BOTH: + return(out,err) + elif to_ret==STDERR: + return err + return out + def fatal(self,msg,ex=None): + if self.logger: + self.logger.info('from %s: %s'%(self.path.abspath(),msg)) + try: + msg='%s\n(complete log in %s)'%(msg,self.logger.handlers[0].baseFilename) + except: + pass + raise self.errors.ConfigurationError(msg,ex=ex) + def to_log(self,msg): + if not msg: + return + if self.logger: + self.logger.info(msg) + else: + sys.stderr.write(str(msg)) + sys.stderr.flush() + def msg(self,msg,result,color=None): + self.start_msg(msg) + if not isinstance(color,str): + color=result and'GREEN'or'YELLOW' + self.end_msg(result,color) + def start_msg(self,msg): + try: + if self.in_msg: + self.in_msg+=1 + return + except: + self.in_msg=0 + self.in_msg+=1 + try: + self.line_just=max(self.line_just,len(msg)) + except AttributeError: + self.line_just=max(40,len(msg)) + for x in(self.line_just*'-',msg): + self.to_log(x) + Logs.pprint('NORMAL',"%s :"%msg.ljust(self.line_just),sep='') + def end_msg(self,result,color=None): + self.in_msg-=1 + if self.in_msg: + return + defcolor='GREEN' + if result==True: + msg='ok' + elif result==False: + msg='not found' + defcolor='YELLOW' + else: + msg=str(result) + self.to_log(msg) + Logs.pprint(color or defcolor,msg) + def load_special_tools(self,var,ban=[]): + global waf_dir + lst=self.root.find_node(waf_dir).find_node('waflib/extras').ant_glob(var) + for x in lst: + if not x.name in ban: + load_tool(x.name.replace('.py','')) +cache_modules={} +def load_module(path): + try: + return cache_modules[path] + except KeyError: + pass + module=imp.new_module(WSCRIPT_FILE) + try: + code=Utils.readf(path,m='rU') + except(IOError,OSError): + raise Errors.WafError('Could not read the file %r'%path) + module_dir=os.path.dirname(path) + sys.path.insert(0,module_dir) + exec(compile(code,path,'exec'),module.__dict__) + sys.path.remove(module_dir) + cache_modules[path]=module + return module +def load_tool(tool,tooldir=None): + tool=tool.replace('++','xx') + tool=tool.replace('java','javaw') + tool=tool.replace('compiler_cc','compiler_c') + if tooldir: + assert isinstance(tooldir,list) + sys.path=tooldir+sys.path + try: + __import__(tool) + ret=sys.modules[tool] + Context.tools[tool]=ret + return ret + finally: + for d in tooldir: + sys.path.remove(d) + else: + global waf_dir + try: + os.stat(os.path.join(waf_dir,'waflib','extras',tool+'.py')) + d='waflib.extras.%s'%tool + except: + try: + os.stat(os.path.join(waf_dir,'waflib','Tools',tool+'.py')) + d='waflib.Tools.%s'%tool + except: + d=tool + __import__(d) + ret=sys.modules[d] + Context.tools[tool]=ret + return ret diff -Nru jalv-0~svn3409/waflib/Errors.py jalv-1.0.0~dfsg0/waflib/Errors.py --- jalv-0~svn3409/waflib/Errors.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Errors.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,37 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import traceback,sys +class WafError(Exception): + def __init__(self,msg='',ex=None): + self.msg=msg + assert not isinstance(msg,Exception) + self.stack=[] + if ex: + if not msg: + self.msg=str(ex) + if isinstance(ex,WafError): + self.stack=ex.stack + else: + self.stack=traceback.extract_tb(sys.exc_info()[2]) + self.stack+=traceback.extract_stack()[:-1] + self.verbose_msg=''.join(traceback.format_list(self.stack)) + def __str__(self): + return str(self.msg) +class BuildError(WafError): + def __init__(self,error_tasks=[]): + self.tasks=error_tasks + WafError.__init__(self,self.format_error()) + def format_error(self): + lst=['Build failed'] + for tsk in self.tasks: + txt=tsk.format_error() + if txt:lst.append(txt) + return'\n'.join(lst) +class ConfigurationError(WafError): + pass +class TaskRescan(WafError): + pass +class TaskNotReady(WafError): + pass diff -Nru jalv-0~svn3409/waflib/extras/autowaf.py jalv-1.0.0~dfsg0/waflib/extras/autowaf.py --- jalv-0~svn3409/waflib/extras/autowaf.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/extras/autowaf.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,429 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +import subprocess +import sys +import glob +from waflib import Configure,Context,Logs,Node,Options,Task,Utils +from waflib.TaskGen import feature,before,after +global g_is_child +g_is_child=False +global g_step +g_step=0 +def include_config_h(self): + self.env.append_value('INCPATHS',self.bld.bldnode.abspath()) +def set_options(opt,debug_by_default=False): + global g_step + if g_step>0: + return + dirs_options=opt.add_option_group('Installation directories','') + for k in('--prefix','--destdir'): + option=opt.parser.get_option(k) + if option: + opt.parser.remove_option(k) + dirs_options.add_option(option) + dirs_options.add_option('--bindir',type='string',help="Executable programs [Default: PREFIX/bin]") + dirs_options.add_option('--configdir',type='string',help="Configuration data [Default: PREFIX/etc]") + dirs_options.add_option('--datadir',type='string',help="Shared data [Default: PREFIX/share]") + dirs_options.add_option('--includedir',type='string',help="Header files [Default: PREFIX/include]") + dirs_options.add_option('--libdir',type='string',help="Libraries [Default: PREFIX/lib]") + dirs_options.add_option('--mandir',type='string',help="Manual pages [Default: DATADIR/man]") + dirs_options.add_option('--docdir',type='string',help="HTML documentation [Default: DATADIR/doc]") + if debug_by_default: + opt.add_option('--optimize',action='store_false',default=True,dest='debug',help="Build optimized binaries [Default: False]") + else: + opt.add_option('--debug',action='store_true',default=False,dest='debug',help="Build debuggable binaries [Default: False]") + opt.add_option('--grind',action='store_true',default=False,dest='grind',help="Run tests in valgrind [Default: False]") + opt.add_option('--strict',action='store_true',default=False,dest='strict',help="Use strict compiler flags and show all warnings [Default: False]") + opt.add_option('--docs',action='store_true',default=False,dest='docs',help="Build documentation - requires doxygen [Default: False]") + opt.add_option('--lv2-user',action='store_true',default=False,dest='lv2_user',help="Install LV2 bundles to user-local location [Default: False]") + if sys.platform=="darwin": + opt.add_option('--lv2dir',type='string',help="LV2 bundles [Default: /Library/Audio/Plug-Ins/LV2]") + elif sys.platform=="win32": + opt.add_option('--lv2dir',type='string',help="LV2 bundles [Default: C:\Program Files\LV2]") + else: + opt.add_option('--lv2dir',type='string',help="LV2 bundles [Default: LIBDIR/lv2]") + g_step=1 +def check_header(conf,lang,name,define='',mandatory=True): + includes='' + if sys.platform=="darwin": + includes='/opt/local/include' + if lang=='c': + check_func=conf.check_cc + elif lang=='cxx': + check_func=conf.check_cxx + else: + Logs.error("Unknown header language `%s'"%lang) + return + if define!='': + check_func(header_name=name,includes=includes,define_name=define,mandatory=mandatory) + else: + check_func(header_name=name,includes=includes,mandatory=mandatory) +def nameify(name): + return name.replace('/','_').replace('++','PP').replace('-','_').replace('.','_') +def define(conf,var_name,value): + conf.define(var_name,value) + conf.env[var_name]=value +def check_pkg(conf,name,**args): + if args['uselib_store'].lower()in conf.env['AUTOWAF_LOCAL_LIBS']: + return + class CheckType: + OPTIONAL=1 + MANDATORY=2 + var_name='CHECKED_'+nameify(args['uselib_store']) + check=not var_name in conf.env + mandatory=not'mandatory'in args or args['mandatory'] + if not check and'atleast_version'in args: + checked_version=conf.env['VERSION_'+name] + if checked_version and checked_version1: + return + def append_cxx_flags(vals): + conf.env.append_value('CFLAGS',vals.split()) + conf.env.append_value('CXXFLAGS',vals.split()) + print('') + display_header('Global Configuration') + if Options.options.docs: + conf.load('doxygen') + conf.env['DOCS']=Options.options.docs + conf.env['DEBUG']=Options.options.debug + conf.env['STRICT']=Options.options.strict + conf.env['PREFIX']=os.path.normpath(os.path.abspath(os.path.expanduser(conf.env['PREFIX']))) + if sys.platform=='win32': + conf.env['PREFIX']=conf.env['PREFIX'].replace('\\','\\\\') + def config_dir(var,opt,default): + if opt: + conf.env[var]=normpath(opt) + else: + conf.env[var]=normpath(default) + opts=Options.options + prefix=conf.env['PREFIX'] + config_dir('BINDIR',opts.bindir,os.path.join(prefix,'bin')) + config_dir('SYSCONFDIR',opts.configdir,os.path.join(prefix,'etc')) + config_dir('DATADIR',opts.datadir,os.path.join(prefix,'share')) + config_dir('INCLUDEDIR',opts.includedir,os.path.join(prefix,'include')) + config_dir('LIBDIR',opts.libdir,os.path.join(prefix,'lib')) + config_dir('MANDIR',opts.mandir,os.path.join(conf.env['DATADIR'],'man')) + config_dir('DOCDIR',opts.docdir,os.path.join(conf.env['DATADIR'],'doc')) + if Options.options.lv2dir: + conf.env['LV2DIR']=Options.options.lv2dir + else: + if Options.options.lv2_user: + if sys.platform=="darwin": + conf.env['LV2DIR']=os.path.join(os.getenv('HOME'),'Library/Audio/Plug-Ins/LV2') + elif sys.platform=="win32": + conf.env['LV2DIR']=os.path.join(os.getenv('APPDATA'),'LV2') + else: + conf.env['LV2DIR']=os.path.join(os.getenv('HOME'),'.lv2') + else: + if sys.platform=="darwin": + conf.env['LV2DIR']='/Library/Audio/Plug-Ins/LV2' + elif sys.platform=="win32": + conf.env['LV2DIR']=os.path.join(os.getenv('COMMONPROGRAMFILES'),'LV2') + else: + conf.env['LV2DIR']=os.path.join(conf.env['LIBDIR'],'lv2') + if Options.options.docs: + doxygen=conf.find_program('doxygen') + if not doxygen: + conf.fatal("Doxygen is required to build with --docs") + dot=conf.find_program('dot') + if not dot: + conf.fatal("Graphviz (dot) is required to build with --docs") + if Options.options.debug: + conf.env['CFLAGS']=['-O0','-g'] + conf.env['CXXFLAGS']=['-O0','-g'] + else: + append_cxx_flags('-DNDEBUG') + if Options.options.strict: + conf.env.append_value('CFLAGS',['-std=c99','-pedantic']) + conf.env.append_value('CXXFLAGS',['-ansi','-Woverloaded-virtual','-Wnon-virtual-dtor']) + append_cxx_flags('-Wall -Wextra -Wno-unused-parameter') + if not conf.env['MSVC_COMPILER']: + append_cxx_flags('-fshow-column') + conf.env.prepend_value('CFLAGS','-I'+os.path.abspath('.')) + conf.env.prepend_value('CXXFLAGS','-I'+os.path.abspath('.')) + display_msg(conf,"Install prefix",conf.env['PREFIX']) + display_msg(conf,"Debuggable build",str(conf.env['DEBUG'])) + display_msg(conf,"Strict compiler flags",str(conf.env['STRICT'])) + display_msg(conf,"Build documentation",str(conf.env['DOCS'])) + print('') + g_step=2 +def set_local_lib(conf,name,has_objects): + var_name='HAVE_'+nameify(name.upper()) + define(conf,var_name,1) + if has_objects: + if type(conf.env['AUTOWAF_LOCAL_LIBS'])!=dict: + conf.env['AUTOWAF_LOCAL_LIBS']={} + conf.env['AUTOWAF_LOCAL_LIBS'][name.lower()]=True + else: + if type(conf.env['AUTOWAF_LOCAL_HEADERS'])!=dict: + conf.env['AUTOWAF_LOCAL_HEADERS']={} + conf.env['AUTOWAF_LOCAL_HEADERS'][name.lower()]=True +def append_property(obj,key,val): + if hasattr(obj,key): + setattr(obj,key,getattr(obj,key)+val) + else: + setattr(obj,key,val) +def use_lib(bld,obj,libs): + abssrcdir=os.path.abspath('.') + libs_list=libs.split() + for l in libs_list: + in_headers=l.lower()in bld.env['AUTOWAF_LOCAL_HEADERS'] + in_libs=l.lower()in bld.env['AUTOWAF_LOCAL_LIBS'] + if in_libs: + append_property(obj,'use',' lib%s '%l.lower()) + append_property(obj,'framework',bld.env['FRAMEWORK_'+l]) + if in_headers or in_libs: + inc_flag='-iquote '+os.path.join(abssrcdir,l.lower()) + for f in['CFLAGS','CXXFLAGS']: + if not inc_flag in bld.env[f]: + bld.env.prepend_value(f,inc_flag) + else: + append_property(obj,'uselib',' '+l) +def display_header(title): + Logs.pprint('BOLD',title) +def display_msg(conf,msg,status=None,color=None): + color='CYAN' + if type(status)==bool and status or status=="True": + color='GREEN' + elif type(status)==bool and not status or status=="False": + color='YELLOW' + Logs.pprint('BOLD'," *",sep='') + Logs.pprint('NORMAL',"%s"%msg.ljust(conf.line_just-3),sep='') + Logs.pprint('BOLD',":",sep='') + Logs.pprint(color,status) +def link_flags(env,lib): + return' '.join(map(lambda x:env['LIB_ST']%x,env['LIB_'+lib])) +def compile_flags(env,lib): + return' '.join(map(lambda x:env['CPPPATH_ST']%x,env['INCLUDES_'+lib])) +def set_recursive(): + global g_is_child + g_is_child=True +def is_child(): + global g_is_child + return g_is_child +def build_pc(bld,name,version,version_suffix,libs,subst_dict={}): + '''Build a pkg-config file for a library. + name -- uppercase variable name (e.g. 'SOMENAME') + version -- version string (e.g. '1.2.3') + version_suffix -- name version suffix (e.g. '2') + libs -- string/list of dependencies (e.g. 'LIBFOO GLIB') + ''' + pkg_prefix=bld.env['PREFIX'] + if pkg_prefix[-1]=='/': + pkg_prefix=pkg_prefix[:-1] + target=name.lower() + if version_suffix!='': + target+='-'+version_suffix + target+='.pc' + libdir=bld.env['LIBDIR'] + if libdir.startswith(pkg_prefix): + libdir=libdir.replace(pkg_prefix,'${exec_prefix}') + includedir=bld.env['INCLUDEDIR'] + if includedir.startswith(pkg_prefix): + includedir=includedir.replace(pkg_prefix,'${prefix}') + obj=bld(features='subst',source='%s.pc.in'%name.lower(),target=target,install_path=os.path.join(bld.env['LIBDIR'],'pkgconfig'),exec_prefix='${prefix}',PREFIX=pkg_prefix,EXEC_PREFIX='${prefix}',LIBDIR=libdir,INCLUDEDIR=includedir) + if type(libs)!=list: + libs=libs.split() + subst_dict[name+'_VERSION']=version + subst_dict[name+'_MAJOR_VERSION']=version[0:version.find('.')] + for i in libs: + subst_dict[i+'_LIBS']=link_flags(bld.env,i) + lib_cflags=compile_flags(bld.env,i) + if lib_cflags=='': + lib_cflags=' ' + subst_dict[i+'_CFLAGS']=lib_cflags + obj.__dict__.update(subst_dict) +def build_dox(bld,name,version,srcdir,blddir): + if not bld.env['DOCS']: + return + if is_child(): + src_dir=os.path.join(srcdir,name.lower()) + doc_dir=os.path.join(blddir,name.lower(),'doc') + else: + src_dir=srcdir + doc_dir=os.path.join(blddir,'doc') + subst_tg=bld(features='subst',source='doc/reference.doxygen.in',target='doc/reference.doxygen',install_path='',name='doxyfile') + subst_dict={name+'_VERSION':version,name+'_SRCDIR':os.path.abspath(src_dir),name+'_DOC_DIR':os.path.abspath(doc_dir)} + subst_tg.__dict__.update(subst_dict) + subst_tg.post() + docs=bld(features='doxygen',doxyfile='doc/reference.doxygen') + docs.post() + bld.install_files('${DOCDIR}/%s/html'%name.lower(),bld.path.get_bld().ant_glob('doc/html/*')) + bld.install_files('${MANDIR}/man1',bld.path.get_bld().ant_glob('doc/man/man1/*')) + bld.install_files('${MANDIR}/man3',bld.path.get_bld().ant_glob('doc/man/man3/*')) +def build_version_files(header_path,source_path,domain,major,minor,micro): + header_path=os.path.abspath(header_path) + source_path=os.path.abspath(source_path) + text="int "+domain+"_major_version = "+str(major)+";\n" + text+="int "+domain+"_minor_version = "+str(minor)+";\n" + text+="int "+domain+"_micro_version = "+str(micro)+";\n" + try: + o=open(source_path,'w') + o.write(text) + o.close() + except IOError: + Logs.error('Failed to open %s for writing\n'%source_path) + sys.exit(-1) + text="#ifndef __"+domain+"_version_h__\n" + text+="#define __"+domain+"_version_h__\n" + text+="extern const char* "+domain+"_revision;\n" + text+="extern int "+domain+"_major_version;\n" + text+="extern int "+domain+"_minor_version;\n" + text+="extern int "+domain+"_micro_version;\n" + text+="#endif /* __"+domain+"_version_h__ */\n" + try: + o=open(header_path,'w') + o.write(text) + o.close() + except IOError: + Logs.warn('Failed to open %s for writing\n'%header_path) + sys.exit(-1) + return None +def build_i18n_pot(bld,srcdir,dir,name,sources,copyright_holder=None): + Logs.info('Generating pot file from %s'%name) + pot_file='%s.pot'%name + cmd=['xgettext','--keyword=_','--keyword=N_','--keyword=S_','--from-code=UTF-8','-o',pot_file] + if copyright_holder: + cmd+=['--copyright-holder="%s"'%copyright_holder] + cmd+=sources + Logs.info('Updating '+pot_file) + subprocess.call(cmd,cwd=os.path.join(srcdir,dir)) +def build_i18n_po(bld,srcdir,dir,name,sources,copyright_holder=None): + pwd=os.getcwd() + os.chdir(os.path.join(srcdir,dir)) + pot_file='%s.pot'%name + po_files=glob.glob('po/*.po') + for po_file in po_files: + cmd=['msgmerge','--update',po_file,pot_file] + Logs.info('Updating '+po_file) + subprocess.call(cmd) + os.chdir(pwd) +def build_i18n_mo(bld,srcdir,dir,name,sources,copyright_holder=None): + pwd=os.getcwd() + os.chdir(os.path.join(srcdir,dir)) + pot_file='%s.pot'%name + po_files=glob.glob('po/*.po') + for po_file in po_files: + mo_file=po_file.replace('.po','.mo') + cmd=['msgfmt','-c','-f','-o',mo_file,po_file] + Logs.info('Generating '+po_file) + subprocess.call(cmd) + os.chdir(pwd) +def build_i18n(bld,srcdir,dir,name,sources,copyright_holder=None): + build_i18n_pot(bld,srcdir,dir,name,sources,copyright_holder) + build_i18n_po(bld,srcdir,dir,name,sources,copyright_holder) + build_i18n_mo(bld,srcdir,dir,name,sources,copyright_holder) +def cd_to_build_dir(ctx,appname): + orig_dir=os.path.abspath(os.curdir) + top_level=(len(ctx.stack_path)>1) + if top_level: + os.chdir(os.path.join('build',appname)) + else: + os.chdir('build') + Logs.pprint('GREEN',"Waf: Entering directory `%s'"%os.path.abspath(os.getcwd())) +def cd_to_orig_dir(ctx,child): + if child: + os.chdir(os.path.join('..','..')) + else: + os.chdir('..') +def pre_test(ctx,appname,dirs=['src']): + diropts='' + for i in dirs: + diropts+=' -d '+i + cd_to_build_dir(ctx,appname) + clear_log=open('lcov-clear.log','w') + try: + try: + subprocess.call(('lcov %s -z'%diropts).split(),stdout=clear_log,stderr=clear_log) + except: + Logs.warn('Failed to run lcov, no coverage report will be generated') + finally: + clear_log.close() +def post_test(ctx,appname,dirs=['src']): + diropts='' + for i in dirs: + diropts+=' -d '+i + coverage_log=open('lcov-coverage.log','w') + coverage_lcov=open('coverage.lcov','w') + coverage_stripped_lcov=open('coverage-stripped.lcov','w') + try: + try: + base='.' + if g_is_child: + base='..' + subprocess.call(('lcov -c %s -b %s'%(diropts,base)).split(),stdout=coverage_lcov,stderr=coverage_log) + subprocess.call('lcov --remove coverage.lcov *boost* c++*'.split(),stdout=coverage_stripped_lcov,stderr=coverage_log) + if not os.path.isdir('coverage'): + os.makedirs('coverage') + subprocess.call('genhtml -o coverage coverage-stripped.lcov'.split(),stdout=coverage_log,stderr=coverage_log) + except: + Logs.warn('Failed to run lcov, no coverage report will be generated') + finally: + coverage_stripped_lcov.close() + coverage_lcov.close() + coverage_log.close() + print('') + Logs.pprint('GREEN',"Waf: Leaving directory `%s'"%os.path.abspath(os.getcwd())) + top_level=(len(ctx.stack_path)>1) + if top_level: + cd_to_orig_dir(ctx,top_level) + print('') + Logs.pprint('BOLD','Coverage:',sep='') + print('\n\n'%os.path.abspath('coverage/index.html')) +def run_tests(ctx,appname,tests,desired_status=0,dirs=['src'],name='*'): + failures=0 + diropts='' + for i in dirs: + diropts+=' -d '+i + for i in tests: + s=i + if type(i)==type([]): + s=' '.join(i) + print('') + Logs.pprint('BOLD','** Test',sep='') + Logs.pprint('NORMAL','%s'%s) + cmd=i + if Options.options.grind: + cmd='valgrind '+i + if subprocess.call(cmd,shell=True)==desired_status: + Logs.pprint('GREEN','** Pass') + else: + failures+=1 + Logs.pprint('RED','** FAIL') + print('') + if failures==0: + Logs.pprint('GREEN','** Pass: All %s.%s tests passed'%(appname,name)) + else: + Logs.pprint('RED','** FAIL: %d %s.%s tests failed'%(failures,appname,name)) +def run_ldconfig(ctx): + if(ctx.cmd=='install'and not ctx.env['RAN_LDCONFIG']and ctx.env['LIBDIR']and not os.environ.has_key('DESTDIR')): + try: + Logs.info("Waf: Running `/sbin/ldconfig %s'"%ctx.env['LIBDIR']) + subprocess.call(['/sbin/ldconfig',ctx.env['LIBDIR']]) + ctx.env['RAN_LDCONFIG']=True + except: + pass + +feature('c','cxx')(include_config_h) +after('apply_incpaths')(include_config_h) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/extras/doxygen.py jalv-1.0.0~dfsg0/waflib/extras/doxygen.py --- jalv-0~svn3409/waflib/extras/doxygen.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/extras/doxygen.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,116 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from fnmatch import fnmatchcase +import os,os.path,re,stat +from waflib import Task,Utils,Node,Logs +from waflib.TaskGen import feature +DOXY_STR='${DOXYGEN} - ' +DOXY_FMTS='html latex man rft xml'.split() +DOXY_FILE_PATTERNS='*.'+' *.'.join(''' +c cc cxx cpp c++ java ii ixx ipp i++ inl h hh hxx hpp h++ idl odl cs php php3 +inc m mm py f90c cc cxx cpp c++ java ii ixx ipp i++ inl h hh hxx +'''.split()) +re_nl=re.compile('\\\\\r*\n',re.MULTILINE) +class doxygen(Task.Task): + vars=['DOXYGEN','DOXYFLAGS'] + color='BLUE' + def runnable_status(self): + ''' + self.pars are populated in runnable_status - because this function is being + run *before* both self.pars "consumers" - scan() and run() + + set output_dir (node) for the output + ''' + for x in self.run_after: + if not x.hasrun: + return Task.ASK_LATER + if not getattr(self,'pars',None): + txt=self.inputs[0].read() + txt=re_nl.sub('',txt) + self.pars=Utils.str_to_dict(txt) + if not self.pars.get('OUTPUT_DIRECTORY'): + self.pars['OUTPUT_DIRECTORY']=self.inputs[0].parent.get_bld().abspath() + if not self.pars.get('INPUT'): + self.pars['INPUT']=self.inputs[0].parent.abspath() + if not getattr(self,'output_dir',None): + self.output_dir=self.generator.bld.root.find_dir(self.pars['OUTPUT_DIRECTORY']) + self.signature() + return Task.Task.runnable_status(self) + def scan(self): + if self.pars.get('RECURSIVE')=='YES': + Logs.warn("Doxygen RECURSIVE dependencies are not supported") + inputs=self.pars.get('INPUT').split() + exclude_patterns=self.pars.get('EXCLUDE_PATTERNS','').split() + file_patterns=self.pars.get('FILE_PATTERNS','').split() + if not file_patterns: + file_patterns=DOXY_FILE_PATTERNS + nodes=[] + names=[] + for i in inputs: + node=self.generator.bld.root.make_node(i) + if node: + if os.path.isdir(node.abspath()): + for m in node.ant_glob(file_patterns): + nodes.append(self.generator.bld.root.make_node(m.abspath())) + else: + nodes.append(node) + else: + names.append(i) + return(nodes,names) + def run(self): + code='\n'.join(['%s = %s'%(x,self.pars[x])for x in self.pars]) + code=code + cmd=Utils.subst_vars(DOXY_STR,self.env) + proc=Utils.subprocess.Popen(cmd,shell=True,stdin=Utils.subprocess.PIPE) + proc.communicate(code) + return proc.returncode + def post_run(self): + nodes=self.output_dir.ant_glob('**/*') + for x in nodes: + x.sig=Utils.h_file(x.abspath()) + self.outputs+=nodes + return Task.Task.post_run(self) +class tar(Task.Task): + run_str='${TAR} ${TAROPTS} ${TGT} ${SRC}' + color='RED' + after=['doxygen'] + def runnable_status(self): + for x in getattr(self,'input_tasks',[]): + if not x.hasrun: + return Task.ASK_LATER + if not getattr(self,'tar_done_adding',None): + self.tar_done_adding=True + for x in getattr(self,'input_tasks',[]): + self.set_inputs(x.outputs) + if not self.inputs: + return Task.SKIP_ME + return Task.Task.runnable_status(self) + def __str__(self): + tgt_str=' '.join([a.nice_path(self.env)for a in self.outputs]) + return'%s: %s\n'%(self.__class__.__name__,tgt_str) +def process_doxy(self): + if not getattr(self,'doxyfile',None): + self.generator.bld.fatal('no doxyfile??') + node=self.doxyfile + if not isinstance(node,Node.Node): + node=self.path.find_resource(node) + if not node: + raise ValueError('doxygen file not found') + dsk=self.create_task('doxygen',node) + if getattr(self,'doxy_tar',None): + tsk=self.create_task('tar') + tsk.input_tasks=[dsk] + tsk.set_outputs(self.path.find_or_declare(self.doxy_tar)) + if self.doxy_tar.endswith('bz2'): + tsk.env['TAROPTS']=['cjf'] + elif self.doxy_tar.endswith('gz'): + tsk.env['TAROPTS']=['czf'] + else: + tsk.env['TAROPTS']=['cf'] +def configure(conf): + conf.find_program('doxygen',var='DOXYGEN') + conf.find_program('tar',var='TAR') + +feature('doxygen')(process_doxy) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/extras/__init__.py jalv-1.0.0~dfsg0/waflib/extras/__init__.py --- jalv-0~svn3409/waflib/extras/__init__.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/extras/__init__.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,4 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + diff -Nru jalv-0~svn3409/waflib/extras/swig.py jalv-1.0.0~dfsg0/waflib/extras/swig.py --- jalv-0~svn3409/waflib/extras/swig.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/extras/swig.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,119 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Task,Utils,Logs +from waflib.TaskGen import extension,feature,after_method +from waflib.Configure import conf +from waflib.Tools import c_preproc +SWIG_EXTS=['.swig','.i'] +re_module=re.compile('%module(?:\s*\(.*\))?\s+(.+)',re.M) +re_1=re.compile(r'^%module.*?\s+([\w]+)\s*?$',re.M) +re_2=re.compile('%include "(.*)"',re.M) +re_3=re.compile('#include "(.*)"',re.M) +class swig(Task.Task): + color='BLUE' + run_str='${SWIG} ${SWIGFLAGS} ${SWIGPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${SRC}' + ext_out=['.h'] + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + if not getattr(self,'init_outputs',None): + self.init_outputs=True + if not getattr(self,'module',None): + txt=self.inputs[0].read() + m=re_module.search(txt) + if not m: + raise ValueError("could not find the swig module name") + self.module=m.group(1) + swig_c(self) + for x in self.env['SWIGFLAGS']: + x=x[1:] + try: + fun=swig_langs[x] + except KeyError: + pass + else: + fun(self) + return super(swig,self).runnable_status() + def scan(self): + env=self.env + lst_src=[] + seen=[] + to_see=[self.inputs[0]] + while to_see: + node=to_see.pop(0) + if node in seen: + continue + seen.append(node) + lst_src.append(node) + code=node.read() + code=c_preproc.re_nl.sub('',code) + code=c_preproc.re_cpp.sub(c_preproc.repl,code) + names=re_2.findall(code)+re_3.findall(code) + for n in names: + for d in self.generator.includes_nodes+[node.parent]: + u=d.find_resource(n) + if u: + to_see.append(u) + break + else: + Logs.warn('could not find %r'%n) + return(lst_src,[]) +swig_langs={} +def swigf(fun): + swig_langs[fun.__name__.replace('swig_','')]=fun +swig.swigf=swigf +def swig_c(self): + ext='.swigwrap_%d.c'%self.generator.idx + flags=self.env['SWIGFLAGS'] + if'-c++'in flags: + ext+='xx' + out_node=self.inputs[0].parent.find_or_declare(self.module+ext) + if'-c++'in flags: + c_tsk=self.generator.cxx_hook(out_node) + else: + c_tsk=self.generator.c_hook(out_node) + c_tsk.set_run_after(self) + ge=self.generator.bld.producer + ge.outstanding.insert(0,c_tsk) + ge.total+=1 + try: + ltask=self.generator.link_task + except AttributeError: + pass + else: + ltask.set_run_after(c_tsk) + ltask.inputs.append(c_tsk.outputs[0]) + self.outputs.append(out_node) + if not'-o'in self.env['SWIGFLAGS']: + self.env.append_value('SWIGFLAGS',['-o',self.outputs[0].abspath()]) +def swig_python(tsk): + tsk.set_outputs(tsk.inputs[0].parent.find_or_declare(tsk.module+'.py')) +def swig_ocaml(tsk): + tsk.set_outputs(tsk.inputs[0].parent.find_or_declare(tsk.module+'.ml')) + tsk.set_outputs(tsk.inputs[0].parent.find_or_declare(tsk.module+'.mli')) +def i_file(self,node): + tsk=self.create_task('swig') + tsk.set_inputs(node) + tsk.module=getattr(self,'swig_module',None) + flags=self.to_list(getattr(self,'swig_flags',[])) + tsk.env.append_value('SWIGFLAGS',flags) +def check_swig_version(self): + reg_swig=re.compile(r'SWIG Version\s(.*)',re.M) + swig_out=self.cmd_and_log('%s -version'%self.env['SWIG']) + swigver=tuple([int(s)for s in reg_swig.findall(swig_out)[0].split('.')]) + self.env['SWIG_VERSION']=swigver + msg='Checking for swig version' + self.msg(msg,'.'.join(map(str,swigver))) + return swigver +def configure(conf): + swig=conf.find_program('swig',var='SWIG') + conf.env.SWIGPATH_ST='-I%s' + +swigf(swig_python) +swigf(swig_ocaml) +extension(*SWIG_EXTS)(i_file) +conf(check_swig_version) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/fixpy2.py jalv-1.0.0~dfsg0/waflib/fixpy2.py --- jalv-0~svn3409/waflib/fixpy2.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/fixpy2.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,50 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +all_modifs={} +def fixdir(dir): + global all_modifs + for k in all_modifs: + for v in all_modifs[k]: + modif(os.path.join(dir,'waflib'),k,v) +def modif(dir,name,fun): + if name=='*': + lst=[] + for y in'. Tools extras'.split(): + for x in os.listdir(os.path.join(dir,y)): + if x.endswith('.py'): + lst.append(y+os.sep+x) + for x in lst: + modif(dir,x,fun) + return + filename=os.path.join(dir,name) + f=open(filename,'r') + txt=f.read() + f.close() + txt=fun(txt) + f=open(filename,'w') + f.write(txt) + f.close() +def subst(*k): + def do_subst(fun): + global all_modifs + for x in k: + try: + all_modifs[x].append(fun) + except KeyError: + all_modifs[x]=[fun] + return fun + return do_subst +def r1(code): + code=code.replace(',e:',',e:') + code=code.replace("",'') + code=code.replace('','') + return code +def r4(code): + code=code.replace('next(self.biter)','self.biter.next()') + return code + +subst('*')(r1) +subst('Runner.py')(r4) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/__init__.py jalv-1.0.0~dfsg0/waflib/__init__.py --- jalv-0~svn3409/waflib/__init__.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/__init__.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,4 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + diff -Nru jalv-0~svn3409/waflib/Logs.py jalv-1.0.0~dfsg0/waflib/Logs.py --- jalv-0~svn3409/waflib/Logs.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Logs.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,149 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re,traceback,sys +_nocolor=os.environ.get('NOCOLOR','no')not in('no','0','false') +try: + if not _nocolor: + import waflib.ansiterm +except: + pass +import logging +LOG_FORMAT="%(asctime)s %(c1)s%(zone)s%(c2)s %(message)s" +HOUR_FORMAT="%H:%M:%S" +zones='' +verbose=0 +colors_lst={'USE':True,'BOLD':'\x1b[01;1m','RED':'\x1b[01;31m','GREEN':'\x1b[32m','YELLOW':'\x1b[33m','PINK':'\x1b[35m','BLUE':'\x1b[01;34m','CYAN':'\x1b[36m','NORMAL':'\x1b[0m','cursor_on':'\x1b[?25h','cursor_off':'\x1b[?25l',} +got_tty=not os.environ.get('TERM','dumb')in['dumb','emacs'] +if got_tty: + try: + got_tty=sys.stderr.isatty() + except AttributeError: + got_tty=False +if(not got_tty and os.environ.get('TERM','dumb')!='msys')or _nocolor: + colors_lst['USE']=False +def get_term_cols(): + return 80 +try: + import struct,fcntl,termios +except ImportError: + pass +else: + if got_tty: + def get_term_cols_real(): + dummy_lines,cols=struct.unpack("HHHH",fcntl.ioctl(sys.stderr.fileno(),termios.TIOCGWINSZ,struct.pack("HHHH",0,0,0,0)))[:2] + return cols + try: + get_term_cols_real() + except: + pass + else: + get_term_cols=get_term_cols_real +get_term_cols.__doc__=""" + Get the console width in characters. + + :return: the number of characters per line + :rtype: int + """ +def get_color(cl): + if not colors_lst['USE']:return'' + return colors_lst.get(cl,'') +class color_dict(object): + def __getattr__(self,a): + return get_color(a) + def __call__(self,a): + return get_color(a) +colors=color_dict() +re_log=re.compile(r'(\w+): (.*)',re.M) +class log_filter(logging.Filter): + def __init__(self,name=None): + pass + def filter(self,rec): + rec.c1=colors.PINK + rec.c2=colors.NORMAL + rec.zone=rec.module + if rec.levelno>=logging.INFO: + if rec.levelno>=logging.ERROR: + rec.c1=colors.RED + elif rec.levelno>=logging.WARNING: + rec.c1=colors.YELLOW + else: + rec.c1=colors.GREEN + return True + m=re_log.match(rec.msg) + if m: + rec.zone=m.group(1) + rec.msg=m.group(2) + if zones: + return getattr(rec,'zone','')in zones or'*'in zones + elif not verbose>2: + return False + return True +class formatter(logging.Formatter): + def __init__(self): + logging.Formatter.__init__(self,LOG_FORMAT,HOUR_FORMAT) + def format(self,rec): + if rec.levelno>=logging.WARNING or rec.levelno==logging.INFO: + try: + msg=rec.msg.decode('utf-8') + except: + msg=rec.msg + return'%s%s%s'%(rec.c1,msg,rec.c2) + return logging.Formatter.format(self,rec) +log=None +def debug(*k,**kw): + if verbose: + k=list(k) + k[0]=k[0].replace('\n',' ') + global log + log.debug(*k,**kw) +def error(*k,**kw): + global log + log.error(*k,**kw) + if verbose>2: + st=traceback.extract_stack() + if st: + st=st[:-1] + buf=[] + for filename,lineno,name,line in st: + buf.append(' File "%s", line %d, in %s'%(filename,lineno,name)) + if line: + buf.append(' %s'%line.strip()) + if buf:log.error("\n".join(buf)) +def warn(*k,**kw): + global log + log.warn(*k,**kw) +def info(*k,**kw): + global log + log.info(*k,**kw) +def init_log(): + global log + log=logging.getLogger('waflib') + log.handlers=[] + log.filters=[] + hdlr=logging.StreamHandler() + hdlr.setFormatter(formatter()) + log.addHandler(hdlr) + log.addFilter(log_filter()) + log.setLevel(logging.DEBUG) +def make_logger(path,name): + logger=logging.getLogger(name) + hdlr=logging.FileHandler(path,'w') + formatter=logging.Formatter('%(message)s') + hdlr.setFormatter(formatter) + logger.addHandler(hdlr) + logger.setLevel(logging.DEBUG) + return logger +def make_mem_logger(name,to_log,size=10000): + from logging.handlers import MemoryHandler + logger=logging.getLogger(name) + hdlr=MemoryHandler(size,target=to_log) + formatter=logging.Formatter('%(message)s') + hdlr.setFormatter(formatter) + logger.addHandler(hdlr) + logger.memhandler=hdlr + logger.setLevel(logging.DEBUG) + return logger +def pprint(col,str,label='',sep='\n'): + sys.stderr.write("%s%s%s %s%s"%(colors(col),str,colors.NORMAL,label,sep)) diff -Nru jalv-0~svn3409/waflib/Node.py jalv-1.0.0~dfsg0/waflib/Node.py --- jalv-0~svn3409/waflib/Node.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Node.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,506 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import os,re,sys,shutil +from waflib import Utils,Errors +exclude_regs=''' +**/*~ +**/#*# +**/.#* +**/%*% +**/._* +**/CVS +**/CVS/** +**/.cvsignore +**/SCCS +**/SCCS/** +**/vssver.scc +**/.svn +**/.svn/** +**/BitKeeper +**/.git +**/.git/** +**/.gitignore +**/.bzr +**/.bzrignore +**/.bzr/** +**/.hg +**/.hg/** +**/_MTN +**/_MTN/** +**/.arch-ids +**/{arch} +**/_darcs +**/_darcs/** +**/.DS_Store''' +def split_path(path): + return path.split('/') +def split_path_cygwin(path): + if path.startswith('//'): + ret=path.split('/')[2:] + ret[0]='/'+ret[0] + return ret + return path.split('/') +re_sp=re.compile('[/\\\\]') +def split_path_win32(path): + if path.startswith('\\\\'): + ret=re.split(re_sp,path)[2:] + ret[0]='\\'+ret[0] + return ret + return re.split(re_sp,path) +if sys.platform=='cygwin': + split_path=split_path_cygwin +elif Utils.is_win32: + split_path=split_path_win32 +class Node(object): + __slots__=('name','sig','children','parent','cache_abspath','cache_isdir') + def __init__(self,name,parent): + self.name=name + self.parent=parent + if parent: + if name in parent.children: + raise Errors.WafError('node %s exists in the parent files %r already'%(name,parent)) + parent.children[name]=self + def __setstate__(self,data): + self.name=data[0] + self.parent=data[1] + if data[2]is not None: + self.children=data[2] + if data[3]is not None: + self.sig=data[3] + def __getstate__(self): + return(self.name,self.parent,getattr(self,'children',None),getattr(self,'sig',None)) + def __str__(self): + return self.name + def __repr__(self): + return self.abspath() + def __hash__(self): + return id(self) + def __eq__(self,node): + return id(self)==id(node) + def __copy__(self): + raise Errors.WafError('nodes are not supposed to be copied') + def read(self,flags='r'): + return Utils.readf(self.abspath(),flags) + def write(self,data,flags='w'): + f=None + try: + f=open(self.abspath(),flags) + f.write(data) + finally: + if f: + f.close() + def chmod(self,val): + os.chmod(self.abspath(),val) + def delete(self): + try: + if getattr(self,'children',None): + shutil.rmtree(self.abspath()) + else: + os.unlink(self.abspath()) + except: + pass + try: + delattr(self,'children') + except: + pass + def suffix(self): + k=max(0,self.name.rfind('.')) + return self.name[k:] + def height(self): + d=self + val=-1 + while d: + d=d.parent + val+=1 + return val + def listdir(self): + lst=Utils.listdir(self.abspath()) + lst.sort() + return lst + def mkdir(self): + if getattr(self,'cache_isdir',None): + return + try: + self.parent.mkdir() + except: + pass + if self.name: + try: + os.makedirs(self.abspath()) + except OSError: + pass + if not os.path.isdir(self.abspath()): + raise Errors.WafError('Could not create the directory %s'%self.abspath()) + try: + self.children + except: + self.children={} + self.cache_isdir=True + def find_node(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + cur=self + for x in lst: + if x=='..': + cur=cur.parent or cur + continue + try: + if x in cur.children: + cur=cur.children[x] + continue + except: + cur.children={} + cur=self.__class__(x,cur) + try: + os.stat(cur.abspath()) + except: + del cur.parent.children[x] + return None + ret=cur + try: + os.stat(ret.abspath()) + except: + del ret.parent.children[ret.name] + return None + try: + while not getattr(cur.parent,'cache_isdir',None): + cur=cur.parent + cur.cache_isdir=True + except AttributeError: + pass + return ret + def make_node(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + cur=self + for x in lst: + if x=='..': + cur=cur.parent or cur + continue + if getattr(cur,'children',{}): + if x in cur.children: + cur=cur.children[x] + continue + else: + cur.children={} + cur=self.__class__(x,cur) + return cur + def search(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + cur=self + try: + for x in lst: + if x=='..': + cur=cur.parent or cur + else: + cur=cur.children[x] + return cur + except: + pass + def path_from(self,node): + c1=self + c2=node + c1h=c1.height() + c2h=c2.height() + lst=[] + up=0 + while c1h>c2h: + lst.append(c1.name) + c1=c1.parent + c1h-=1 + while c2h>c1h: + up+=1 + c2=c2.parent + c2h-=1 + while id(c1)!=id(c2): + lst.append(c1.name) + up+=1 + c1=c1.parent + c2=c2.parent + for i in range(up): + lst.append('..') + lst.reverse() + return os.sep.join(lst)or'.' + def abspath(self): + try: + return self.cache_abspath + except: + pass + if os.sep=='/': + if not self.parent: + val=os.sep + elif not self.parent.name: + val=os.sep+self.name + else: + val=self.parent.abspath()+os.sep+self.name + else: + if not self.parent: + val='' + elif not self.parent.name: + val=self.name+os.sep + else: + val=self.parent.abspath().rstrip(os.sep)+os.sep+self.name + self.cache_abspath=val + return val + def is_child_of(self,node): + p=self + diff=self.height()-node.height() + while diff>0: + diff-=1 + p=p.parent + return id(p)==id(node) + def ant_iter(self,accept=None,maxdepth=25,pats=[],dir=False,src=True,remove=True): + dircont=self.listdir() + dircont.sort() + try: + lst=set(self.children.keys()) + if remove: + for x in lst-set(dircont): + del self.children[x] + except: + self.children={} + for name in dircont: + npats=accept(name,pats) + if npats and npats[0]: + accepted=[]in npats[0] + node=self.make_node([name]) + isdir=os.path.isdir(node.abspath()) + if accepted: + if isdir: + if dir: + yield node + else: + if src: + yield node + if getattr(node,'cache_isdir',None)or isdir: + node.cache_isdir=True + if maxdepth: + for k in node.ant_iter(accept=accept,maxdepth=maxdepth-1,pats=npats,dir=dir,src=src,remove=remove): + yield k + raise StopIteration + def ant_glob(self,*k,**kw): + src=kw.get('src',True) + dir=kw.get('dir',False) + excl=kw.get('excl',exclude_regs) + incl=k and k[0]or kw.get('incl','**') + def to_pat(s): + lst=Utils.to_list(s) + ret=[] + for x in lst: + x=x.replace('\\','/').replace('//','/') + if x.endswith('/'): + x+='**' + lst2=x.split('/') + accu=[] + for k in lst2: + if k=='**': + accu.append(k) + else: + k=k.replace('.','[.]').replace('*','.*').replace('?','.').replace('+','\\+') + k='^%s$'%k + try: + accu.append(re.compile(k)) + except Exception ,e: + raise Errors.WafError("Invalid pattern: %s"%k,e) + ret.append(accu) + return ret + def filtre(name,nn): + ret=[] + for lst in nn: + if not lst: + pass + elif lst[0]=='**': + ret.append(lst) + if len(lst)>1: + if lst[1].match(name): + ret.append(lst[2:]) + else: + ret.append([]) + elif lst[0].match(name): + ret.append(lst[1:]) + return ret + def accept(name,pats): + nacc=filtre(name,pats[0]) + nrej=filtre(name,pats[1]) + if[]in nrej: + nacc=[] + return[nacc,nrej] + ret=[x for x in self.ant_iter(accept=accept,pats=[to_pat(incl),to_pat(excl)],maxdepth=25,dir=dir,src=src,remove=kw.get('remove',True))] + if kw.get('flat',False): + return' '.join([x.path_from(self)for x in ret]) + return ret + def find_nodes(self,find_dirs=True,find_files=True,match_fun=lambda x:True): + x=""" + Recursively finds nodes:: + + def configure(cnf): + cnf.find_nodes() + + :param find_dirs: whether to return directories + :param find_files: whether to return files + :param match_fun: matching function, taking a node as parameter + :rtype generator + :return: a generator that iterates over all the requested files + """ + files=self.listdir() + for f in files: + node=self.make_node([f]) + if os.path.isdir(node.abspath()): + if find_dirs and match_fun(node): + yield node + gen=node.find_nodes(find_dirs,find_files,match_fun) + for g in gen: + yield g + else: + if find_files and match_fun(node): + yield node + def is_src(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==y: + return False + if id(cur)==x: + return True + cur=cur.parent + return False + def is_bld(self): + cur=self + y=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==y: + return True + cur=cur.parent + return False + def get_src(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + lst=[] + while cur.parent: + if id(cur)==y: + lst.reverse() + return self.ctx.srcnode.make_node(lst) + if id(cur)==x: + return self + lst.append(cur.name) + cur=cur.parent + return self + def get_bld(self): + cur=self + x=id(self.ctx.srcnode) + y=id(self.ctx.bldnode) + lst=[] + while cur.parent: + if id(cur)==y: + return self + if id(cur)==x: + lst.reverse() + return self.ctx.bldnode.make_node(lst) + lst.append(cur.name) + cur=cur.parent + lst.reverse() + if lst and Utils.is_win32 and len(lst[0])==2 and lst[0].endswith(':'): + lst[0]=lst[0][0] + return self.ctx.bldnode.make_node(['__root__']+lst) + def find_resource(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.get_bld().search(lst) + if not node: + self=self.get_src() + node=self.find_node(lst) + try: + pat=node.abspath() + if os.path.isdir(pat): + return None + except: + pass + return node + def find_or_declare(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.get_bld().search(lst) + if node: + if not os.path.isfile(node.abspath()): + node.sig=None + try: + node.parent.mkdir() + except: + pass + return node + self=self.get_src() + node=self.find_node(lst) + if node: + if not os.path.isfile(node.abspath()): + node.sig=None + try: + node.parent.mkdir() + except: + pass + return node + node=self.get_bld().make_node(lst) + node.parent.mkdir() + return node + def find_dir(self,lst): + if isinstance(lst,str): + lst=[x for x in split_path(lst)if x and x!='.'] + node=self.find_node(lst) + try: + if not os.path.isdir(node.abspath()): + return None + except(OSError,AttributeError): + return None + return node + def change_ext(self,ext,ext_in=None): + name=self.name + if ext_in is None: + k=name.rfind('.') + if k>=0: + name=name[:k]+ext + else: + name=name+ext + else: + name=name[:-len(ext_in)]+ext + return self.parent.find_or_declare([name]) + def nice_path(self,env=None): + return self.path_from(self.ctx.launch_node()) + def bldpath(self): + return self.path_from(self.ctx.bldnode) + def srcpath(self): + return self.path_from(self.ctx.srcnode) + def relpath(self): + cur=self + x=id(self.ctx.bldnode) + while cur.parent: + if id(cur)==x: + return self.bldpath() + cur=cur.parent + return self.srcpath() + def bld_dir(self): + return self.parent.bldpath() + def bld_base(self): + s=os.path.splitext(self.name)[0] + return self.bld_dir()+os.sep+s + def get_bld_sig(self): + try: + ret=self.ctx.hash_cache[id(self)] + except KeyError: + pass + except AttributeError: + self.ctx.hash_cache={} + else: + return ret + if not self.is_bld()or self.ctx.bldnode is self.ctx.srcnode: + self.sig=Utils.h_file(self.abspath()) + self.ctx.hash_cache[id(self)]=ret=self.sig + return ret +pickle_lock=Utils.threading.Lock() +class Nod3(Node): + pass diff -Nru jalv-0~svn3409/waflib/Options.py jalv-1.0.0~dfsg0/waflib/Options.py --- jalv-0~svn3409/waflib/Options.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Options.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,134 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,tempfile,optparse,sys,re +from waflib import Logs,Utils,Context +cmds='distclean configure build install clean uninstall check dist distcheck'.split() +options={} +commands=[] +lockfile=os.environ.get('WAFLOCK','.lock-waf_%s_build'%sys.platform) +try:cache_global=os.path.abspath(os.environ['WAFCACHE']) +except KeyError:cache_global='' +platform=Utils.unversioned_sys_platform() +class opt_parser(optparse.OptionParser): + def __init__(self,ctx): + optparse.OptionParser.__init__(self,conflict_handler="resolve",version='waf %s (%s)'%(Context.WAFVERSION,Context.WAFREVISION)) + self.formatter.width=Logs.get_term_cols() + p=self.add_option + self.ctx=ctx + jobs=ctx.jobs() + p('-j','--jobs',dest='jobs',default=jobs,type='int',help='amount of parallel jobs (%r)'%jobs) + p('-k','--keep',dest='keep',default=0,action='count',help='keep running happily even if errors are found') + p('-v','--verbose',dest='verbose',default=0,action='count',help='verbosity level -v -vv or -vvv [default: 0]') + p('--nocache',dest='nocache',default=False,action='store_true',help='ignore the WAFCACHE (if set)') + p('--zones',dest='zones',default='',action='store',help='debugging zones (task_gen, deps, tasks, etc)') + gr=optparse.OptionGroup(self,'configure options') + self.add_option_group(gr) + gr.add_option('-o','--out',action='store',default='',help='build dir for the project',dest='out') + gr.add_option('-t','--top',action='store',default='',help='src dir for the project',dest='top') + default_prefix=os.environ.get('PREFIX') + if not default_prefix: + if platform=='win32': + d=tempfile.gettempdir() + default_prefix=d[0].upper()+d[1:] + else: + default_prefix='/usr/local/' + gr.add_option('--prefix',dest='prefix',default=default_prefix,help='installation prefix [default: %r]'%default_prefix) + gr.add_option('--download',dest='download',default=False,action='store_true',help='try to download the tools if missing') + gr=optparse.OptionGroup(self,'build and install options') + self.add_option_group(gr) + gr.add_option('-p','--progress',dest='progress_bar',default=0,action='count',help='-p: progress bar; -pp: ide output') + gr.add_option('--targets',dest='targets',default='',action='store',help='task generators, e.g. "target1,target2"') + gr=optparse.OptionGroup(self,'step options') + self.add_option_group(gr) + gr.add_option('--files',dest='files',default='',action='store',help='files to process, by regexp, e.g. "*/main.c,*/test/main.o"') + default_destdir=os.environ.get('DESTDIR','') + gr=optparse.OptionGroup(self,'install/uninstall options') + self.add_option_group(gr) + gr.add_option('--destdir',help='installation root [default: %r]'%default_destdir,default=default_destdir,dest='destdir') + gr.add_option('-f','--force',dest='force',default=False,action='store_true',help='force file installation') + def get_usage(self): + cmds_str={} + for cls in Context.classes: + if not cls.cmd or cls.cmd=='options': + continue + s=cls.__doc__ or'' + cmds_str[cls.cmd]=s + if Context.g_module: + for(k,v)in Context.g_module.__dict__.items(): + if k in['options','init','shutdown']: + continue + if type(v)is type(Context.create_context): + if v.__doc__ and not k.startswith('_'): + cmds_str[k]=v.__doc__ + just=0 + for k in cmds_str: + just=max(just,len(k)) + lst=[' %s: %s'%(k.ljust(just),v)for(k,v)in cmds_str.items()] + lst.sort() + ret='\n'.join(lst) + return'''waf [commands] [options] + +Main commands (example: ./waf build -j4) +%s +'''%ret +class OptionsContext(Context.Context): + cmd='options' + fun='options' + def __init__(self,**kw): + super(OptionsContext,self).__init__(**kw) + self.parser=opt_parser(self) + self.option_groups={} + def jobs(self): + count=int(os.environ.get('JOBS',0)) + if count<1: + if'NUMBER_OF_PROCESSORS'in os.environ: + count=int(os.environ.get('NUMBER_OF_PROCESSORS',1)) + else: + if hasattr(os,'sysconf_names'): + if'SC_NPROCESSORS_ONLN'in os.sysconf_names: + count=int(os.sysconf('SC_NPROCESSORS_ONLN')) + elif'SC_NPROCESSORS_CONF'in os.sysconf_names: + count=int(os.sysconf('SC_NPROCESSORS_CONF')) + if not count and os.name not in('nt','java'): + try: + tmp=self.cmd_and_log(['sysctl','-n','hw.ncpu'],quiet=0) + except Exception: + pass + else: + if re.match('^[0-9]+$',tmp): + count=int(tmp) + if count<1: + count=1 + elif count>1024: + count=1024 + return count + def add_option(self,*k,**kw): + self.parser.add_option(*k,**kw) + def add_option_group(self,*k,**kw): + try: + gr=self.option_groups[k[0]] + except: + gr=self.parser.add_option_group(*k,**kw) + self.option_groups[k[0]]=gr + return gr + def get_option_group(self,opt_str): + try: + return self.option_groups[opt_str] + except KeyError: + for group in self.parser.option_groups: + if group.title==opt_str: + return group + return None + def parse_args(self,_args=None): + global options,commands + (options,leftover_args)=self.parser.parse_args(args=_args) + commands=leftover_args + if options.destdir: + options.destdir=os.path.abspath(os.path.expanduser(options.destdir)) + if options.verbose>=1: + self.load('errcheck') + def execute(self): + super(OptionsContext,self).execute() + self.parse_args() diff -Nru jalv-0~svn3409/waflib/Runner.py jalv-1.0.0~dfsg0/waflib/Runner.py --- jalv-0~svn3409/waflib/Runner.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Runner.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,196 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import random,atexit +try: + from queue import Queue +except: + from Queue import Queue +from waflib import Utils,Task,Errors,Logs +GAP=10 +class TaskConsumer(Utils.threading.Thread): + def __init__(self): + Utils.threading.Thread.__init__(self) + self.ready=Queue() + self.setDaemon(1) + self.start() + def run(self): + try: + self.loop() + except: + pass + def loop(self): + while 1: + tsk=self.ready.get() + if not isinstance(tsk,Task.TaskBase): + tsk(self) + else: + tsk.process() +pool=Queue() +def get_pool(): + try: + return pool.get(False) + except: + return TaskConsumer() +def put_pool(x): + pool.put(x) +def _free_resources(): + global pool + lst=[] + while pool.qsize(): + lst.append(pool.get()) + for x in lst: + x.ready.put(None) + for x in lst: + x.join() + pool=None +atexit.register(_free_resources) +class Parallel(object): + def __init__(self,bld,j=2): + self.numjobs=j + self.bld=bld + self.outstanding=[] + self.frozen=[] + self.out=Queue(0) + self.count=0 + self.processed=1 + self.stop=False + self.error=[] + self.biter=None + self.dirty=False + def get_next_task(self): + if not self.outstanding: + return None + return self.outstanding.pop(0) + def postpone(self,tsk): + if random.randint(0,1): + self.frozen.insert(0,tsk) + else: + self.frozen.append(tsk) + def refill_task_list(self): + while self.count>self.numjobs*GAP: + self.get_out() + while not self.outstanding: + if self.count: + self.get_out() + elif self.frozen: + try: + cond=self.deadlock==self.processed + except: + pass + else: + if cond: + msg='check the build order for the tasks' + for tsk in self.frozen: + if not tsk.run_after: + msg='check the methods runnable_status' + break + lst=[] + for tsk in self.frozen: + lst.append('%s\t-> %r'%(repr(tsk),[id(x)for x in tsk.run_after])) + raise Errors.WafError('Deadlock detected: %s%s'%(msg,''.join(lst))) + self.deadlock=self.processed + if self.frozen: + self.outstanding+=self.frozen + self.frozen=[] + elif not self.count: + self.outstanding.extend(self.biter.next()) + self.total=self.bld.total() + break + def add_more_tasks(self,tsk): + if getattr(tsk,'more_tasks',None): + self.outstanding+=tsk.more_tasks + self.total+=len(tsk.more_tasks) + def get_out(self): + tsk=self.out.get() + if not self.stop: + self.add_more_tasks(tsk) + self.count-=1 + self.dirty=True + def error_handler(self,tsk): + if not self.bld.keep: + self.stop=True + self.error.append(tsk) + def add_task(self,tsk): + try: + self.pool + except AttributeError: + self.init_task_pool() + self.ready.put(tsk) + def init_task_pool(self): + pool=self.pool=[get_pool()for i in range(self.numjobs)] + self.ready=Queue(0) + def setq(consumer): + consumer.ready=self.ready + for x in pool: + x.ready.put(setq) + return pool + def free_task_pool(self): + def setq(consumer): + consumer.ready=Queue(0) + self.out.put(self) + try: + pool=self.pool + except: + pass + else: + for x in pool: + self.ready.put(setq) + for x in pool: + self.get_out() + for x in pool: + put_pool(x) + self.pool=[] + def start(self): + self.total=self.bld.total() + while not self.stop: + self.refill_task_list() + tsk=self.get_next_task() + if not tsk: + if self.count: + continue + else: + break + if tsk.hasrun: + self.processed+=1 + continue + if self.stop: + break + try: + st=tsk.runnable_status() + except Exception: + self.processed+=1 + tsk.err_msg=Utils.ex_stack() + if not self.stop and self.bld.keep: + tsk.hasrun=Task.SKIPPED + if self.bld.keep==1: + if Logs.verbose>1 or not self.error: + self.error.append(tsk) + self.stop=True + else: + if Logs.verbose>1: + self.error.append(tsk) + continue + tsk.hasrun=Task.EXCEPTION + self.error_handler(tsk) + continue + if st==Task.ASK_LATER: + self.postpone(tsk) + elif st==Task.SKIP_ME: + self.processed+=1 + tsk.hasrun=Task.SKIPPED + self.add_more_tasks(tsk) + else: + tsk.position=(self.processed,self.total) + self.count+=1 + tsk.master=self + self.processed+=1 + if self.numjobs==1: + tsk.process() + else: + self.add_task(tsk) + while self.error and self.count: + self.get_out() + assert(self.count==0 or self.stop) + self.free_task_pool() diff -Nru jalv-0~svn3409/waflib/Scripting.py jalv-1.0.0~dfsg0/waflib/Scripting.py --- jalv-0~svn3409/waflib/Scripting.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Scripting.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,367 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shutil,traceback,errno,sys,stat +from waflib import Utils,Configure,Logs,Options,ConfigSet,Context,Errors,Build,Node +build_dir_override=None +no_climb_commands=['configure'] +default_cmd="build" +def waf_entry_point(current_directory,version,wafdir): + Logs.init_log() + if Context.WAFVERSION!=version: + Logs.error('Waf script %r and library %r do not match (directory %r)'%(version,Context.WAFVERSION,wafdir)) + sys.exit(1) + if'--version'in sys.argv: + Context.run_dir=current_directory + ctx=Context.create_context('options') + ctx.curdir=current_directory + ctx.parse_args() + sys.exit(0) + Context.waf_dir=wafdir + Context.launch_dir=current_directory + no_climb=os.environ.get('NOCLIMB',None) + if not no_climb: + for k in no_climb_commands: + if k in sys.argv: + no_climb=True + break + cur=current_directory + while cur: + lst=os.listdir(cur) + if Options.lockfile in lst: + env=ConfigSet.ConfigSet() + try: + env.load(os.path.join(cur,Options.lockfile)) + ino=os.stat(cur)[stat.ST_INO] + except Exception: + pass + else: + for x in[env.run_dir,env.top_dir,env.out_dir]: + if Utils.is_win32: + if cur==x: + load=True + break + else: + try: + ino2=os.stat(x)[stat.ST_INO] + except: + pass + else: + if ino==ino2: + load=True + break + else: + Logs.warn('invalid lock file in %s'%cur) + load=False + if load: + Context.run_dir=env.run_dir + Context.top_dir=env.top_dir + Context.out_dir=env.out_dir + break + if not Context.run_dir: + if Context.WSCRIPT_FILE in lst: + Context.run_dir=cur + next=os.path.dirname(cur) + if next==cur: + break + cur=next + if no_climb: + break + if not Context.run_dir: + if'-h'in sys.argv or'--help'in sys.argv: + Logs.warn('No wscript file found: the help message may be incomplete') + Context.run_dir=current_directory + ctx=Context.create_context('options') + ctx.curdir=current_directory + ctx.parse_args() + sys.exit(0) + Logs.error('Waf: Run from a directory containing a file named %r'%Context.WSCRIPT_FILE) + sys.exit(1) + try: + os.chdir(Context.run_dir) + except OSError: + Logs.error('Waf: The folder %r is unreadable'%Context.run_dir) + sys.exit(1) + try: + set_main_module(Context.run_dir+os.sep+Context.WSCRIPT_FILE) + except Errors.WafError ,e: + Logs.pprint('RED',e.verbose_msg) + Logs.error(str(e)) + sys.exit(1) + except Exception ,e: + Logs.error('Waf: The wscript in %r is unreadable'%Context.run_dir,e) + traceback.print_exc(file=sys.stdout) + sys.exit(2) + try: + run_commands() + except Errors.WafError ,e: + if Logs.verbose>1: + Logs.pprint('RED',e.verbose_msg) + Logs.error(e.msg) + sys.exit(1) + except Exception ,e: + traceback.print_exc(file=sys.stdout) + sys.exit(2) + except KeyboardInterrupt: + Logs.pprint('RED','Interrupted') + sys.exit(68) +def set_main_module(file_path): + Context.g_module=Context.load_module(file_path) + Context.g_module.root_path=file_path + def set_def(obj): + name=obj.__name__ + if not name in Context.g_module.__dict__: + setattr(Context.g_module,name,obj) + for k in[update,dist,distclean,distcheck,update]: + set_def(k) + if not'init'in Context.g_module.__dict__: + Context.g_module.init=Utils.nada + if not'shutdown'in Context.g_module.__dict__: + Context.g_module.shutdown=Utils.nada + if not'options'in Context.g_module.__dict__: + Context.g_module.options=Utils.nada +def parse_options(): + Context.create_context('options').execute() + if not Options.commands: + Options.commands=[default_cmd] + Options.commands=[x for x in Options.commands if x!='options'] + Logs.verbose=Options.options.verbose + Logs.init_log() + if Options.options.zones: + Logs.zones=Options.options.zones.split(',') + if not Logs.verbose: + Logs.verbose=1 + elif Logs.verbose>0: + Logs.zones=['runner'] + if Logs.verbose>2: + Logs.zones=['*'] +def run_command(cmd_name): + ctx=Context.create_context(cmd_name) + ctx.options=Options.options + ctx.cmd=cmd_name + ctx.execute() + return ctx +def run_commands(): + parse_options() + run_command('init') + while Options.commands: + cmd_name=Options.commands.pop(0) + timer=Utils.Timer() + run_command(cmd_name) + if not Options.options.progress_bar: + elapsed=' (%s)'%str(timer) + Logs.info('%r finished successfully%s'%(cmd_name,elapsed)) + run_command('shutdown') +def _can_distclean(name): + for k in'.o .moc .exe'.split(): + if name.endswith(k): + return True + return False +def distclean_dir(dirname): + for(root,dirs,files)in os.walk(dirname): + for f in files: + if _can_distclean(f): + fname=root+os.sep+f + try: + os.unlink(fname) + except: + Logs.warn('could not remove %r'%fname) + for x in[Context.DBFILE,'config.log']: + try: + os.unlink(x) + except: + pass + try: + shutil.rmtree('c4che') + except: + pass +def distclean(ctx): + '''removes the build directory''' + lst=os.listdir('.') + for f in lst: + if f==Options.lockfile: + try: + proj=ConfigSet.ConfigSet(f) + except: + Logs.warn('could not read %r'%f) + continue + if proj['out_dir']!=proj['top_dir']: + try: + shutil.rmtree(proj['out_dir']) + except IOError: + pass + except OSError ,e: + if e.errno!=errno.ENOENT: + Logs.warn('project %r cannot be removed'%proj[Context.OUT]) + else: + distclean_dir(proj['out_dir']) + for k in(proj['out_dir'],proj['top_dir'],proj['run_dir']): + try: + os.remove(os.path.join(k,Options.lockfile)) + except OSError ,e: + if e.errno!=errno.ENOENT: + Logs.warn('file %r cannot be removed'%f) + if f.startswith('.waf-')and not Options.commands: + shutil.rmtree(f,ignore_errors=True) +class Dist(Context.Context): + cmd='dist' + fun='dist' + algo='tar.bz2' + ext_algo={} + def execute(self): + self.recurse([os.path.dirname(Context.g_module.root_path)]) + self.archive() + def archive(self): + import tarfile + arch_name=self.get_arch_name() + try: + self.base_path + except: + self.base_path=self.path + node=self.base_path.make_node(arch_name) + try: + node.delete() + except: + pass + files=self.get_files() + if self.algo.startswith('tar.'): + tar=tarfile.open(arch_name,'w:'+self.algo.replace('tar.','')) + for x in files: + self.add_tar_file(x,tar) + tar.close() + elif self.algo=='zip': + import zipfile + zip=zipfile.ZipFile(arch_name,'w',compression=zipfile.ZIP_DEFLATED) + for x in files: + archive_name=self.get_base_name()+'/'+x.path_from(self.base_path) + zip.write(x.abspath(),archive_name,zipfile.ZIP_DEFLATED) + zip.close() + else: + self.fatal('Valid algo types are tar.bz2, tar.gz or zip') + try: + from hashlib import sha1 as sha + except ImportError: + from sha import sha + try: + digest=" (sha=%r)"%sha(node.read()).hexdigest() + except: + digest='' + Logs.info('New archive created: %s%s'%(self.arch_name,digest)) + def get_tar_path(self,node): + return node.abspath() + def add_tar_file(self,x,tar): + p=self.get_tar_path(x) + tinfo=tar.gettarinfo(name=p,arcname=self.get_tar_prefix()+'/'+x.path_from(self.base_path)) + tinfo.uid=0 + tinfo.gid=0 + tinfo.uname='root' + tinfo.gname='root' + fu=None + try: + fu=open(p,'rb') + tar.addfile(tinfo,fileobj=fu) + finally: + if fu: + fu.close() + def get_tar_prefix(self): + try: + return self.tar_prefix + except: + return self.get_base_name() + def get_arch_name(self): + try: + self.arch_name + except: + self.arch_name=self.get_base_name()+'.'+self.ext_algo.get(self.algo,self.algo) + return self.arch_name + def get_base_name(self): + try: + self.base_name + except: + appname=getattr(Context.g_module,Context.APPNAME,'noname') + version=getattr(Context.g_module,Context.VERSION,'1.0') + self.base_name=appname+'-'+version + return self.base_name + def get_excl(self): + try: + return self.excl + except: + self.excl=Node.exclude_regs+' **/waf-1.6.* **/.waf-1.6* **/*~ **/*.rej **/*.orig **/*.pyc **/*.pyo **/*.bak **/*.swp **/.lock-w*' + nd=self.root.find_node(Context.out_dir) + if nd: + self.excl+=' '+nd.path_from(self.base_path) + return self.excl + def get_files(self): + try: + files=self.files + except: + files=self.base_path.ant_glob('**/*',excl=self.get_excl()) + return files +def dist(ctx): + '''makes a tarball for redistributing the sources''' + pass +class DistCheck(Dist): + fun='distcheck' + cmd='distcheck' + def execute(self): + self.recurse([os.path.dirname(Context.g_module.root_path)]) + self.archive() + self.check() + def check(self): + import tempfile,tarfile + t=None + try: + t=tarfile.open(self.get_arch_name()) + for x in t: + t.extract(x) + finally: + if t: + t.close() + instdir=tempfile.mkdtemp('.inst',self.get_base_name()) + ret=Utils.subprocess.Popen([sys.argv[0],'configure','install','uninstall','--destdir='+instdir],cwd=self.get_base_name()).wait() + if ret: + raise Errors.WafError('distcheck failed with code %i'%ret) + if os.path.exists(instdir): + raise Errors.WafError('distcheck succeeded, but files were left in %s'%instdir) + shutil.rmtree(self.get_base_name()) +def distcheck(ctx): + '''checks if the project compiles (tarball from 'dist')''' + pass +def update(ctx): + '''updates the plugins from the *waflib/extras* directory''' + lst=Options.options.files.split(',') + if not lst: + lst=[x for x in Utils.listdir(Context.waf_dir+'/waflib/extras')if x.endswith('.py')] + for x in lst: + tool=x.replace('.py','') + try: + Configure.download_tool(tool,force=True,ctx=ctx) + except Errors.WafError: + Logs.error('Could not find the tool %s in the remote repository'%x) +def autoconfigure(execute_method): + def execute(self): + if not Configure.autoconfig: + return execute_method(self) + env=ConfigSet.ConfigSet() + do_config=False + try: + env.load(os.path.join(Context.top_dir,Options.lockfile)) + except Exception: + Logs.warn('Configuring the project') + do_config=True + else: + if env.run_dir!=Context.run_dir: + do_config=True + else: + h=0 + for f in env['files']: + h=hash((h,Utils.readf(f,'rb'))) + do_config=h!=env.hash + if do_config: + Options.commands.insert(0,self.cmd) + Options.commands.insert(0,'configure') + return + return execute_method(self) + return execute +Build.BuildContext.execute=autoconfigure(Build.BuildContext.execute) diff -Nru jalv-0~svn3409/waflib/TaskGen.py jalv-1.0.0~dfsg0/waflib/TaskGen.py --- jalv-0~svn3409/waflib/TaskGen.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/TaskGen.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,353 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import copy,re,os +from waflib import Task,Utils,Logs,Errors,ConfigSet +feats=Utils.defaultdict(set) +class task_gen(object): + mappings={} + prec=Utils.defaultdict(list) + def __init__(self,*k,**kw): + self.source='' + self.target='' + self.meths=[] + self.prec=Utils.defaultdict(list) + self.mappings={} + self.features=[] + self.tasks=[] + if not'bld'in kw: + self.env=ConfigSet.ConfigSet() + self.idx=0 + self.path=None + else: + self.bld=kw['bld'] + self.env=self.bld.env.derive() + self.path=self.bld.path + try: + self.idx=self.bld.idx[id(self.path)]=self.bld.idx.get(id(self.path),0)+1 + except AttributeError: + self.bld.idx={} + self.idx=self.bld.idx[id(self.path)]=1 + for key,val in kw.items(): + setattr(self,key,val) + def __str__(self): + return""%(self.name,self.path.abspath()) + def __repr__(self): + lst=[] + for x in self.__dict__.keys(): + if x not in['env','bld','compiled_tasks','tasks']: + lst.append("%s=%s"%(x,repr(getattr(self,x)))) + return"bld(%s) in %s"%(", ".join(lst),self.path.abspath()) + def get_name(self): + try: + return self._name + except AttributeError: + if isinstance(self.target,list): + lst=[str(x)for x in self.target] + name=self._name=','.join(lst) + else: + name=self._name=str(self.target) + return name + def set_name(self,name): + self._name=name + name=property(get_name,set_name) + def to_list(self,val): + if isinstance(val,str):return val.split() + else:return val + def post(self): + if getattr(self,'posted',None): + return False + self.posted=True + keys=set(self.meths) + self.features=Utils.to_list(self.features) + for x in self.features+['*']: + st=feats[x] + if not st: + if not x in Task.classes: + Logs.warn('feature %r does not exist - bind at least one method to it'%x) + keys.update(list(st)) + prec={} + prec_tbl=self.prec or task_gen.prec + for x in prec_tbl: + if x in keys: + prec[x]=prec_tbl[x] + tmp=[] + for a in keys: + for x in prec.values(): + if a in x:break + else: + tmp.append(a) + out=[] + while tmp: + e=tmp.pop() + if e in keys:out.append(e) + try: + nlst=prec[e] + except KeyError: + pass + else: + del prec[e] + for x in nlst: + for y in prec: + if x in prec[y]: + break + else: + tmp.append(x) + if prec: + raise Errors.WafError('Cycle detected in the method execution %r'%prec) + out.reverse() + self.meths=out + Logs.debug('task_gen: posting %s %d'%(self,id(self))) + for x in out: + try: + v=getattr(self,x) + except AttributeError: + raise Errors.WafError('%r is not a valid task generator method'%x) + Logs.debug('task_gen: -> %s (%d)'%(x,id(self))) + v() + Logs.debug('task_gen: posted %s'%self.name) + return True + def get_hook(self,node): + name=node.name + for k in self.mappings: + if name.endswith(k): + return self.mappings[k] + for k in task_gen.mappings: + if name.endswith(k): + return task_gen.mappings[k] + raise Errors.WafError("File %r has no mapping in %r (did you forget to load a waf tool?)"%(node,task_gen.mappings.keys())) + def create_task(self,name,src=None,tgt=None): + task=Task.classes[name](env=self.env.derive(),generator=self) + if src: + task.set_inputs(src) + if tgt: + task.set_outputs(tgt) + self.tasks.append(task) + return task + def clone(self,env): + newobj=self.bld() + for x in self.__dict__: + if x in['env','bld']: + continue + elif x in['path','features']: + setattr(newobj,x,getattr(self,x)) + else: + setattr(newobj,x,copy.copy(getattr(self,x))) + newobj.posted=False + if isinstance(env,str): + newobj.env=self.bld.all_envs[env].derive() + else: + newobj.env=env.derive() + return newobj +def declare_chain(name='',rule=None,reentrant=None,color='BLUE',ext_in=[],ext_out=[],before=[],after=[],decider=None,scan=None,install_path=None,shell=False): + ext_in=Utils.to_list(ext_in) + ext_out=Utils.to_list(ext_out) + if not name: + name=rule + cls=Task.task_factory(name,rule,color=color,ext_in=ext_in,ext_out=ext_out,before=before,after=after,scan=scan,shell=shell) + def x_file(self,node): + ext=decider and decider(self,node)or cls.ext_out + if ext_in: + _ext_in=ext_in[0] + tsk=self.create_task(name,node) + cnt=0 + keys=self.mappings.keys()+self.__class__.mappings.keys() + for x in ext: + k=node.change_ext(x,ext_in=_ext_in) + tsk.outputs.append(k) + if reentrant!=None: + if cnt task failed (exit status %r): %r\n%r'%(self.err_code,self,msg) + except AttributeError: + return' -> task failed: %r\n%r'%(self,msg) + elif self.hasrun==MISSING: + return' -> missing files: %r\n%r'%(self,msg) + else: + return'invalid status %r'%self.hasrun + def colon(self,var1,var2): + tmp=self.env[var1] + if isinstance(var2,str): + it=self.env[var2] + else: + it=var2 + if isinstance(tmp,str): + return[tmp%x for x in it] + else: + if Logs.verbose and not tmp and it: + Logs.warn('Missing env variable %r for task %r (generator %r)'%(var1,self,self.generator)) + lst=[] + for y in it: + lst.extend(tmp) + lst.append(y) + return lst +class Task(TaskBase): + vars=[] + shell=False + def __init__(self,*k,**kw): + TaskBase.__init__(self,*k,**kw) + self.env=kw['env'] + self.inputs=[] + self.outputs=[] + self.dep_nodes=[] + self.run_after=set([]) + def __str__(self): + env=self.env + src_str=' '.join([a.nice_path(env)for a in self.inputs]) + tgt_str=' '.join([a.nice_path(env)for a in self.outputs]) + if self.outputs:sep=' -> ' + else:sep='' + return'%s: %s%s%s\n'%(self.__class__.__name__.replace('_task',''),src_str,sep,tgt_str) + def __repr__(self): + return"".join(['\n\t{task %r: '%id(self),self.__class__.__name__," ",",".join([x.name for x in self.inputs])," -> ",",".join([x.name for x in self.outputs]),'}']) + def uid(self): + try: + return self.uid_ + except AttributeError: + m=Utils.md5() + up=m.update + up(self.__class__.__name__) + for x in self.inputs+self.outputs: + up(x.abspath()) + self.uid_=m.digest() + return self.uid_ + def set_inputs(self,inp): + if isinstance(inp,list):self.inputs+=inp + else:self.inputs.append(inp) + def set_outputs(self,out): + if isinstance(out,list):self.outputs+=out + else:self.outputs.append(out) + def set_run_after(self,task): + assert isinstance(task,TaskBase) + self.run_after.add(task) + def signature(self): + try:return self.cache_sig + except AttributeError:pass + self.m=Utils.md5() + self.m.update(self.hcode) + self.sig_explicit_deps() + self.sig_vars() + if self.scan: + try: + self.sig_implicit_deps() + except Errors.TaskRescan: + return self.signature() + ret=self.cache_sig=self.m.digest() + return ret + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return ASK_LATER + bld=self.generator.bld + try: + new_sig=self.signature() + except Errors.TaskNotReady: + return ASK_LATER + key=self.uid() + try: + prev_sig=bld.task_sigs[key] + except KeyError: + Logs.debug("task: task %r must run as it was never run before or the task code changed"%self) + return RUN_ME + for node in self.outputs: + try: + if node.sig!=new_sig: + return RUN_ME + except AttributeError: + Logs.debug("task: task %r must run as the output nodes do not exist"%self) + return RUN_ME + if new_sig!=prev_sig: + return RUN_ME + return SKIP_ME + def post_run(self): + bld=self.generator.bld + sig=self.signature() + for node in self.outputs: + try: + os.stat(node.abspath()) + except OSError: + self.hasrun=MISSING + self.err_msg='-> missing file: %r'%node.abspath() + raise Errors.WafError(self.err_msg) + node.sig=sig + bld.task_sigs[self.uid()]=self.cache_sig + def sig_explicit_deps(self): + bld=self.generator.bld + upd=self.m.update + for x in self.inputs+self.dep_nodes: + try: + upd(x.get_bld_sig()) + except(AttributeError,TypeError): + raise Errors.WafError('Missing node signature for %r (required by %r)'%(x,self)) + if bld.deps_man: + additional_deps=bld.deps_man + for x in self.inputs+self.outputs: + try: + d=additional_deps[id(x)] + except KeyError: + continue + for v in d: + if isinstance(v,bld.root.__class__): + try: + v=v.get_bld_sig() + except AttributeError: + raise Errors.WafError('Missing node signature for %r (required by %r)'%(v,self)) + elif hasattr(v,'__call__'): + v=v() + upd(v) + return self.m.digest() + def sig_vars(self): + bld=self.generator.bld + env=self.env + upd=self.m.update + act_sig=bld.hash_env_vars(env,self.__class__.vars) + upd(act_sig) + dep_vars=getattr(self,'dep_vars',None) + if dep_vars: + upd(bld.hash_env_vars(env,dep_vars)) + return self.m.digest() + scan=None + def sig_implicit_deps(self): + bld=self.generator.bld + key=self.uid() + prev=bld.task_sigs.get((key,'imp'),[]) + if prev: + try: + if prev==self.compute_sig_implicit_deps(): + return prev + except: + for x in bld.node_deps.get(self.uid(),[]): + if x.is_child_of(bld.srcnode): + try: + os.stat(x.abspath()) + except: + try: + del x.parent.children[x.name] + except: + pass + del bld.task_sigs[(key,'imp')] + raise Errors.TaskRescan('rescan') + (nodes,names)=self.scan() + if Logs.verbose: + Logs.debug('deps: scanner for %s returned %s %s'%(str(self),str(nodes),str(names))) + bld.node_deps[key]=nodes + bld.raw_deps[key]=names + self.are_implicit_nodes_ready() + try: + bld.task_sigs[(key,'imp')]=sig=self.compute_sig_implicit_deps() + except: + if Logs.verbose: + for k in bld.node_deps.get(self.uid(),[]): + try: + k.get_bld_sig() + except: + Logs.warn('Missing signature for node %r (may cause rebuilds)'%k) + else: + return sig + def compute_sig_implicit_deps(self): + upd=self.m.update + bld=self.generator.bld + self.are_implicit_nodes_ready() + for k in bld.node_deps.get(self.uid(),[]): + upd(k.get_bld_sig()) + return self.m.digest() + def are_implicit_nodes_ready(self): + bld=self.generator.bld + try: + cache=bld.dct_implicit_nodes + except: + bld.dct_implicit_nodes=cache={} + try: + dct=cache[bld.cur] + except KeyError: + dct=cache[bld.cur]={} + for tsk in bld.cur_tasks: + for x in tsk.outputs: + dct[x]=tsk + modified=False + for x in bld.node_deps.get(self.uid(),[]): + if x in dct: + self.run_after.add(dct[x]) + modified=True + if modified: + for tsk in self.run_after: + if not tsk.hasrun: + raise Errors.TaskNotReady('not ready') + def can_retrieve_cache(self): + if not getattr(self,'outputs',None): + return None + sig=self.signature() + ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig) + dname=os.path.join(self.generator.bld.cache_global,ssig) + try: + t1=os.stat(dname).st_mtime + except OSError: + return None + for node in self.outputs: + orig=os.path.join(dname,node.name) + try: + shutil.copy2(orig,node.abspath()) + os.utime(orig,None) + except(OSError,IOError): + Logs.debug('task: failed retrieving file') + return None + try: + t2=os.stat(dname).st_mtime + except OSError: + return None + if t1!=t2: + return None + for node in self.outputs: + node.sig=sig + if self.generator.bld.progress_bar<1: + self.generator.bld.to_log('restoring from cache %r\n'%node.abspath()) + self.cached=True + return True + def put_files_cache(self): + if getattr(self,'cached',None): + return None + if not getattr(self,'outputs',None): + return None + sig=self.signature() + ssig=Utils.to_hex(self.uid())+Utils.to_hex(sig) + dname=os.path.join(self.generator.bld.cache_global,ssig) + tmpdir=tempfile.mkdtemp(prefix=self.generator.bld.cache_global+os.sep+'waf') + try: + shutil.rmtree(dname) + except: + pass + try: + for node in self.outputs: + dest=os.path.join(tmpdir,node.name) + shutil.copy2(node.abspath(),dest) + except(OSError,IOError): + try: + shutil.rmtree(tmpdir) + except: + pass + else: + try: + os.rename(tmpdir,dname) + except OSError: + try: + shutil.rmtree(tmpdir) + except: + pass + else: + try: + os.chmod(dname,Utils.O755) + except: + pass +def is_before(t1,t2): + to_list=Utils.to_list + for k in to_list(t2.ext_in): + if k in to_list(t1.ext_out): + return 1 + if t1.__class__.__name__ in to_list(t2.after): + return 1 + if t2.__class__.__name__ in to_list(t1.before): + return 1 + return 0 +def set_file_constraints(tasks): + ins=Utils.defaultdict(set) + outs=Utils.defaultdict(set) + for x in tasks: + for a in getattr(x,'inputs',[])+getattr(x,'dep_nodes',[]): + ins[id(a)].add(x) + for a in getattr(x,'outputs',[]): + outs[id(a)].add(x) + links=set(ins.keys()).intersection(outs.keys()) + for k in links: + for a in ins[k]: + a.run_after.update(outs[k]) +def set_precedence_constraints(tasks): + cstr_groups=Utils.defaultdict(list) + for x in tasks: + h=x.hash_constraints() + cstr_groups[h].append(x) + keys=list(cstr_groups.keys()) + maxi=len(keys) + for i in range(maxi): + t1=cstr_groups[keys[i]][0] + for j in range(i+1,maxi): + t2=cstr_groups[keys[j]][0] + if is_before(t1,t2): + a=i + b=j + elif is_before(t2,t1): + a=j + b=i + else: + continue + for x in cstr_groups[keys[b]]: + x.run_after.update(cstr_groups[keys[a]]) +def funex(c): + dc={} + exec(c,dc) + return dc['f'] +reg_act=re.compile(r"(?P\\)|(?P\$\$)|(?P\$\{(?P\w+)(?P.*?)\})",re.M) +def compile_fun_shell(line): + extr=[] + def repl(match): + g=match.group + if g('dollar'):return"$" + elif g('backslash'):return'\\\\' + elif g('subst'):extr.append((g('var'),g('code')));return"%s" + return None + line=reg_act.sub(repl,line)or line + parm=[] + dvars=[] + app=parm.append + for(var,meth)in extr: + if var=='SRC': + if meth:app('tsk.inputs%s'%meth) + else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.inputs])') + elif var=='TGT': + if meth:app('tsk.outputs%s'%meth) + else:app('" ".join([a.path_from(bld.bldnode) for a in tsk.outputs])') + elif meth: + if meth.startswith(':'): + m=meth[1:] + if m=='SRC': + m='[a.path_from(bld.bldnode) for a in tsk.inputs]' + elif m=='TGT': + m='[a.path_from(bld.bldnode) for a in tsk.outputs]' + elif m[:3]not in('tsk','gen','bld'): + dvars.extend([var,meth[1:]]) + m='%r'%m + app('" ".join(tsk.colon(%r, %s))'%(var,m)) + else: + app('%s%s'%(var,meth)) + else: + if not var in dvars:dvars.append(var) + app("p('%s')"%var) + if parm:parm="%% (%s) "%(',\n\t\t'.join(parm)) + else:parm='' + c=COMPILE_TEMPLATE_SHELL%(line,parm) + Logs.debug('action: %s'%c) + return(funex(c),dvars) +def compile_fun_noshell(line): + extr=[] + def repl(match): + g=match.group + if g('dollar'):return"$" + elif g('subst'):extr.append((g('var'),g('code')));return"<<|@|>>" + return None + line2=reg_act.sub(repl,line) + params=line2.split('<<|@|>>') + assert(extr) + buf=[] + dvars=[] + app=buf.append + for x in range(len(extr)): + params[x]=params[x].strip() + if params[x]: + app("lst.extend(%r)"%params[x].split()) + (var,meth)=extr[x] + if var=='SRC': + if meth:app('lst.append(tsk.inputs%s)'%meth) + else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.inputs])") + elif var=='TGT': + if meth:app('lst.append(tsk.outputs%s)'%meth) + else:app("lst.extend([a.path_from(bld.bldnode) for a in tsk.outputs])") + elif meth: + if meth.startswith(':'): + m=meth[1:] + if m=='SRC': + m='[a.path_from(bld.bldnode) for a in tsk.inputs]' + elif m=='TGT': + m='[a.path_from(bld.bldnode) for a in tsk.outputs]' + elif m[:3]not in('tsk','gen','bld'): + dvars.extend([var,m]) + m='%r'%m + app('lst.extend(tsk.colon(%r, %s))'%(var,m)) + else: + app('lst.extend(gen.to_list(%s%s))'%(var,meth)) + else: + app('lst.extend(to_list(env[%r]))'%var) + if not var in dvars:dvars.append(var) + if extr: + if params[-1]: + app("lst.extend(%r)"%params[-1].split()) + fun=COMPILE_TEMPLATE_NOSHELL%"\n\t".join(buf) + Logs.debug('action: %s'%fun) + return(funex(fun),dvars) +def compile_fun(line,shell=False): + if line.find('<')>0 or line.find('>')>0 or line.find('&&')>0: + shell=True + if shell: + return compile_fun_shell(line) + else: + return compile_fun_noshell(line) +def task_factory(name,func=None,vars=None,color='GREEN',ext_in=[],ext_out=[],before=[],after=[],shell=False,scan=None): + params={'vars':vars or[],'color':color,'name':name,'ext_in':Utils.to_list(ext_in),'ext_out':Utils.to_list(ext_out),'before':Utils.to_list(before),'after':Utils.to_list(after),'shell':shell,'scan':scan,} + if isinstance(func,str): + params['run_str']=func + else: + params['run']=func + cls=type(Task)(name,(Task,),params) + global classes + classes[name]=cls + return cls +def always_run(cls): + old=cls.runnable_status + def always(self): + ret=old(self) + if ret==SKIP_ME: + ret=RUN_ME + return ret + cls.runnable_status=always + return cls +def update_outputs(cls): + old_post_run=cls.post_run + def post_run(self): + old_post_run(self) + for node in self.outputs: + node.sig=Utils.h_file(node.abspath()) + self.generator.bld.task_sigs[node.abspath()]=self.uid() + cls.post_run=post_run + old_runnable_status=cls.runnable_status + def runnable_status(self): + status=old_runnable_status(self) + if status!=RUN_ME: + return status + try: + bld=self.generator.bld + prev_sig=bld.task_sigs[self.uid()] + if prev_sig==self.signature(): + for x in self.outputs: + if not x.sig or bld.task_sigs[x.abspath()]!=self.uid(): + return RUN_ME + return SKIP_ME + except KeyError: + pass + except IndexError: + pass + except AttributeError: + pass + return RUN_ME + cls.runnable_status=runnable_status + return cls diff -Nru jalv-0~svn3409/waflib/Tools/ar.py jalv-1.0.0~dfsg0/waflib/Tools/ar.py --- jalv-0~svn3409/waflib/Tools/ar.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/ar.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,12 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Configure import conf +def find_ar(conf): + conf.load('ar') +def configure(conf): + conf.find_program('ar',var='AR') + conf.env.ARFLAGS='rcs' + +conf(find_ar) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/asm.py jalv-1.0.0~dfsg0/waflib/Tools/asm.py --- jalv-0~svn3409/waflib/Tools/asm.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/asm.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,25 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib import Task,Utils +import waflib.Task +from waflib.Tools.ccroot import link_task,stlink_task +from waflib.TaskGen import extension,feature +class asm(Task.Task): + color='BLUE' + run_str='${AS} ${ASFLAGS} ${CPPPATH_ST:INCPATHS} ${AS_SRC_F}${SRC} ${AS_TGT_F}${TGT}' +def asm_hook(self,node): + return self.create_compiled_task('asm',node) +class asmprogram(link_task): + run_str='${ASLINK} ${ASLINKFLAGS} ${ASLNK_TGT_F}${TGT} ${ASLNK_SRC_F}${SRC}' + ext_out=['.bin'] + inst_to='${BINDIR}' + chmod=Utils.O755 +class asmshlib(asmprogram): + inst_to='${LIBDIR}' +class asmstlib(stlink_task): + pass + +extension('.s','.S','.asm','.ASM','.spp','.SPP')(asm_hook) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/bison.py jalv-1.0.0~dfsg0/waflib/Tools/bison.py --- jalv-0~svn3409/waflib/Tools/bison.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/bison.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,29 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Task +from waflib.TaskGen import extension +class bison(Task.Task): + color='BLUE' + run_str='${BISON} ${BISONFLAGS} ${SRC[0].abspath()} -o ${TGT[0].name}' + ext_out=['.h'] +def big_bison(self,node): + has_h='-d'in self.env['BISONFLAGS'] + outs=[] + if node.name.endswith('.yc'): + outs.append(node.change_ext('.tab.cc')) + if has_h: + outs.append(node.change_ext('.tab.hh')) + else: + outs.append(node.change_ext('.tab.c')) + if has_h: + outs.append(node.change_ext('.tab.h')) + tsk=self.create_task('bison',node,outs) + tsk.cwd=node.parent.get_bld().abspath() + self.source.append(outs[0]) +def configure(conf): + conf.find_program('bison',var='BISON') + conf.env.BISONFLAGS=['-d'] + +extension('.y','.yc','.yy')(big_bison) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/c_aliases.py jalv-1.0.0~dfsg0/waflib/Tools/c_aliases.py --- jalv-0~svn3409/waflib/Tools/c_aliases.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c_aliases.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,56 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,re +from waflib import Utils,Build +from waflib.Configure import conf +def get_extensions(lst): + ret=[] + for x in Utils.to_list(lst): + try: + if not isinstance(x,str): + x=x.name + ret.append(x[x.rfind('.')+1:]) + except: + pass + return ret +def sniff_features(**kw): + exts=get_extensions(kw['source']) + type=kw['_type'] + feats=[] + if'cxx'in exts or'cpp'in exts or'c++'in exts or'cc'in exts or'C'in exts: + feats.append('cxx') + if'c'in exts or'vala'in exts: + feats.append('c') + if'd'in exts: + feats.append('d') + if'java'in exts: + feats.append('java') + if'java'in exts: + return'java' + if type in['program','shlib','stlib']: + for x in feats: + if x in['cxx','d','c']: + feats.append(x+type) + return feats +def set_features(kw,_type): + kw['_type']=_type + kw['features']=Utils.to_list(kw.get('features',[]))+Utils.to_list(sniff_features(**kw)) +def program(bld,*k,**kw): + set_features(kw,'program') + return bld(*k,**kw) +def shlib(bld,*k,**kw): + set_features(kw,'shlib') + return bld(*k,**kw) +def stlib(bld,*k,**kw): + set_features(kw,'stlib') + return bld(*k,**kw) +def objects(bld,*k,**kw): + set_features(kw,'objects') + return bld(*k,**kw) + +conf(program) +conf(shlib) +conf(stlib) +conf(objects) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/c_config.py jalv-1.0.0~dfsg0/waflib/Tools/c_config.py --- jalv-0~svn3409/waflib/Tools/c_config.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c_config.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,713 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import os,imp,sys,re,shlex,shutil +from waflib import Build,Utils,Configure,Task,Options,Logs,TaskGen,Errors,ConfigSet,Runner +from waflib.TaskGen import before_method,after_method,feature +from waflib.Configure import conf +WAF_CONFIG_H='config.h' +DEFKEYS='define_key' +INCKEYS='include_key' +cfg_ver={'atleast-version':'>=','exact-version':'==','max-version':'<=',} +SNIP_FUNCTION=''' + int main() { + void *p; + p=(void*)(%s); + return 0; +} +''' +SNIP_TYPE=''' +int main() { + if ((%(type_name)s *) 0) return 0; + if (sizeof (%(type_name)s)) return 0; +} +''' +SNIP_CLASS=''' +int main() { + if ( +} +''' +SNIP_EMPTY_PROGRAM=''' +int main() { + return 0; +} +''' +SNIP_FIELD=''' +int main() { + char *off; + off = (char*) &((%(type_name)s*)0)->%(field_name)s; + return (size_t) off < sizeof(%(type_name)s); +} +''' +MACRO_TO_DESTOS={'__linux__':'linux','__GNU__':'gnu','__FreeBSD__':'freebsd','__NetBSD__':'netbsd','__OpenBSD__':'openbsd','__sun':'sunos','__hpux':'hpux','__sgi':'irix','_AIX':'aix','__CYGWIN__':'cygwin','__MSYS__':'msys','_UWIN':'uwin','_WIN64':'win32','_WIN32':'win32','__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__':'darwin','__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__':'darwin','__QNX__':'qnx','__native_client__':'nacl'} +MACRO_TO_DEST_CPU={'__x86_64__':'x86_64','__i386__':'x86','__ia64__':'ia','__mips__':'mips','__sparc__':'sparc','__alpha__':'alpha','__arm__':'arm','__hppa__':'hppa','__powerpc__':'powerpc',} +def parse_flags(self,line,uselib,env=None,force_static=False): + assert(isinstance(line,str)) + env=env or self.env + app=env.append_value + appu=env.append_unique + lex=shlex.shlex(line,posix=False) + lex.whitespace_split=True + lex.commenters='' + lst=list(lex) + while lst: + x=lst.pop(0) + st=x[:2] + ot=x[2:] + if st=='-I'or st=='/I': + if not ot:ot=lst.pop(0) + appu('INCLUDES_'+uselib,[ot]) + elif st=='-include': + tmp=[x,lst.pop(0)] + app('CFLAGS',tmp) + app('CXXFLAGS',tmp) + elif st=='-D'or(self.env.CXX_NAME=='msvc'and st=='/D'): + if not ot:ot=lst.pop(0) + app('DEFINES_'+uselib,[ot]) + elif st=='-l': + if not ot:ot=lst.pop(0) + prefix=force_static and'STLIB_'or'LIB_' + appu(prefix+uselib,[ot]) + elif st=='-L': + if not ot:ot=lst.pop(0) + appu('LIBPATH_'+uselib,[ot]) + elif x=='-pthread'or x.startswith('+')or x.startswith('-std'): + app('CFLAGS_'+uselib,[x]) + app('CXXFLAGS_'+uselib,[x]) + app('LINKFLAGS_'+uselib,[x]) + elif x=='-framework': + appu('FRAMEWORK_'+uselib,[lst.pop(0)]) + elif x.startswith('-F'): + appu('FRAMEWORKPATH_'+uselib,[x[2:]]) + elif x.startswith('-Wl'): + app('LINKFLAGS_'+uselib,[x]) + elif x.startswith('-m')or x.startswith('-f')or x.startswith('-dynamic'): + app('CFLAGS_'+uselib,[x]) + app('CXXFLAGS_'+uselib,[x]) + elif x.startswith('-bundle'): + app('LINKFLAGS_'+uselib,[x]) + elif x.startswith('-undefined'): + arg=lst.pop(0) + app('LINKFLAGS_'+uselib,[x,arg]) + elif x.startswith('-arch')or x.startswith('-isysroot'): + tmp=[x,lst.pop(0)] + app('CFLAGS_'+uselib,tmp) + app('CXXFLAGS_'+uselib,tmp) + app('LINKFLAGS_'+uselib,tmp) + elif x.endswith('.a')or x.endswith('.so')or x.endswith('.dylib'): + appu('LINKFLAGS_'+uselib,[x]) +def ret_msg(self,f,kw): + if isinstance(f,str): + return f + return f(kw) +def validate_cfg(self,kw): + if not'path'in kw: + if not self.env.PKGCONFIG: + self.find_program('pkg-config',var='PKGCONFIG') + kw['path']=self.env.PKGCONFIG + if'atleast_pkgconfig_version'in kw: + if not'msg'in kw: + kw['msg']='Checking for pkg-config version >= %r'%kw['atleast_pkgconfig_version'] + return + if not'okmsg'in kw: + kw['okmsg']='yes' + if not'errmsg'in kw: + kw['errmsg']='not found' + if'modversion'in kw: + if not'msg'in kw: + kw['msg']='Checking for %r version'%kw['modversion'] + return + for x in cfg_ver.keys(): + y=x.replace('-','_') + if y in kw: + if not'package'in kw: + raise ValueError('%s requires a package'%x) + if not'msg'in kw: + kw['msg']='Checking for %r %s %s'%(kw['package'],cfg_ver[x],kw[y]) + return + if not'msg'in kw: + kw['msg']='Checking for %r'%(kw['package']or kw['path']) +def exec_cfg(self,kw): + if'atleast_pkgconfig_version'in kw: + cmd=[kw['path'],'--atleast-pkgconfig-version=%s'%kw['atleast_pkgconfig_version']] + self.cmd_and_log(cmd) + if not'okmsg'in kw: + kw['okmsg']='yes' + return + for x in cfg_ver: + y=x.replace('-','_') + if y in kw: + self.cmd_and_log([kw['path'],'--%s=%s'%(x,kw[y]),kw['package']]) + if not'okmsg'in kw: + kw['okmsg']='yes' + self.define(self.have_define(kw.get('uselib_store',kw['package'])),1,0) + break + if'modversion'in kw: + version=self.cmd_and_log([kw['path'],'--modversion',kw['modversion']]).strip() + self.define('%s_VERSION'%Utils.quote_define_name(kw.get('uselib_store',kw['modversion'])),version) + return version + lst=[kw['path']] + defi=kw.get('define_variable',None) + if not defi: + defi=self.env.PKG_CONFIG_DEFINES or{} + for key,val in defi.items(): + lst.append('--define-variable=%s=%s'%(key,val)) + if kw['package']: + lst.extend(Utils.to_list(kw['package'])) + if'variables'in kw: + env=kw.get('env',self.env) + uselib=kw.get('uselib_store',kw['package'].upper()) + vars=Utils.to_list(kw['variables']) + for v in vars: + val=self.cmd_and_log(lst+['--variable='+v]).strip() + var='%s_%s'%(uselib,v) + env[var]=val + if not'okmsg'in kw: + kw['okmsg']='yes' + return + static=False + if'args'in kw: + args=Utils.to_list(kw['args']) + if'--static'in args or'--static-libs'in args: + static=True + lst+=args + ret=self.cmd_and_log(lst) + if not'okmsg'in kw: + kw['okmsg']='yes' + self.define(self.have_define(kw.get('uselib_store',kw['package'])),1,0) + self.parse_flags(ret,kw.get('uselib_store',kw['package'].upper()),kw.get('env',self.env),force_static=static) + return ret +def check_cfg(self,*k,**kw): + if k: + lst=k[0].split() + kw['package']=lst[0] + kw['args']=' '.join(lst[1:]) + self.validate_cfg(kw) + if'msg'in kw: + self.start_msg(kw['msg']) + ret=None + try: + ret=self.exec_cfg(kw) + except self.errors.WafError ,e: + if'errmsg'in kw: + self.end_msg(kw['errmsg'],'YELLOW') + if Logs.verbose>1: + raise + else: + self.fatal('The configuration failed') + else: + kw['success']=ret + if'okmsg'in kw: + self.end_msg(self.ret_msg(kw['okmsg'],kw)) + return ret +def validate_c(self,kw): + if not'env'in kw: + kw['env']=self.env.derive() + env=kw['env'] + if not'compiler'in kw and not'features'in kw: + kw['compiler']='c' + if env['CXX_NAME']and Task.classes.get('cxx',None): + kw['compiler']='cxx' + if not self.env['CXX']: + self.fatal('a c++ compiler is required') + else: + if not self.env['CC']: + self.fatal('a c compiler is required') + if not'compile_mode'in kw: + kw['compile_mode']='c' + if'cxx'in Utils.to_list(kw.get('features',[]))or kw.get('compiler','')=='cxx': + kw['compile_mode']='cxx' + if not'type'in kw: + kw['type']='cprogram' + if not'features'in kw: + kw['features']=[kw['compile_mode'],kw['type']] + else: + kw['features']=Utils.to_list(kw['features']) + if not'compile_filename'in kw: + kw['compile_filename']='test.c'+((kw['compile_mode']=='cxx')and'pp'or'') + def to_header(dct): + if'header_name'in dct: + dct=Utils.to_list(dct['header_name']) + return''.join(['#include <%s>\n'%x for x in dct]) + return'' + if'framework_name'in kw: + fwkname=kw['framework_name'] + if not'uselib_store'in kw: + kw['uselib_store']=fwkname.upper() + if not kw.get('no_header',False): + if not'header_name'in kw: + kw['header_name']=[] + fwk='%s/%s.h'%(fwkname,fwkname) + if kw.get('remove_dot_h',None): + fwk=fwk[:-2] + kw['header_name']=Utils.to_list(kw['header_name'])+[fwk] + kw['msg']='Checking for framework %s'%fwkname + kw['framework']=fwkname + if'function_name'in kw: + fu=kw['function_name'] + if not'msg'in kw: + kw['msg']='Checking for function %s'%fu + kw['code']=to_header(kw)+SNIP_FUNCTION%fu + if not'uselib_store'in kw: + kw['uselib_store']=fu.upper() + if not'define_name'in kw: + kw['define_name']=self.have_define(fu) + elif'type_name'in kw: + tu=kw['type_name'] + if not'header_name'in kw: + kw['header_name']='stdint.h' + if'field_name'in kw: + field=kw['field_name'] + kw['code']=to_header(kw)+SNIP_FIELD%{'type_name':tu,'field_name':field} + if not'msg'in kw: + kw['msg']='Checking for field %s in %s'%(field,tu) + if not'define_name'in kw: + kw['define_name']=self.have_define((tu+'_'+field).upper()) + else: + kw['code']=to_header(kw)+SNIP_TYPE%{'type_name':tu} + if not'msg'in kw: + kw['msg']='Checking for type %s'%tu + if not'define_name'in kw: + kw['define_name']=self.have_define(tu.upper()) + elif'header_name'in kw: + if not'msg'in kw: + kw['msg']='Checking for header %s'%kw['header_name'] + l=Utils.to_list(kw['header_name']) + assert len(l)>0,'list of headers in header_name is empty' + kw['code']=to_header(kw)+SNIP_EMPTY_PROGRAM + if not'uselib_store'in kw: + kw['uselib_store']=l[0].upper() + if not'define_name'in kw: + kw['define_name']=self.have_define(l[0]) + if'lib'in kw: + if not'msg'in kw: + kw['msg']='Checking for library %s'%kw['lib'] + if not'uselib_store'in kw: + kw['uselib_store']=kw['lib'].upper() + if'stlib'in kw: + if not'msg'in kw: + kw['msg']='Checking for static library %s'%kw['stlib'] + if not'uselib_store'in kw: + kw['uselib_store']=kw['stlib'].upper() + if'fragment'in kw: + kw['code']=kw['fragment'] + if not'msg'in kw: + kw['msg']='Checking for code snippet' + if not'errmsg'in kw: + kw['errmsg']='no' + for(flagsname,flagstype)in[('cxxflags','compiler'),('cflags','compiler'),('linkflags','linker')]: + if flagsname in kw: + if not'msg'in kw: + kw['msg']='Checking for %s flags %s'%(flagstype,kw[flagsname]) + if not'errmsg'in kw: + kw['errmsg']='no' + if not'execute'in kw: + kw['execute']=False + if kw['execute']: + kw['features'].append('test_exec') + if not'errmsg'in kw: + kw['errmsg']='not found' + if not'okmsg'in kw: + kw['okmsg']='yes' + if not'code'in kw: + kw['code']=SNIP_EMPTY_PROGRAM + if self.env[INCKEYS]: + kw['code']='\n'.join(['#include <%s>'%x for x in self.env[INCKEYS]])+'\n'+kw['code'] + if not kw.get('success'):kw['success']=None + if'define_name'in kw: + self.undefine(kw['define_name']) + assert'msg'in kw,'invalid parameters, read http://freehackers.org/~tnagy/wafbook/single.html#config_helpers_c' +def post_check(self,*k,**kw): + is_success=0 + if kw['execute']: + if kw['success']is not None: + if kw.get('define_ret',False): + is_success=kw['success'] + else: + is_success=(kw['success']==0) + else: + is_success=(kw['success']==0) + if'define_name'in kw: + if'header_name'in kw or'function_name'in kw or'type_name'in kw or'fragment'in kw: + nm=kw['define_name'] + if kw['execute']and kw.get('define_ret',None)and isinstance(is_success,str): + self.define(kw['define_name'],is_success,quote=kw.get('quote',1)) + else: + self.define_cond(kw['define_name'],is_success) + else: + self.define_cond(kw['define_name'],is_success) + if'header_name'in kw: + if kw.get('auto_add_header_name',False): + self.env.append_value(INCKEYS,Utils.to_list(kw['header_name'])) + if is_success and'uselib_store'in kw: + from waflib.Tools import ccroot + _vars=set([]) + for x in kw['features']: + if x in ccroot.USELIB_VARS: + _vars|=ccroot.USELIB_VARS[x] + for k in _vars: + lk=k.lower() + if k=='INCLUDES':lk='includes' + if k=='DEFINES':lk='defines' + if lk in kw: + val=kw[lk] + if isinstance(val,str): + val=val.rstrip(os.path.sep) + self.env.append_unique(k+'_'+kw['uselib_store'],val) + return is_success +def check(self,*k,**kw): + self.validate_c(kw) + self.start_msg(kw['msg']) + ret=None + try: + ret=self.run_c_code(*k,**kw) + except self.errors.ConfigurationError ,e: + self.end_msg(kw['errmsg'],'YELLOW') + if Logs.verbose>1: + raise + else: + self.fatal('The configuration failed') + else: + kw['success']=ret + self.end_msg(self.ret_msg(kw['okmsg'],kw)) + ret=self.post_check(*k,**kw) + if not ret: + self.fatal('The configuration failed %r'%ret) + return ret +class test_exec(Task.Task): + color='PINK' + def run(self): + if getattr(self.generator,'rpath',None): + if getattr(self.generator,'define_ret',False): + self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()]) + else: + self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()]) + else: + env=self.env.env or{} + env.update(dict(os.environ)) + for var in('LD_LIBRARY_PATH','DYLD_LIBRARY_PATH','PATH'): + env[var]=self.inputs[0].parent.abspath()+os.path.pathsep+env.get(var,'') + if getattr(self.generator,'define_ret',False): + self.generator.bld.retval=self.generator.bld.cmd_and_log([self.inputs[0].abspath()],env=env) + else: + self.generator.bld.retval=self.generator.bld.exec_command([self.inputs[0].abspath()],env=env) +def test_exec_fun(self): + self.create_task('test_exec',self.link_task.outputs[0]) +CACHE_RESULTS=1 +COMPILE_ERRORS=2 +def run_c_code(self,*k,**kw): + lst=[str(v)for(p,v)in kw.items()if p!='env'] + h=Utils.h_list(lst) + dir=self.bldnode.abspath()+os.sep+(not Utils.is_win32 and'.'or'')+'conf_check_'+Utils.to_hex(h) + try: + os.makedirs(dir) + except: + pass + try: + os.stat(dir) + except: + self.fatal('cannot use the configuration test folder %r'%dir) + cachemode=getattr(Options.options,'confcache',None) + if cachemode==CACHE_RESULTS: + try: + proj=ConfigSet.ConfigSet(os.path.join(dir,'cache_run_c_code')) + ret=proj['cache_run_c_code'] + except: + pass + else: + if isinstance(ret,str)and ret.startswith('Test does not build'): + self.fatal(ret) + return ret + bdir=os.path.join(dir,'testbuild') + if not os.path.exists(bdir): + os.makedirs(bdir) + self.test_bld=bld=Build.BuildContext(top_dir=dir,out_dir=bdir) + bld.init_dirs() + bld.progress_bar=0 + bld.targets='*' + if kw['compile_filename']: + node=bld.srcnode.make_node(kw['compile_filename']) + node.write(kw['code']) + bld.logger=self.logger + bld.all_envs.update(self.all_envs) + bld.env=kw['env'] + o=bld(features=kw['features'],source=kw['compile_filename'],target='testprog') + for k,v in kw.items(): + setattr(o,k,v) + self.to_log("==>\n%s\n<=="%kw['code']) + bld.targets='*' + ret=-1 + try: + try: + bld.compile() + except Errors.WafError: + ret='Test does not build: %s'%Utils.ex_stack() + self.fatal(ret) + else: + ret=getattr(bld,'retval',0) + finally: + proj=ConfigSet.ConfigSet() + proj['cache_run_c_code']=ret + proj.store(os.path.join(dir,'cache_run_c_code')) + return ret +def check_cxx(self,*k,**kw): + kw['compiler']='cxx' + return self.check(*k,**kw) +def check_cc(self,*k,**kw): + kw['compiler']='c' + return self.check(*k,**kw) +def define(self,key,val,quote=True): + assert key and isinstance(key,str) + if isinstance(val,int)or isinstance(val,float): + s='%s=%s' + else: + s=quote and'%s="%s"'or'%s=%s' + app=s%(key,str(val)) + ban=key+'=' + lst=self.env['DEFINES'] + for x in lst: + if x.startswith(ban): + lst[lst.index(x)]=app + break + else: + self.env.append_value('DEFINES',app) + self.env.append_unique(DEFKEYS,key) +def undefine(self,key): + assert key and isinstance(key,str) + ban=key+'=' + lst=[x for x in self.env['DEFINES']if not x.startswith(ban)] + self.env['DEFINES']=lst + self.env.append_unique(DEFKEYS,key) +def define_cond(self,key,val): + assert key and isinstance(key,str) + if val: + self.define(key,1) + else: + self.undefine(key) +def is_defined(self,key): + assert key and isinstance(key,str) + ban=key+'=' + for x in self.env['DEFINES']: + if x.startswith(ban): + return True + return False +def get_define(self,key): + assert key and isinstance(key,str) + ban=key+'=' + for x in self.env['DEFINES']: + if x.startswith(ban): + return x[len(ban):] + return None +def have_define(self,key): + return self.__dict__.get('HAVE_PAT','HAVE_%s')%Utils.quote_define_name(key) +def write_config_header(self,configfile='',guard='',top=False,env=None,defines=True,headers=False,remove=True): + if not configfile:configfile=WAF_CONFIG_H + waf_guard=guard or'_%s_WAF'%Utils.quote_define_name(configfile) + node=top and self.bldnode or self.path.get_bld() + node=node.make_node(configfile) + node.parent.mkdir() + lst=['/* WARNING! All changes made to this file will be lost! */\n'] + lst.append('#ifndef %s\n#define %s\n'%(waf_guard,waf_guard)) + lst.append(self.get_config_header(defines,headers)) + lst.append('\n#endif /* %s */\n'%waf_guard) + node.write('\n'.join(lst)) + env=env or self.env + env.append_unique(Build.CFG_FILES,[node.abspath()]) + if remove: + for key in self.env[DEFKEYS]: + self.undefine(key) + self.env[DEFKEYS]=[] +def get_config_header(self,defines=True,headers=False): + lst=[] + if headers: + for x in self.env[INCKEYS]: + lst.append('#include <%s>'%x) + if defines: + for x in self.env[DEFKEYS]: + if self.is_defined(x): + val=self.get_define(x) + lst.append('#define %s %s'%(x,val)) + else: + lst.append('/* #undef %s */'%x) + return"\n".join(lst) +def cc_add_flags(conf): + conf.add_os_flags('CPPFLAGS','CFLAGS') + conf.add_os_flags('CFLAGS') +def cxx_add_flags(conf): + conf.add_os_flags('CPPFLAGS','CXXFLAGS') + conf.add_os_flags('CXXFLAGS') +def link_add_flags(conf): + conf.add_os_flags('LINKFLAGS') + conf.add_os_flags('LDFLAGS','LINKFLAGS') +def cc_load_tools(conf): + if not conf.env.DEST_OS: + conf.env.DEST_OS=Utils.unversioned_sys_platform() + conf.load('c') +def cxx_load_tools(conf): + if not conf.env.DEST_OS: + conf.env.DEST_OS=Utils.unversioned_sys_platform() + conf.load('cxx') +def get_cc_version(conf,cc,gcc=False,icc=False): + cmd=cc+['-dM','-E','-'] + try: + p=Utils.subprocess.Popen(cmd,stdin=Utils.subprocess.PIPE,stdout=Utils.subprocess.PIPE,stderr=Utils.subprocess.PIPE) + p.stdin.write('\n') + out=p.communicate()[0] + except: + conf.fatal('could not determine the compiler version %r'%cmd) + if not isinstance(out,str): + out=out.decode(sys.stdout.encoding) + if gcc: + if out.find('__INTEL_COMPILER')>=0: + conf.fatal('The intel compiler pretends to be gcc') + if out.find('__GNUC__')<0: + conf.fatal('Could not determine the compiler type') + if icc and out.find('__INTEL_COMPILER')<0: + conf.fatal('Not icc/icpc') + k={} + if icc or gcc: + out=out.split('\n') + import shlex + for line in out: + lst=shlex.split(line) + if len(lst)>2: + key=lst[1] + val=lst[2] + k[key]=val + def isD(var): + return var in k + def isT(var): + return var in k and k[var]!='0' + if not conf.env.DEST_OS: + conf.env.DEST_OS='' + for i in MACRO_TO_DESTOS: + if isD(i): + conf.env.DEST_OS=MACRO_TO_DESTOS[i] + break + else: + if isD('__APPLE__')and isD('__MACH__'): + conf.env.DEST_OS='darwin' + elif isD('__unix__'): + conf.env.DEST_OS='generic' + if isD('__ELF__'): + conf.env.DEST_BINFMT='elf' + elif isD('__WINNT__')or isD('__CYGWIN__'): + conf.env.DEST_BINFMT='pe' + conf.env.LIBDIR=conf.env['PREFIX']+'/bin' + elif isD('__APPLE__'): + conf.env.DEST_BINFMT='mac-o' + if not conf.env.DEST_BINFMT: + conf.env.DEST_BINFMT=Utils.destos_to_binfmt(conf.env.DEST_OS) + for i in MACRO_TO_DEST_CPU: + if isD(i): + conf.env.DEST_CPU=MACRO_TO_DEST_CPU[i] + break + Logs.debug('ccroot: dest platform: '+' '.join([conf.env[x]or'?'for x in('DEST_OS','DEST_BINFMT','DEST_CPU')])) + if icc: + ver=k['__INTEL_COMPILER'] + conf.env['CC_VERSION']=(ver[:-2],ver[-2],ver[-1]) + else: + conf.env['CC_VERSION']=(k['__GNUC__'],k['__GNUC_MINOR__'],k['__GNUC_PATCHLEVEL__']) + return k +def get_xlc_version(conf,cc): + version_re=re.compile(r"IBM XL C/C\+\+.*, V(?P\d*)\.(?P\d*)",re.I).search + cmd=cc+['-qversion'] + try: + out,err=conf.cmd_and_log(cmd,output=0) + except Errors.WafError: + conf.fatal('Could not find xlc %r'%cmd) + if out:match=version_re(out) + else:match=version_re(err) + if not match: + conf.fatal('Could not determine the XLC version.') + k=match.groupdict() + conf.env['CC_VERSION']=(k['major'],k['minor']) +def add_as_needed(self): + if self.env.DEST_BINFMT=='elf'and'gcc'in(self.env.CXX_NAME,self.env.CC_NAME): + self.env.append_unique('LINKFLAGS','--as-needed') +class cfgtask(Task.TaskBase): + def display(self): + return'' + def runnable_status(self): + return Task.RUN_ME + def run(self): + conf=self.conf + bld=Build.BuildContext(top_dir=conf.srcnode.abspath(),out_dir=conf.bldnode.abspath()) + bld.env=conf.env + bld.init_dirs() + bld.in_msg=1 + bld.logger=self.logger + try: + bld.check(**self.args) + except: + return 1 +def multicheck(self,*k,**kw): + self.start_msg(kw.get('msg','Executing %d configuration tests'%len(k))) + class par(object): + def __init__(self): + self.keep=False + self.cache_global=Options.cache_global + self.nocache=Options.options.nocache + self.returned_tasks=[] + def total(self): + return len(tasks) + def to_log(self,*k,**kw): + return + bld=par() + tasks=[] + for dct in k: + x=cfgtask(bld=bld) + tasks.append(x) + x.args=dct + x.bld=bld + x.conf=self + x.args=dct + x.logger=Logs.make_mem_logger(str(id(x)),self.logger) + def it(): + yield tasks + while 1: + yield[] + p=Runner.Parallel(bld,Options.options.jobs) + p.biter=it() + p.start() + for x in tasks: + x.logger.memhandler.flush() + for x in tasks: + if x.hasrun!=Task.SUCCESS: + self.end_msg(kw.get('errmsg','no'),color='YELLOW') + self.fatal(kw.get('fatalmsg',None)or'One of the tests has failed, see the config.log for more information') + self.end_msg('ok') + +conf(parse_flags) +conf(ret_msg) +conf(validate_cfg) +conf(exec_cfg) +conf(check_cfg) +conf(validate_c) +conf(post_check) +conf(check) +feature('test_exec')(test_exec_fun) +after_method('apply_link')(test_exec_fun) +conf(run_c_code) +conf(check_cxx) +conf(check_cc) +conf(define) +conf(undefine) +conf(define_cond) +conf(is_defined) +conf(get_define) +conf(have_define) +conf(write_config_header) +conf(get_config_header) +conf(cc_add_flags) +conf(cxx_add_flags) +conf(link_add_flags) +conf(cc_load_tools) +conf(cxx_load_tools) +conf(get_cc_version) +conf(get_xlc_version) +conf(add_as_needed) +conf(multicheck) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/ccroot.py jalv-1.0.0~dfsg0/waflib/Tools/ccroot.py --- jalv-0~svn3409/waflib/Tools/ccroot.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/ccroot.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,375 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import os,sys,re +from waflib import TaskGen,Task,Utils,Logs,Build,Options,Node,Errors +from waflib.Logs import error,debug,warn +from waflib.TaskGen import after_method,before_method,feature,taskgen_method,extension +from waflib.Tools import c_aliases,c_preproc,c_config,c_osx,c_tests +from waflib.Configure import conf +USELIB_VARS=Utils.defaultdict(set) +USELIB_VARS['c']=set(['INCLUDES','FRAMEWORKPATH','DEFINES','CPPFLAGS','CCDEPS','CFLAGS','ARCH']) +USELIB_VARS['cxx']=set(['INCLUDES','FRAMEWORKPATH','DEFINES','CPPFLAGS','CXXDEPS','CXXFLAGS','ARCH']) +USELIB_VARS['d']=set(['INCLUDES','DFLAGS']) +USELIB_VARS['cprogram']=USELIB_VARS['cxxprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS','FRAMEWORK','FRAMEWORKPATH','ARCH']) +USELIB_VARS['cshlib']=USELIB_VARS['cxxshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS','FRAMEWORK','FRAMEWORKPATH','ARCH']) +USELIB_VARS['cstlib']=USELIB_VARS['cxxstlib']=set(['ARFLAGS','LINKDEPS']) +USELIB_VARS['dprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +USELIB_VARS['dshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +USELIB_VARS['dstlib']=set(['ARFLAGS','LINKDEPS']) +USELIB_VARS['go']=set(['GOCFLAGS']) +USELIB_VARS['goprogram']=set(['GOLFLAGS']) +USELIB_VARS['asm']=set(['ASFLAGS']) +def create_compiled_task(self,name,node): + out='%s.%d.o'%(node.name,self.idx) + task=self.create_task(name,node,node.parent.find_or_declare(out)) + try: + self.compiled_tasks.append(task) + except AttributeError: + self.compiled_tasks=[task] + return task +def to_incnodes(self,inlst): + lst=[] + seen=set([]) + for x in self.to_list(inlst): + if x in seen or not x: + continue + seen.add(x) + if isinstance(x,Node.Node): + lst.append(x) + else: + if os.path.isabs(x): + lst.append(self.bld.root.make_node(x)or x) + else: + if x[0]=='#': + p=self.bld.bldnode.make_node(x[1:]) + v=self.bld.srcnode.make_node(x[1:]) + else: + p=self.path.get_bld().make_node(x) + v=self.path.make_node(x) + if p.is_child_of(self.bld.bldnode): + p.mkdir() + lst.append(p) + lst.append(v) + return lst +def apply_incpaths(self): + lst=self.to_incnodes(self.to_list(getattr(self,'includes',[]))+self.env['INCLUDES']) + self.includes_nodes=lst + self.env['INCPATHS']=[x.abspath()for x in lst] +class link_task(Task.Task): + color='YELLOW' + inst_to=None + chmod=Utils.O644 + def add_target(self,target): + if isinstance(target,str): + pattern=self.env[self.__class__.__name__+'_PATTERN'] + if not pattern: + pattern='%s' + folder,name=os.path.split(target) + if self.__class__.__name__.find('shlib')>0: + if self.env.DEST_BINFMT=='pe'and getattr(self.generator,'vnum',None): + name=name+'-'+self.generator.vnum.split('.')[0] + tmp=folder+os.sep+pattern%name + target=self.generator.path.find_or_declare(tmp) + self.set_outputs(target) +class stlink_task(link_task): + run_str='${AR} ${ARFLAGS} ${AR_TGT_F}${TGT} ${AR_SRC_F}${SRC}' +def rm_tgt(cls): + old=cls.run + def wrap(self): + try:os.remove(self.outputs[0].abspath()) + except OSError:pass + return old(self) + setattr(cls,'run',wrap) +rm_tgt(stlink_task) +def apply_link(self): + for x in self.features: + if x=='cprogram'and'cxx'in self.features: + x='cxxprogram' + elif x=='cshlib'and'cxx'in self.features: + x='cxxshlib' + if x in Task.classes: + if issubclass(Task.classes[x],link_task): + link=x + break + else: + return + objs=[t.outputs[0]for t in getattr(self,'compiled_tasks',[])] + self.link_task=self.create_task(link,objs) + self.link_task.add_target(self.target) + try: + inst_to=self.install_path + except AttributeError: + inst_to=self.link_task.__class__.inst_to + if inst_to: + self.install_task=self.bld.install_files(inst_to,self.link_task.outputs[:],env=self.env,chmod=self.link_task.chmod) +def use_rec(self,name,**kw): + if name in self.tmp_use_not or name in self.tmp_use_seen: + return + try: + y=self.bld.get_tgen_by_name(name) + except Errors.WafError: + self.uselib.append(name) + self.tmp_use_not.add(name) + return + self.tmp_use_seen.append(name) + y.post() + y.tmp_use_objects=objects=kw.get('objects',True) + y.tmp_use_stlib=stlib=kw.get('stlib',True) + try: + link_task=y.link_task + except AttributeError: + y.tmp_use_var='' + else: + objects=False + if not isinstance(y.link_task,stlink_task): + stlib=False + y.tmp_use_var='LIB' + else: + y.tmp_use_var='STLIB' + p=self.tmp_use_prec + for x in self.to_list(getattr(y,'use',[])): + try: + p[x].append(name) + except: + p[x]=[name] + self.use_rec(x,objects=objects,stlib=stlib) +def process_use(self): + use_not=self.tmp_use_not=set([]) + use_seen=self.tmp_use_seen=[] + use_prec=self.tmp_use_prec={} + self.uselib=self.to_list(getattr(self,'uselib',[])) + self.includes=self.to_list(getattr(self,'includes',[])) + names=self.to_list(getattr(self,'use',[])) + for x in names: + self.use_rec(x) + for x in use_not: + if x in use_prec: + del use_prec[x] + out=[] + tmp=[] + for x in self.tmp_use_seen: + for k in use_prec.values(): + if x in k: + break + else: + tmp.append(x) + while tmp: + e=tmp.pop() + out.append(e) + try: + nlst=use_prec[e] + except KeyError: + pass + else: + del use_prec[e] + for x in nlst: + for y in use_prec: + if x in use_prec[y]: + break + else: + tmp.append(x) + if use_prec: + raise Errors.WafError('Cycle detected in the use processing %r'%use_prec) + out.reverse() + link_task=getattr(self,'link_task',None) + for x in out: + y=self.bld.get_tgen_by_name(x) + var=y.tmp_use_var + if var and link_task: + if var=='LIB'or y.tmp_use_stlib: + self.env.append_value(var,[y.target[y.target.rfind(os.sep)+1:]]) + self.link_task.dep_nodes.extend(y.link_task.outputs) + tmp_path=y.link_task.outputs[0].parent.path_from(self.bld.bldnode) + self.env.append_value(var+'PATH',[tmp_path]) + else: + if y.tmp_use_objects: + self.add_objects_from_tgen(y) + if getattr(y,'export_includes',None): + self.includes.extend(y.to_incnodes(y.export_includes)) + for x in names: + try: + y=self.bld.get_tgen_by_name(x) + except: + if not self.env['STLIB_'+x]and not x in self.uselib: + self.uselib.append(x) + else: + for k in self.to_list(getattr(y,'uselib',[])): + if not self.env['STLIB_'+k]and not k in self.uselib: + self.uselib.append(k) +def add_objects_from_tgen(self,tg): + try: + link_task=self.link_task + except AttributeError: + pass + else: + for tsk in getattr(tg,'compiled_tasks',[]): + for x in tsk.outputs: + if x.name.endswith('.o')or x.name.endswith('.obj'): + link_task.inputs.append(x) +def get_uselib_vars(self): + _vars=set([]) + for x in self.features: + if x in USELIB_VARS: + _vars|=USELIB_VARS[x] + return _vars +def propagate_uselib_vars(self): + _vars=self.get_uselib_vars() + env=self.env + for x in _vars: + y=x.lower() + env.append_unique(x,self.to_list(getattr(self,y,[]))) + for x in self.features: + for var in _vars: + compvar='%s_%s'%(var,x) + env.append_value(var,env[compvar]) + for x in self.to_list(getattr(self,'uselib',[])): + for v in _vars: + env.append_value(v,env[v+'_'+x]) +def apply_implib(self): + if not self.env.DEST_BINFMT=='pe': + return + dll=self.link_task.outputs[0] + if isinstance(self.target,Node.Node): + name=self.target.name + else: + name=os.path.split(self.target)[1] + implib=self.env['implib_PATTERN']%name + implib=dll.parent.find_or_declare(implib) + self.env.append_value('LINKFLAGS',self.env['IMPLIB_ST']%implib.bldpath()) + self.link_task.outputs.append(implib) + if getattr(self,'defs',None)and self.env.DEST_BINFMT=='pe': + node=self.path.find_resource(self.defs) + if not node: + raise Errors.WafError('invalid def file %r'%self.defs) + if'msvc'in(self.env.CC_NAME,self.env.CXX_NAME): + self.env.append_value('LINKFLAGS','/def:%s'%node.path_from(self.bld.bldnode)) + self.link_task.dep_nodes.append(node) + else: + self.link_task.inputs.append(node) + try: + inst_to=self.install_path + except AttributeError: + inst_to=self.link_task.__class__.inst_to + if not inst_to: + return + self.implib_install_task=self.bld.install_as('${PREFIX}/lib/%s'%implib.name,implib,self.env) +def apply_vnum(self): + if not getattr(self,'vnum','')or os.name!='posix'or self.env.DEST_BINFMT not in('elf','mac-o'): + return + link=self.link_task + nums=self.vnum.split('.') + node=link.outputs[0] + libname=node.name + if libname.endswith('.dylib'): + name3=libname.replace('.dylib','.%s.dylib'%self.vnum) + name2=libname.replace('.dylib','.%s.dylib'%nums[0]) + else: + name3=libname+'.'+self.vnum + name2=libname+'.'+nums[0] + if self.env.SONAME_ST: + v=self.env.SONAME_ST%name2 + self.env.append_value('LINKFLAGS',v.split()) + tsk=self.create_task('vnum',node,[node.parent.find_or_declare(name2),node.parent.find_or_declare(name3)]) + if getattr(self.bld,'is_install',None): + self.install_task.hasrun=Task.SKIP_ME + bld=self.bld + path=self.install_task.dest + t1=bld.install_as(path+os.sep+name3,node,env=self.env) + t2=bld.symlink_as(path+os.sep+name2,name3) + t3=bld.symlink_as(path+os.sep+libname,name3) + self.vnum_install_task=(t1,t2,t3) + if'-dynamiclib'in self.env['LINKFLAGS']and getattr(self,'install_task',None): + path=os.path.join(self.install_task.get_install_path(),self.link_task.outputs[0].name) + self.env.append_value('LINKFLAGS',['-install_name',path]) +class vnum(Task.Task): + color='CYAN' + quient=True + ext_in=['.bin'] + def run(self): + for x in self.outputs: + path=x.abspath() + try: + os.remove(path) + except OSError: + pass + try: + os.symlink(self.inputs[0].name,path) + except OSError: + return 1 +class fake_shlib(link_task): + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +class fake_stlib(stlink_task): + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +def read_shlib(self,name,paths=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='shlib') +def read_stlib(self,name,paths=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='stlib') +lib_patterns={'shlib':['lib%s.so','%s.so','lib%s.dll','%s.dll'],'stlib':['lib%s.a','%s.a','lib%s.dll','%s.dll','lib%s.lib','%s.lib'],} +def process_lib(self): + node=None + names=[x%self.name for x in lib_patterns[self.lib_type]] + for x in self.lib_paths+[self.path,'/usr/lib64','/usr/lib','/usr/local/lib64','/usr/local/lib']: + if not isinstance(x,Node.Node): + x=self.bld.root.find_node(x)or self.path.find_node(x) + if not x: + continue + for y in names: + node=x.find_node(y) + if node: + node.sig=Utils.h_file(node.abspath()) + break + else: + continue + break + else: + raise Errors.WafError('could not find library %r'%self.name) + self.link_task=self.create_task('fake_%s'%self.lib_type,[],[node]) + self.target=self.name +class fake_o(Task.Task): + def runnable_status(self): + return Task.SKIP_ME +def add_those_o_files(self,node): + tsk=self.create_task('fake_o',[],node) + try: + self.compiled_tasks.append(tsk) + except AttributeError: + self.compiled_tasks=[tsk] + +taskgen_method(create_compiled_task) +taskgen_method(to_incnodes) +feature('c','cxx','d','go','asm','fc','includes')(apply_incpaths) +after_method('propagate_uselib_vars','process_source')(apply_incpaths) +feature('c','cxx','d','go','fc','asm')(apply_link) +after_method('process_source')(apply_link) +taskgen_method(use_rec) +feature('c','cxx','d','use','fc')(process_use) +before_method('apply_incpaths','propagate_uselib_vars')(process_use) +after_method('apply_link','process_source')(process_use) +taskgen_method(add_objects_from_tgen) +taskgen_method(get_uselib_vars) +feature('c','cxx','d','fc','javac','cs','uselib')(propagate_uselib_vars) +after_method('process_use')(propagate_uselib_vars) +feature('cshlib','cxxshlib','fcshlib')(apply_implib) +after_method('apply_link')(apply_implib) +feature('cshlib','cxxshlib','dshlib','fcshlib','vnum')(apply_vnum) +after_method('apply_link')(apply_vnum) +conf(read_shlib) +conf(read_stlib) +feature('fake_lib')(process_lib) +extension('.o','.obj')(add_those_o_files) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/compiler_c.py jalv-1.0.0~dfsg0/waflib/Tools/compiler_c.py --- jalv-0~svn3409/waflib/Tools/compiler_c.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/compiler_c.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,39 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib.Tools import ccroot +from waflib import Utils,Configure +from waflib.Logs import debug +c_compiler={'win32':['msvc','gcc'],'cygwin':['gcc'],'darwin':['gcc'],'aix':['xlc','gcc'],'linux':['gcc','icc'],'sunos':['suncc','gcc'],'irix':['gcc','irixcc'],'hpux':['gcc'],'gnu':['gcc'],'java':['gcc','msvc','icc'],'default':['gcc'],} +def configure(conf): + try:test_for_compiler=conf.options.check_c_compiler + except AttributeError:conf.fatal("Add options(opt): opt.load('compiler_c')") + for compiler in test_for_compiler.split(): + conf.env.stash() + conf.start_msg('Checking for %r (c compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + debug('compiler_c: %r'%e) + else: + if conf.env['CC']: + conf.end_msg(conf.env.get_flat('CC')) + conf.env['COMPILER_CC']=compiler + break + conf.end_msg(False) + else: + conf.fatal('could not configure a c compiler!') +def options(opt): + opt.load_special_tools('c_*.py',ban=['c_dumbpreproc.py']) + global c_compiler + build_platform=Utils.unversioned_sys_platform() + possible_compiler_list=c_compiler[build_platform in c_compiler and build_platform or'default'] + test_for_compiler=' '.join(possible_compiler_list) + cc_compiler_opts=opt.add_option_group("C Compiler Options") + cc_compiler_opts.add_option('--check-c-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following C-Compiler will be checked by default: "%s"'%(build_platform,test_for_compiler),dest="check_c_compiler") + for x in test_for_compiler.split(): + opt.load('%s'%x) diff -Nru jalv-0~svn3409/waflib/Tools/compiler_cxx.py jalv-1.0.0~dfsg0/waflib/Tools/compiler_cxx.py --- jalv-0~svn3409/waflib/Tools/compiler_cxx.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/compiler_cxx.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,39 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib.Tools import ccroot +from waflib import Utils,Configure +from waflib.Logs import debug +cxx_compiler={'win32':['msvc','g++'],'cygwin':['g++'],'darwin':['g++'],'aix':['xlc++','g++'],'linux':['g++','icpc'],'sunos':['sunc++','g++'],'irix':['g++'],'hpux':['g++'],'gnu':['g++'],'java':['g++','msvc','icpc'],'default':['g++']} +def configure(conf): + try:test_for_compiler=conf.options.check_cxx_compiler + except AttributeError:conf.fatal("Add options(opt): opt.load('compiler_cxx')") + for compiler in test_for_compiler.split(): + conf.env.stash() + conf.start_msg('Checking for %r (c++ compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + debug('compiler_cxx: %r'%e) + else: + if conf.env['CXX']: + conf.end_msg(conf.env.get_flat('CXX')) + conf.env['COMPILER_CXX']=compiler + break + conf.end_msg(False) + else: + conf.fatal('could not configure a c++ compiler!') +def options(opt): + opt.load_special_tools('cxx_*.py') + global cxx_compiler + build_platform=Utils.unversioned_sys_platform() + possible_compiler_list=cxx_compiler[build_platform in cxx_compiler and build_platform or'default'] + test_for_compiler=' '.join(possible_compiler_list) + cxx_compiler_opts=opt.add_option_group('C++ Compiler Options') + cxx_compiler_opts.add_option('--check-cxx-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following C++ Compiler will be checked by default: "%s"'%(build_platform,test_for_compiler),dest="check_cxx_compiler") + for x in test_for_compiler.split(): + opt.load('%s'%x) diff -Nru jalv-0~svn3409/waflib/Tools/compiler_d.py jalv-1.0.0~dfsg0/waflib/Tools/compiler_d.py --- jalv-0~svn3409/waflib/Tools/compiler_d.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/compiler_d.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,30 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib import Utils,Configure,Options,Logs +def configure(conf): + for compiler in conf.options.dcheck.split(','): + conf.env.stash() + conf.start_msg('Checking for %r (d compiler)'%compiler) + try: + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.env.revert() + conf.end_msg(False) + Logs.debug('compiler_cxx: %r'%e) + else: + if conf.env.D: + conf.end_msg(conf.env.get_flat('D')) + conf.env['COMPILER_D']=compiler + conf.env.D_COMPILER=conf.env.D + break + conf.end_msg(False) + else: + conf.fatal('no suitable d compiler was found') +def options(opt): + d_compiler_opts=opt.add_option_group('D Compiler Options') + d_compiler_opts.add_option('--check-d-compiler',default='gdc,dmd',action='store',help='check for the compiler [Default:gdc,dmd]',dest='dcheck') + for d_compiler in['gdc','dmd']: + opt.load('%s'%d_compiler) diff -Nru jalv-0~svn3409/waflib/Tools/compiler_fc.py jalv-1.0.0~dfsg0/waflib/Tools/compiler_fc.py --- jalv-0~svn3409/waflib/Tools/compiler_fc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/compiler_fc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,45 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,imp,types +from waflib import Utils,Configure,Options,Logs,Errors +from waflib.Tools import fc +fc_compiler={'win32':['gfortran','ifort'],'darwin':['gfortran','g95','ifort'],'linux':['gfortran','g95','ifort'],'java':['gfortran','g95','ifort'],'default':['gfortran'],'aix':['gfortran']} +def __list_possible_compiler(platform): + try: + return fc_compiler[platform] + except KeyError: + return fc_compiler["default"] +def configure(conf): + try:test_for_compiler=conf.options.check_fc + except AttributeError:conf.fatal("Add options(opt): opt.load('compiler_fc')") + orig=conf.env + for compiler in test_for_compiler.split(): + try: + conf.start_msg('Checking for %r (fortran compiler)'%compiler) + conf.env=orig.derive() + conf.load(compiler) + except conf.errors.ConfigurationError ,e: + conf.end_msg(False) + Logs.debug('compiler_fortran: %r'%e) + else: + if conf.env['FC']: + orig.table=conf.env.get_merged_dict() + conf.env=orig + conf.end_msg(conf.env.get_flat('FC')) + conf.env.COMPILER_FORTRAN=compiler + break + conf.end_msg(False) + else: + conf.fatal('could not configure a fortran compiler!') +def options(opt): + opt.load_special_tools('fc_*.py') + build_platform=Utils.unversioned_sys_platform() + detected_platform=Options.platform + possible_compiler_list=__list_possible_compiler(detected_platform) + test_for_compiler=' '.join(possible_compiler_list) + fortran_compiler_opts=opt.add_option_group("Fortran Compiler Options") + fortran_compiler_opts.add_option('--check-fortran-compiler',default="%s"%test_for_compiler,help='On this platform (%s) the following Fortran Compiler will be checked by default: "%s"'%(detected_platform,test_for_compiler),dest="check_fc") + for compiler in test_for_compiler.split(): + opt.load('%s'%compiler) diff -Nru jalv-0~svn3409/waflib/Tools/c_osx.py jalv-1.0.0~dfsg0/waflib/Tools/c_osx.py --- jalv-0~svn3409/waflib/Tools/c_osx.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c_osx.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,121 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,shutil,sys,platform +from waflib import TaskGen,Task,Build,Options,Utils,Errors +from waflib.TaskGen import taskgen_method,feature,after_method,before_method +app_info=''' + + + + + CFBundlePackageType + APPL + CFBundleGetInfoString + Created by Waf + CFBundleSignature + ???? + NOTE + THIS IS A GENERATED FILE, DO NOT MODIFY + CFBundleExecutable + %s + + +''' +def set_macosx_deployment_target(self): + if self.env['MACOSX_DEPLOYMENT_TARGET']: + os.environ['MACOSX_DEPLOYMENT_TARGET']=self.env['MACOSX_DEPLOYMENT_TARGET'] + elif'MACOSX_DEPLOYMENT_TARGET'not in os.environ: + if Utils.unversioned_sys_platform()=='darwin': + os.environ['MACOSX_DEPLOYMENT_TARGET']='.'.join(platform.mac_ver()[0].split('.')[:2]) +def create_bundle_dirs(self,name,out): + bld=self.bld + dir=out.parent.find_or_declare(name) + dir.mkdir() + macos=dir.find_or_declare(['Contents','MacOS']) + macos.mkdir() + return dir +def bundle_name_for_output(out): + name=out.name + k=name.rfind('.') + if k>=0: + name=name[:k]+'.app' + else: + name=name+'.app' + return name +def create_task_macapp(self): + if self.env['MACAPP']or getattr(self,'mac_app',False): + out=self.link_task.outputs[0] + name=bundle_name_for_output(out) + dir=self.create_bundle_dirs(name,out) + n1=dir.find_or_declare(['Contents','MacOS',out.name]) + self.apptask=self.create_task('macapp',self.link_task.outputs,n1) + inst_to=getattr(self,'install_path','/Applications')+'/%s/Contents/MacOS/'%name + self.bld.install_files(inst_to,n1,chmod=Utils.O755) + if getattr(self,'mac_resources',None): + res_dir=n1.parent.parent.make_node('Resources') + inst_to=getattr(self,'install_path','/Applications')+'/%s/Resources'%name + for x in self.to_list(self.mac_resources): + node=self.path.find_node(x) + if not node: + raise Errors.WafError('Missing mac_resource %r in %r'%(x,self)) + parent=node.parent + if os.path.isdir(node.abspath()): + nodes=node.ant_glob('**') + else: + nodes=[node] + for node in nodes: + rel=node.path_from(parent) + tsk=self.create_task('macapp',node,res_dir.make_node(rel)) + self.bld.install_as(inst_to+'/%s'%rel,node) + if getattr(self.bld,'is_install',None): + self.install_task.hasrun=Task.SKIP_ME +def create_task_macplist(self): + if self.env['MACAPP']or getattr(self,'mac_app',False): + out=self.link_task.outputs[0] + name=bundle_name_for_output(out) + dir=self.create_bundle_dirs(name,out) + n1=dir.find_or_declare(['Contents','Info.plist']) + self.plisttask=plisttask=self.create_task('macplist',[],n1) + if getattr(self,'mac_plist',False): + node=self.path.find_resource(self.mac_plist) + if node: + plisttask.inputs.append(node) + else: + plisttask.code=self.mac_plist + else: + plisttask.code=app_info%self.link_task.outputs[0].name + inst_to=getattr(self,'install_path','/Applications')+'/%s/Contents/'%name + self.bld.install_files(inst_to,n1) +def apply_bundle(self): + if self.env['MACBUNDLE']or getattr(self,'mac_bundle',False): + self.env['LINKFLAGS_cshlib']=self.env['LINKFLAGS_cxxshlib']=[] + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['macbundle_PATTERN'] + use=self.use=self.to_list(getattr(self,'use',[])) + if not'MACBUNDLE'in use: + use.append('MACBUNDLE') +app_dirs=['Contents','Contents/MacOS','Contents/Resources'] +class macapp(Task.Task): + color='PINK' + def run(self): + self.outputs[0].parent.mkdir() + shutil.copy2(self.inputs[0].srcpath(),self.outputs[0].abspath()) +class macplist(Task.Task): + color='PINK' + ext_in=['.bin'] + def run(self): + if getattr(self,'code',None): + txt=self.code + else: + txt=self.inputs[0].read() + self.outputs[0].write(txt) + +feature('c','cxx')(set_macosx_deployment_target) +taskgen_method(create_bundle_dirs) +feature('cprogram','cxxprogram')(create_task_macapp) +after_method('apply_link')(create_task_macapp) +feature('cprogram','cxxprogram')(create_task_macplist) +after_method('apply_link')(create_task_macplist) +feature('cshlib','cxxshlib')(apply_bundle) +before_method('apply_link','propagate_uselib_vars')(apply_bundle) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/c_preproc.py jalv-1.0.0~dfsg0/waflib/Tools/c_preproc.py --- jalv-0~svn3409/waflib/Tools/c_preproc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c_preproc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,606 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import re,sys,os,string,traceback +from waflib import Logs,Build,Utils,Errors +from waflib.Logs import debug,error +class PreprocError(Errors.WafError): + pass +POPFILE='-' +recursion_limit=150 +go_absolute=False +standard_includes=['/usr/include'] +if Utils.is_win32: + standard_includes=[] +use_trigraphs=0 +strict_quotes=0 +g_optrans={'not':'!','and':'&&','bitand':'&','and_eq':'&=','or':'||','bitor':'|','or_eq':'|=','xor':'^','xor_eq':'^=','compl':'~',} +re_lines=re.compile('^[ \t]*(#|%:)[ \t]*(ifdef|ifndef|if|else|elif|endif|include|import|define|undef|pragma)[ \t]*(.*)\r*$',re.IGNORECASE|re.MULTILINE) +re_mac=re.compile("^[a-zA-Z_]\w*") +re_fun=re.compile('^[a-zA-Z_][a-zA-Z0-9_]*[(]') +re_pragma_once=re.compile('^\s*once\s*',re.IGNORECASE) +re_nl=re.compile('\\\\\r*\n',re.MULTILINE) +re_cpp=re.compile(r"""(/\*[^*]*\*+([^/*][^*]*\*+)*/)|//[^\n]*|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^/"'\\]*)""",re.MULTILINE) +trig_def=[('??'+a,b)for a,b in zip("=-/!'()<>",r'#~\|^[]{}')] +chr_esc={'0':0,'a':7,'b':8,'t':9,'n':10,'f':11,'v':12,'r':13,'\\':92,"'":39} +NUM='i' +OP='O' +IDENT='T' +STR='s' +CHAR='c' +tok_types=[NUM,STR,IDENT,OP] +exp_types=[r"""0[xX](?P[a-fA-F0-9]+)(?P[uUlL]*)|L*?'(?P(\\.|[^\\'])+)'|(?P\d+)[Ee](?P[+-]*?\d+)(?P[fFlL]*)|(?P\d*\.\d+)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P\d+\.\d*)([Ee](?P[+-]*?\d+))?(?P[fFlL]*)|(?P0*)(?P\d+)(?P[uUlL]*)""",r'L?"([^"\\]|\\.)*"',r'[a-zA-Z_]\w*',r'%:%:|<<=|>>=|\.\.\.|<<|<%|<:|<=|>>|>=|\+\+|\+=|--|->|-=|\*=|/=|%:|%=|%>|==|&&|&=|\|\||\|=|\^=|:>|!=|##|[\(\)\{\}\[\]<>\?\|\^\*\+&=:!#;,%/\-\?\~\.]',] +re_clexer=re.compile('|'.join(["(?P<%s>%s)"%(name,part)for name,part in zip(tok_types,exp_types)]),re.M) +accepted='a' +ignored='i' +undefined='u' +skipped='s' +def repl(m): + s=m.group(1) + if s: + return' ' + return m.group(3)or'' +def filter_comments(filename): + code=Utils.readf(filename) + if use_trigraphs: + for(a,b)in trig_def:code=code.split(a).join(b) + code=re_nl.sub('',code) + code=re_cpp.sub(repl,code) + return[(m.group(2),m.group(3))for m in re.finditer(re_lines,code)] +prec={} +ops=['* / %','+ -','<< >>','< <= >= >','== !=','& | ^','&& ||',','] +for x in range(len(ops)): + syms=ops[x] + for u in syms.split(): + prec[u]=x +def trimquotes(s): + if not s:return'' + s=s.rstrip() + if s[0]=="'"and s[-1]=="'":return s[1:-1] + return s +def reduce_nums(val_1,val_2,val_op): + try:a=0+val_1 + except TypeError:a=int(val_1) + try:b=0+val_2 + except TypeError:b=int(val_2) + d=val_op + if d=='%':c=a%b + elif d=='+':c=a+b + elif d=='-':c=a-b + elif d=='*':c=a*b + elif d=='/':c=a/b + elif d=='^':c=a^b + elif d=='|':c=a|b + elif d=='||':c=int(a or b) + elif d=='&':c=a&b + elif d=='&&':c=int(a and b) + elif d=='==':c=int(a==b) + elif d=='!=':c=int(a!=b) + elif d=='<=':c=int(a<=b) + elif d=='<':c=int(a':c=int(a>b) + elif d=='>=':c=int(a>=b) + elif d=='^':c=int(a^b) + elif d=='<<':c=a<>':c=a>>b + else:c=0 + return c +def get_num(lst): + if not lst:raise PreprocError("empty list for get_num") + (p,v)=lst[0] + if p==OP: + if v=='(': + count_par=1 + i=1 + while i=prec[v]: + num2=reduce_nums(num,num2,v) + return get_term([(NUM,num2)]+lst) + else: + num3,lst=get_num(lst[1:]) + num3=reduce_nums(num2,num3,v2) + return get_term([(NUM,num),(p,v),(NUM,num3)]+lst) + raise PreprocError("cannot reduce %r"%lst) +def reduce_eval(lst): + num,lst=get_term(lst) + return(NUM,num) +def stringize(lst): + lst=[str(v2)for(p2,v2)in lst] + return"".join(lst) +def paste_tokens(t1,t2): + p1=None + if t1[0]==OP and t2[0]==OP: + p1=OP + elif t1[0]==IDENT and(t2[0]==IDENT or t2[0]==NUM): + p1=IDENT + elif t1[0]==NUM and t2[0]==NUM: + p1=NUM + if not p1: + raise PreprocError('tokens do not make a valid paste %r and %r'%(t1,t2)) + return(p1,t1[1]+t2[1]) +def reduce_tokens(lst,defs,ban=[]): + i=0 + while i=len(lst): + raise PreprocError("expected '(' after %r (got nothing)"%v) + (p2,v2)=lst[i] + if p2!=OP or v2!='(': + raise PreprocError("expected '(' after %r"%v) + del lst[i] + one_param=[] + count_paren=0 + while i1: + (p3,v3)=accu[-1] + (p4,v4)=accu[-2] + if v3=='##': + accu.pop() + if v4==','and pt.*)>|"(?P.*)")') +def extract_include(txt,defs): + m=re_include.search(txt) + if m: + if m.group('a'):return'<',m.group('a') + if m.group('b'):return'"',m.group('b') + toks=tokenize(txt) + reduce_tokens(toks,defs,['waf_include']) + if not toks: + raise PreprocError("could not parse include %s"%txt) + if len(toks)==1: + if toks[0][0]==STR: + return'"',toks[0][1] + else: + if toks[0][1]=='<'and toks[-1][1]=='>': + return stringize(toks).lstrip('<').rstrip('>') + raise PreprocError("could not parse include %s."%txt) +def parse_char(txt): + if not txt:raise PreprocError("attempted to parse a null char") + if txt[0]!='\\': + return ord(txt) + c=txt[1] + if c=='x': + if len(txt)==4 and txt[3]in string.hexdigits:return int(txt[2:],16) + return int(txt[2:],16) + elif c.isdigit(): + if c=='0'and len(txt)==2:return 0 + for i in 3,2,1: + if len(txt)>i and txt[1:1+i].isdigit(): + return(1+i,int(txt[1:1+i],8)) + else: + try:return chr_esc[c] + except KeyError:raise PreprocError("could not parse char literal '%s'"%txt) +def tokenize(s): + ret=[] + for match in re_clexer.finditer(s): + m=match.group + for name in tok_types: + v=m(name) + if v: + if name==IDENT: + try:v=g_optrans[v];name=OP + except KeyError: + if v.lower()=="true": + v=1 + name=NUM + elif v.lower()=="false": + v=0 + name=NUM + elif name==NUM: + if m('oct'):v=int(v,8) + elif m('hex'):v=int(m('hex'),16) + elif m('n0'):v=m('n0') + else: + v=m('char') + if v:v=parse_char(v) + else:v=m('n2')or m('n4') + elif name==OP: + if v=='%:':v='#' + elif v=='%:%:':v='##' + elif name==STR: + v=v[1:-1] + ret.append((name,v)) + break + return ret +def define_name(line): + return re_mac.match(line).group(0) +class c_parser(object): + def __init__(self,nodepaths=None,defines=None): + self.lines=[] + if defines is None: + self.defs={} + else: + self.defs=dict(defines) + self.state=[] + self.count_files=0 + self.currentnode_stack=[] + self.nodepaths=nodepaths or[] + self.nodes=[] + self.names=[] + self.curfile='' + self.ban_includes=set([]) + def cached_find_resource(self,node,filename): + try: + nd=node.ctx.cache_nd + except: + nd=node.ctx.cache_nd={} + tup=(node,filename) + try: + return nd[tup] + except KeyError: + ret=node.find_resource(filename) + if ret: + if getattr(ret,'children',None): + ret=None + elif ret.is_child_of(node.ctx.bldnode): + tmp=node.ctx.srcnode.search(ret.path_from(node.ctx.bldnode)) + if tmp and getattr(tmp,'children',None): + ret=None + nd[tup]=ret + return ret + def tryfind(self,filename): + self.curfile=filename + found=self.cached_find_resource(self.currentnode_stack[-1],filename) + for n in self.nodepaths: + if found: + break + found=self.cached_find_resource(n,filename) + if found: + self.nodes.append(found) + if filename[-4:]!='.moc': + self.addlines(found) + else: + if not filename in self.names: + self.names.append(filename) + return found + def addlines(self,node): + self.currentnode_stack.append(node.parent) + filepath=node.abspath() + self.count_files+=1 + if self.count_files>recursion_limit: + raise PreprocError("recursion limit exceeded") + pc=self.parse_cache + debug('preproc: reading file %r',filepath) + try: + lns=pc[filepath] + except KeyError: + pass + else: + self.lines.extend(lns) + return + try: + lines=filter_comments(filepath) + lines.append((POPFILE,'')) + lines.reverse() + pc[filepath]=lines + self.lines.extend(lines) + except IOError: + raise PreprocError("could not read the file %s"%filepath) + except Exception: + if Logs.verbose>0: + error("parsing %s failed"%filepath) + traceback.print_exc() + def start(self,node,env): + debug('preproc: scanning %s (in %s)',node.name,node.parent.name) + bld=node.ctx + try: + self.parse_cache=bld.parse_cache + except AttributeError: + bld.parse_cache={} + self.parse_cache=bld.parse_cache + self.addlines(node) + if env['DEFINES']: + try: + lst=['%s %s'%(x[0],trimquotes('='.join(x[1:])))for x in[y.split('=')for y in env['DEFINES']]] + lst.reverse() + self.lines.extend([('define',x)for x in lst]) + except AttributeError: + pass + while self.lines: + (token,line)=self.lines.pop() + if token==POPFILE: + self.count_files-=1 + self.currentnode_stack.pop() + continue + try: + ve=Logs.verbose + if ve:debug('preproc: line is %s - %s state is %s',token,line,self.state) + state=self.state + if token[:2]=='if': + state.append(undefined) + elif token=='endif': + state.pop() + if token[0]!='e': + if skipped in self.state or ignored in self.state: + continue + if token=='if': + ret=eval_macro(tokenize(line),self.defs) + if ret:state[-1]=accepted + else:state[-1]=ignored + elif token=='ifdef': + m=re_mac.match(line) + if m and m.group(0)in self.defs:state[-1]=accepted + else:state[-1]=ignored + elif token=='ifndef': + m=re_mac.match(line) + if m and m.group(0)in self.defs:state[-1]=ignored + else:state[-1]=accepted + elif token=='include'or token=='import': + (kind,inc)=extract_include(line,self.defs) + if inc in self.ban_includes: + continue + if token=='import':self.ban_includes.add(inc) + if ve:debug('preproc: include found %s (%s) ',inc,kind) + if kind=='"'or not strict_quotes: + self.tryfind(inc) + elif token=='elif': + if state[-1]==accepted: + state[-1]=skipped + elif state[-1]==ignored: + if eval_macro(tokenize(line),self.defs): + state[-1]=accepted + elif token=='else': + if state[-1]==accepted:state[-1]=skipped + elif state[-1]==ignored:state[-1]=accepted + elif token=='define': + try: + self.defs[define_name(line)]=line + except: + raise PreprocError("Invalid define line %s"%line) + elif token=='undef': + m=re_mac.match(line) + if m and m.group(0)in self.defs: + self.defs.__delitem__(m.group(0)) + elif token=='pragma': + if re_pragma_once.match(line.lower()): + self.ban_includes.add(self.curfile) + except Exception ,e: + if Logs.verbose: + debug('preproc: line parsing failed (%s): %s %s',e,line,Utils.ex_stack()) +def scan(task): + global go_absolute + try: + incn=task.generator.includes_nodes + except AttributeError: + raise Errors.WafError('%r is missing a feature such as "c", "cxx" or "includes": '%task.generator) + if go_absolute: + nodepaths=incn+standard_includes + else: + nodepaths=[x for x in incn if x.is_child_of(x.ctx.srcnode)or x.is_child_of(x.ctx.bldnode)] + tmp=c_parser(nodepaths) + tmp.start(task.inputs[0],task.env) + if Logs.verbose: + debug('deps: deps for %r: %r; unresolved %r'%(task.inputs,tmp.nodes,tmp.names)) + return(tmp.nodes,tmp.names) + +Utils.run_once(tokenize) +Utils.run_once(define_name) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/c.py jalv-1.0.0~dfsg0/waflib/Tools/c.py --- jalv-0~svn3409/waflib/Tools/c.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,27 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import TaskGen,Task,Utils +from waflib.Tools import c_preproc +from waflib.Tools.ccroot import link_task,stlink_task +def c_hook(self,node): + return self.create_compiled_task('c',node) +class c(Task.Task): + run_str='${CC} ${ARCH_ST:ARCH} ${CFLAGS} ${CPPFLAGS} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${CC_SRC_F}${SRC} ${CC_TGT_F}${TGT}' + vars=['CCDEPS'] + ext_in=['.h'] + scan=c_preproc.scan +Task.classes['cc']=cc=c +class cprogram(link_task): + run_str='${LINK_CC} ${LINKFLAGS} ${CCLNK_SRC_F}${SRC} ${CCLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${SHLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB}' + ext_out=['.bin'] + vars=['LINKDEPS'] + inst_to='${BINDIR}' + chmod=Utils.O755 +class cshlib(cprogram): + inst_to='${LIBDIR}' +class cstlib(stlink_task): + pass + +TaskGen.extension('.c')(c_hook) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/cs.py jalv-1.0.0~dfsg0/waflib/Tools/cs.py --- jalv-0~svn3409/waflib/Tools/cs.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/cs.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,98 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +from waflib import Utils,Task,Options,Logs,Errors +from waflib.TaskGen import before_method,after_method,feature +from waflib.Tools import ccroot +from waflib.Configure import conf +ccroot.USELIB_VARS['cs']=set(['CSFLAGS','ASSEMBLIES','RESOURCES']) +ccroot.lib_patterns['csshlib']=['%s'] +def apply_cs(self): + cs_nodes=[] + no_nodes=[] + for x in self.to_nodes(self.source): + if x.name.endswith('.cs'): + cs_nodes.append(x) + else: + no_nodes.append(x) + self.source=no_nodes + bintype=getattr(self,'type',self.gen.endswith('.dll')and'library'or'exe') + self.cs_task=tsk=self.create_task('mcs',cs_nodes,self.path.find_or_declare(self.gen)) + tsk.env.CSTYPE='/target:%s'%bintype + tsk.env.OUT='/out:%s'%tsk.outputs[0].abspath() + inst_to=getattr(self,'install_path',bintype=='exe'and'${BINDIR}'or'${LIBDIR}') + if inst_to: + mod=getattr(self,'chmod',bintype=='exe'and Utils.O755 or Utils.O644) + self.install_task=self.bld.install_files(inst_to,self.cs_task.outputs[:],env=self.env,chmod=mod) +def use_cs(self): + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except Errors.WafError: + self.cs_task.env.append_value('CSFLAGS','/reference:%s'%x) + continue + y.post() + tsk=getattr(y,'cs_task',None)or getattr(y,'link_task',None) + if not tsk: + self.bld.fatal('cs task has no link task for use %r'%self) + self.cs_task.dep_nodes.extend(tsk.outputs) + self.cs_task.set_run_after(tsk) + self.cs_task.env.append_value('CSFLAGS','/reference:%s'%tsk.outputs[0].abspath()) +def debug_cs(self): + csdebug=getattr(self,'csdebug',self.env.CSDEBUG) + if not csdebug: + return + node=self.cs_task.outputs[0] + if self.env.CS_NAME=='mono': + out=node.parent.find_or_declare(node.name+'.mdb') + else: + out=node.change_ext('.pdb') + self.cs_task.outputs.append(out) + try: + self.install_task.source.append(out) + except AttributeError: + pass + if csdebug=='pdbonly': + val=['/debug+','/debug:pdbonly'] + elif csdebug=='full': + val=['/debug+','/debug:full'] + else: + val=['/debug-'] + self.cs_task.env.append_value('CSFLAGS',val) +class mcs(Task.Task): + color='YELLOW' + run_str='${MCS} ${CSTYPE} ${CSFLAGS} ${ASS_ST:ASSEMBLIES} ${RES_ST:RESOURCES} ${OUT} ${SRC}' +def configure(conf): + csc=getattr(Options.options,'cscbinary',None) + if csc: + conf.env.MCS=csc + conf.find_program(['csc','mcs','gmcs'],var='MCS') + conf.env.ASS_ST='/r:%s' + conf.env.RES_ST='/resource:%s' + conf.env.CS_NAME='csc' + if str(conf.env.MCS).lower().find('mcs')>-1: + conf.env.CS_NAME='mono' +def options(opt): + opt.add_option('--with-csc-binary',type='string',dest='cscbinary') +class fake_csshlib(Task.Task): + color='YELLOW' + inst_to=None + def runnable_status(self): + for x in self.outputs: + x.sig=Utils.h_file(x.abspath()) + return Task.SKIP_ME +def read_csshlib(self,name,paths=[]): + return self(name=name,features='fake_lib',lib_paths=paths,lib_type='csshlib') + +feature('cs')(apply_cs) +before_method('process_source')(apply_cs) +feature('cs')(use_cs) +after_method('apply_cs')(use_cs) +feature('cs')(debug_cs) +after_method('apply_cs','use_cs')(debug_cs) +conf(read_csshlib) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/c_tests.py jalv-1.0.0~dfsg0/waflib/Tools/c_tests.py --- jalv-0~svn3409/waflib/Tools/c_tests.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/c_tests.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,146 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Task +from waflib.Configure import conf +from waflib.TaskGen import feature,before_method,after_method +import sys +LIB_CODE=''' +#ifdef _MSC_VER +#define testEXPORT __declspec(dllexport) +#else +#define testEXPORT +#endif +testEXPORT int lib_func(void) { return 9; } +''' +MAIN_CODE=''' +#ifdef _MSC_VER +#define testEXPORT __declspec(dllimport) +#else +#define testEXPORT +#endif +testEXPORT int lib_func(void); +int main(void) {return !(lib_func() == 9);} +''' +def link_lib_test_fun(self): + def write_test_file(task): + task.outputs[0].write(task.generator.code) + rpath=[] + if getattr(self,'add_rpath',False): + rpath=[self.bld.path.get_bld().abspath()] + mode=self.mode + m='%s %s'%(mode,mode) + ex=self.test_exec and'test_exec'or'' + bld=self.bld + bld(rule=write_test_file,target='test.'+mode,code=LIB_CODE) + bld(rule=write_test_file,target='main.'+mode,code=MAIN_CODE) + bld(features='%sshlib'%m,source='test.'+mode,target='test') + bld(features='%sprogram %s'%(m,ex),source='main.'+mode,target='app',use='test',rpath=rpath) +def check_library(self,mode=None,test_exec=True): + if not mode: + mode='c' + if self.env.CXX: + mode='cxx' + self.check(compile_filename=[],features='link_lib_test',msg='Checking for libraries',mode=mode,test_exec=test_exec,) +INLINE_CODE=''' +typedef int foo_t; +static %s foo_t static_foo () {return 0; } +%s foo_t foo () { + return 0; +} +''' +INLINE_VALUES=['inline','__inline__','__inline'] +def check_inline(self,**kw): + self.start_msg('Checking for inline') + if not'define_name'in kw: + kw['define_name']='INLINE_MACRO' + if not'features'in kw: + if self.env.CXX: + kw['features']=['cxx'] + else: + kw['features']=['c'] + for x in INLINE_VALUES: + kw['fragment']=INLINE_CODE%(x,x) + try: + self.check(**kw) + except self.errors.ConfigurationError: + continue + else: + self.end_msg(x) + if x!='inline': + self.define('inline',x,quote=False) + return x + self.fatal('could not use inline functions') +LARGE_FRAGMENT='#include \nint main() { return !(sizeof(off_t) >= 8); }\n' +def check_large_file(self,**kw): + if not'define_name'in kw: + kw['define_name']='HAVE_LARGEFILE' + if not'execute'in kw: + kw['execute']=True + if not'features'in kw: + if self.env.CXX: + kw['features']=['cxx','cxxprogram'] + else: + kw['features']=['c','cprogram'] + kw['fragment']=LARGE_FRAGMENT + kw['msg']='Checking for large file support' + ret=True + try: + if self.env.DEST_BINFMT!='pe': + ret=self.check(**kw) + except self.errors.ConfigurationError: + pass + else: + if ret: + return True + kw['msg']='Checking for -D_FILE_OFFSET_BITS=64' + kw['defines']=['_FILE_OFFSET_BITS=64'] + try: + ret=self.check(**kw) + except self.errors.ConfigurationError: + pass + else: + self.define('_FILE_OFFSET_BITS',64) + return ret + self.fatal('There is no support for large files') +ENDIAN_FRAGMENT=''' +short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 }; +short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 }; +int use_ascii (int i) { + return ascii_mm[i] + ascii_ii[i]; +} +short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 }; +short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 }; +int use_ebcdic (int i) { + return ebcdic_mm[i] + ebcdic_ii[i]; +} +extern int foo; +''' +class grep_for_endianness(Task.Task): + color='PINK' + def run(self): + txt=self.inputs[0].read(flags='rb').decode('iso8859-1') + if txt.find('LiTTleEnDian')>-1: + self.generator.tmp.append('little') + elif txt.find('BIGenDianSyS')>-1: + self.generator.tmp.append('big') + else: + return-1 +def grep_for_endianness_fun(self): + self.create_task('grep_for_endianness',self.compiled_tasks[0].outputs[0]) +def check_endianness(self): + tmp=[] + def check_msg(self): + return tmp[0] + self.check(fragment=ENDIAN_FRAGMENT,features='c grep_for_endianness',msg="Checking for endianness",define='ENDIANNESS',tmp=tmp,okmsg=check_msg) + return tmp[0] + +feature('link_lib_test')(link_lib_test_fun) +before_method('process_source')(link_lib_test_fun) +conf(check_library) +conf(check_inline) +conf(check_large_file) +feature('grep_for_endianness')(grep_for_endianness_fun) +after_method('process_source')(grep_for_endianness_fun) +conf(check_endianness) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/cxx.py jalv-1.0.0~dfsg0/waflib/Tools/cxx.py --- jalv-0~svn3409/waflib/Tools/cxx.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/cxx.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,27 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import TaskGen,Task,Utils +from waflib.Tools import c_preproc +from waflib.Tools.ccroot import link_task,stlink_task +def cxx_hook(self,node): + return self.create_compiled_task('cxx',node) +TaskGen.extension('.cpp','.cc','.cxx','.C','.c++')(cxx_hook) +if not'.c'in TaskGen.task_gen.mappings: + TaskGen.task_gen.mappings['.c']=TaskGen.task_gen.mappings['.cpp'] +class cxx(Task.Task): + run_str='${CXX} ${ARCH_ST:ARCH} ${CXXFLAGS} ${CPPFLAGS} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${CXX_SRC_F}${SRC} ${CXX_TGT_F}${TGT}' + vars=['CXXDEPS'] + ext_in=['.h'] + scan=c_preproc.scan +class cxxprogram(link_task): + run_str='${LINK_CXX} ${LINKFLAGS} ${CXXLNK_SRC_F}${SRC} ${CXXLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FRAMEWORKPATH_ST:FRAMEWORKPATH} ${FRAMEWORK_ST:FRAMEWORK} ${ARCH_ST:ARCH} ${STLIB_MARKER} ${STLIBPATH_ST:STLIBPATH} ${STLIB_ST:STLIB} ${SHLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${LIB_ST:LIB}' + vars=['LINKDEPS'] + ext_out=['.bin'] + inst_to='${BINDIR}' + chmod=Utils.O755 +class cxxshlib(cxxprogram): + inst_to='${LIBDIR}' +class cxxstlib(stlink_task): + pass diff -Nru jalv-0~svn3409/waflib/Tools/dbus.py jalv-1.0.0~dfsg0/waflib/Tools/dbus.py --- jalv-0~svn3409/waflib/Tools/dbus.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/dbus.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,30 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Task,Errors +from waflib.TaskGen import taskgen_method,before_method +def add_dbus_file(self,filename,prefix,mode): + if not hasattr(self,'dbus_lst'): + self.dbus_lst=[] + if not'process_dbus'in self.meths: + self.meths.append('process_dbus') + self.dbus_lst.append([filename,prefix,mode]) +def process_dbus(self): + for filename,prefix,mode in getattr(self,'dbus_lst',[]): + node=self.path.find_resource(filename) + if not node: + raise Errors.WafError('file not found '+filename) + tsk=self.create_task('dbus_binding_tool',node,node.change_ext('.h')) + tsk.env.DBUS_BINDING_TOOL_PREFIX=prefix + tsk.env.DBUS_BINDING_TOOL_MODE=mode +class dbus_binding_tool(Task.Task): + color='BLUE' + ext_out=['.h'] + run_str='${DBUS_BINDING_TOOL} --prefix=${DBUS_BINDING_TOOL_PREFIX} --mode=${DBUS_BINDING_TOOL_MODE} --output=${TGT} ${SRC}' + shell=True +def configure(conf): + dbus_binding_tool=conf.find_program('dbus-binding-tool',var='DBUS_BINDING_TOOL') + +taskgen_method(add_dbus_file) +before_method('apply_core')(process_dbus) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/d_config.py jalv-1.0.0~dfsg0/waflib/Tools/d_config.py --- jalv-0~svn3409/waflib/Tools/d_config.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/d_config.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,47 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Utils +from waflib.Configure import conf +def d_platform_flags(self): + v=self.env + if not v.DEST_OS: + v.DEST_OS=Utils.unversioned_sys_platform() + if Utils.destos_to_binfmt(self.env.DEST_OS)=='pe': + v['dprogram_PATTERN']='%s.exe' + v['dshlib_PATTERN']='lib%s.dll' + v['dstlib_PATTERN']='lib%s.a' + else: + v['dprogram_PATTERN']='%s' + v['dshlib_PATTERN']='lib%s.so' + v['dstlib_PATTERN']='lib%s.a' +DLIB=''' +version(D_Version2) { + import std.stdio; + int main() { + writefln("phobos2"); + return 0; + } +} else { + version(Tango) { + import tango.stdc.stdio; + int main() { + printf("tango"); + return 0; + } + } else { + import std.stdio; + int main() { + writefln("phobos1"); + return 0; + } + } +} +''' +def check_dlibrary(self): + ret=self.check_cc(features='d dprogram',fragment=DLIB,compile_filename='test.d',execute=True,define_ret=True) + self.env.DLIBRARY=ret.strip() + +conf(d_platform_flags) +conf(check_dlibrary) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/dmd.py jalv-1.0.0~dfsg0/waflib/Tools/dmd.py --- jalv-0~svn3409/waflib/Tools/dmd.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/dmd.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,47 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +from waflib.Tools import ar,d +from waflib.Configure import conf +def find_dmd(conf): + conf.find_program(['dmd','ldc'],var='D') +def common_flags_ldc(conf): + v=conf.env + v['DFLAGS']=['-d-version=Posix'] + v['LINKFLAGS']=[] + v['DFLAGS_dshlib']=['-relocation-model=pic'] +def common_flags_dmd(conf): + v=conf.env + v['D_SRC_F']=['-c'] + v['D_TGT_F']='-of%s' + v['D_LINKER']=v['D'] + v['DLNK_SRC_F']='' + v['DLNK_TGT_F']='-of%s' + v['DINC_ST']='-I%s' + v['DSHLIB_MARKER']=v['DSTLIB_MARKER']='' + v['DSTLIB_ST']=v['DSHLIB_ST']='-L-l%s' + v['DSTLIBPATH_ST']=v['DLIBPATH_ST']='-L-L%s' + v['LINKFLAGS_dprogram']=['-quiet'] + v['DFLAGS_dshlib']=['-fPIC'] + v['LINKFLAGS_dshlib']=['-L-shared'] + v['DHEADER_ext']='.di' + v.DFLAGS_d_with_header=['-H','-Hf'] + v['D_HDR_F']='%s' +def configure(conf): + conf.find_dmd() + if sys.platform=='win32': + out=conf.cmd_and_log([conf.env.D,'--help']) + if out.find("D Compiler v2.")>-1: + conf.fatal('dmd2 on Windows is not supported, use gdc or ldc instead') + conf.load('ar') + conf.load('d') + conf.common_flags_dmd() + conf.d_platform_flags() + if str(conf.env.D).find('ldc')>-1: + conf.common_flags_ldc() + +conf(find_dmd) +conf(common_flags_ldc) +conf(common_flags_dmd) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/d.py jalv-1.0.0~dfsg0/waflib/Tools/d.py --- jalv-0~svn3409/waflib/Tools/d.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/d.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,48 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Utils,Task,Errors +from waflib.TaskGen import taskgen_method,feature,extension +from waflib.Tools import d_scan,d_config +from waflib.Tools.ccroot import link_task,stlink_task +class d(Task.Task): + color='GREEN' + run_str='${D} ${DFLAGS} ${DINC_ST:INCPATHS} ${D_SRC_F:SRC} ${D_TGT_F:TGT}' + scan=d_scan.scan +class d_with_header(d): + run_str='${D} ${DFLAGS} ${DINC_ST:INCPATHS} ${D_HDR_F:tgt.outputs[1].bldpath()} ${D_SRC_F:SRC} ${D_TGT_F:tgt.outputs[0].bldpath()}' +class d_header(Task.Task): + color='BLUE' + run_str='${D} ${D_HEADER} ${SRC}' +class dprogram(link_task): + run_str='${D_LINKER} ${LINKFLAGS} ${DLNK_SRC_F}${SRC} ${DLNK_TGT_F:TGT} ${RPATH_ST:RPATH} ${DSTLIB_MARKER} ${DSTLIBPATH_ST:STLIBPATH} ${DSTLIB_ST:STLIB} ${DSHLIB_MARKER} ${DLIBPATH_ST:LIBPATH} ${DSHLIB_ST:LIB}' + inst_to='${BINDIR}' + chmod=Utils.O755 +class dshlib(dprogram): + inst_to='${LIBDIR}' +class dstlib(stlink_task): + pass +def d_hook(self,node): + if getattr(self,'generate_headers',None): + task=self.create_compiled_task('d_with_header',node) + header_node=node.change_ext(self.env['DHEADER_ext']) + task.outputs.append(header_node) + else: + task=self.create_compiled_task('d',node) + return task +def generate_header(self,filename,install_path=None): + try: + self.header_lst.append([filename,install_path]) + except AttributeError: + self.header_lst=[[filename,install_path]] +def process_header(self): + for i in getattr(self,'header_lst',[]): + node=self.path.find_resource(i[0]) + if not node: + raise Errors.WafError('file %r not found on d obj'%i[0]) + self.create_task('d_header',node,node.change_ext('.di')) + +extension('.d','.di','.D')(d_hook) +taskgen_method(generate_header) +feature('d')(process_header) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/d_scan.py jalv-1.0.0~dfsg0/waflib/Tools/d_scan.py --- jalv-0~svn3409/waflib/Tools/d_scan.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/d_scan.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,133 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils,Logs +def filter_comments(filename): + txt=Utils.readf(filename) + i=0 + buf=[] + max=len(txt) + begin=0 + while i1: + dupe=True + msg='* Node %r is created by more than once%s. The task generators are:'%(k,Logs.verbose==1 and" (full message on 'waf -v -v')"or"") + Logs.error(msg) + for x in v: + if Logs.verbose>1: + Logs.error(' %d. %r'%(1+v.index(x),x.generator)) + else: + Logs.error(' %d. %r in %r'%(1+v.index(x),x.generator.name,getattr(x.generator,'path',None))) + if not dupe: + for(k,v)in uids.items(): + if len(v)>1: + Logs.error('* Several tasks use the same identifier. Please check the information on\n http://waf.googlecode.com/git/docs/apidocs/Task.html#waflib.Task.Task.uid') + for tsk in v: + Logs.error(' - object %r (%r) defined in %r'%(tsk.__class__.__name__,tsk,tsk.generator)) +def check_invalid_constraints(self): + feat=set([]) + for x in list(TaskGen.feats.values()): + feat.union(set(x)) + for(x,y)in TaskGen.task_gen.prec.items(): + feat.add(x) + feat.union(set(y)) + ext=set([]) + for x in TaskGen.task_gen.mappings.values(): + ext.add(x.__name__) + invalid=ext&feat + if invalid: + Logs.error('The methods %r have invalid annotations: @extension <-> @feature/@before_method/@after_method'%list(invalid)) + for cls in list(Task.classes.values()): + for x in('before','after'): + for y in Utils.to_list(getattr(cls,x,[])): + if not Task.classes.get(y,None): + Logs.error('Erroneous order constraint %r=%r on task class %r'%(x,y,cls.__name__)) + if getattr(cls,'rule',None): + Logs.error('Erroneous attribute "rule" on task class %r (rename to "run_str")'%cls.__name__) +def replace(m): + oldcall=getattr(Build.BuildContext,m) + def call(self,*k,**kw): + ret=oldcall(self,*k,**kw) + for x in typos: + if x in kw: + err=True + Logs.error('Fix the typo %r -> %r on %r'%(x,typos[x],ret)) + return ret + setattr(Build.BuildContext,m,call) +def enhance_lib(): + for m in meths_typos: + replace(m) + def ant_glob(self,*k,**kw): + if k: + lst=Utils.to_list(k[0]) + for pat in lst: + if'..'in pat.split('/'): + Logs.error("In ant_glob pattern %r: '..' means 'two dots', not 'parent directory'"%k[0]) + if kw.get('remove',True): + try: + if self.is_child_of(self.ctx.bldnode)and not kw.get('quiet',False): + Logs.error('Using ant_glob on the build folder (%r) is dangerous (quiet=True to disable this warning)'%self) + except AttributeError: + pass + return self.old_ant_glob(*k,**kw) + Node.Node.old_ant_glob=Node.Node.ant_glob + Node.Node.ant_glob=ant_glob + old=Task.is_before + def is_before(t1,t2): + ret=old(t1,t2) + if ret and old(t2,t1): + Logs.error('Contradictory order constraints in classes %r %r'%(t1,t2)) + return ret + Task.is_before=is_before + def check_err_features(self): + lst=self.to_list(self.features) + if'shlib'in lst: + Logs.error('feature shlib -> cshlib, dshlib or cxxshlib') + for x in('c','cxx','d','fc'): + if not x in lst and lst and lst[0]in[x+y for y in('program','shlib','stlib')]: + Logs.error('%r features is probably missing %r'%(self,x)) + TaskGen.feature('*')(check_err_features) + def check_err_order(self): + if not hasattr(self,'rule'): + for x in('before','after','ext_in','ext_out'): + if hasattr(self,x): + Logs.warn('Erroneous order constraint %r on non-rule based task generator %r'%(x,self)) + else: + for x in('before','after'): + for y in self.to_list(getattr(self,x,[])): + if not Task.classes.get(y,None): + Logs.error('Erroneous order constraint %s=%r on %r'%(x,y,self)) + TaskGen.feature('*')(check_err_order) + def check_compile(self): + check_invalid_constraints(self) + try: + ret=self.orig_compile() + finally: + check_same_targets(self) + return ret + Build.BuildContext.orig_compile=Build.BuildContext.compile + Build.BuildContext.compile=check_compile + def use_rec(self,name,**kw): + try: + y=self.bld.get_tgen_by_name(name) + except Errors.WafError: + pass + else: + idx=self.bld.get_group_idx(self) + odx=self.bld.get_group_idx(y) + if odx>idx: + msg="Invalid 'use' across build groups:" + if Logs.verbose>1: + msg+='\n target %r\n uses:\n %r'%(self,y) + else: + msg+=" %r uses %r (try 'waf -v -v' for the full error)"%(self.name,name) + raise Errors.WafError(msg) + self.orig_use_rec(name,**kw) + TaskGen.task_gen.orig_use_rec=TaskGen.task_gen.use_rec + TaskGen.task_gen.use_rec=use_rec + def getattri(self,name,default=None): + if name=='append'or name=='add': + raise Errors.WafError('env.append and env.add do not exist: use env.append_value/env.append_unique') + elif name=='prepend': + raise Errors.WafError('env.prepend does not exist: use env.prepend_value') + if name in self.__slots__: + return object.__getattr__(self,name,default) + else: + return self[name] + ConfigSet.ConfigSet.__getattr__=getattri +def options(opt): + enhance_lib() +def configure(conf): + pass diff -Nru jalv-0~svn3409/waflib/Tools/fc_config.py jalv-1.0.0~dfsg0/waflib/Tools/fc_config.py --- jalv-0~svn3409/waflib/Tools/fc_config.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/fc_config.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,282 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re,shutil,os,sys,string,shlex +from waflib.Configure import conf +from waflib.TaskGen import feature,after_method,before_method +from waflib import Build,Utils +FC_FRAGMENT=' program main\n end program main\n' +FC_FRAGMENT2=' PROGRAM MAIN\n END\n' +def fc_flags(conf): + v=conf.env + v['FC_SRC_F']=[] + v['FC_TGT_F']=['-c','-o'] + v['FCINCPATH_ST']='-I%s' + v['FCDEFINES_ST']='-D%s' + if not v['LINK_FC']:v['LINK_FC']=v['FC'] + v['FCLNK_SRC_F']=[] + v['FCLNK_TGT_F']=['-o'] + v['FCFLAGS_fcshlib']=['-fpic'] + v['LINKFLAGS_fcshlib']=['-shared'] + v['fcshlib_PATTERN']='lib%s.so' + v['fcstlib_PATTERN']='lib%s.a' + v['FCLIB_ST']='-l%s' + v['FCLIBPATH_ST']='-L%s' + v['FCSTLIB_ST']='-l%s' + v['FCSTLIBPATH_ST']='-L%s' + v['FCSTLIB_MARKER']='-Wl,-Bstatic' + v['FCSHLIB_MARKER']='-Wl,-Bdynamic' + v['SONAME_ST']='-Wl,-h,%s' +def check_fortran(self,*k,**kw): + self.check_cc(fragment=FC_FRAGMENT,compile_filename='test.f',features='fc fcprogram',msg='Compiling a simple fortran app') +def check_fc(self,*k,**kw): + kw['compiler']='fc' + if not'compile_mode'in kw: + kw['compile_mode']='fc' + if not'type'in kw: + kw['type']='fcprogram' + if not'compile_filename'in kw: + kw['compile_filename']='test.f90' + if not'code'in kw: + kw['code']=FC_FRAGMENT + return self.check(*k,**kw) +def fortran_modifier_darwin(conf): + v=conf.env + v['FCFLAGS_fcshlib']=['-fPIC','-compatibility_version','1','-current_version','1'] + v['LINKFLAGS_fcshlib']=['-dynamiclib'] + v['fcshlib_PATTERN']='lib%s.dylib' + v['FRAMEWORKPATH_ST']='-F%s' + v['FRAMEWORK_ST']='-framework %s' + v['LINKFLAGS_fcstlib']=[] + v['FCSHLIB_MARKER']='' + v['FCSTLIB_MARKER']='' + v['SONAME_ST']='' +def fortran_modifier_win32(conf): + v=conf.env + v['fcprogram_PATTERN']=v['fcprogram_test_PATTERN']='%s.exe' + v['fcshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='lib%s.dll.a' + v['IMPLIB_ST']='-Wl,--out-implib,%s' + v['FCFLAGS_fcshlib']=[] + v.append_value('FCFLAGS_fcshlib',['-DDLL_EXPORT']) + v.append_value('LINKFLAGS',['-Wl,--enable-auto-import']) +def fortran_modifier_cygwin(conf): + fortran_modifier_win32(conf) + v=conf.env + v['fcshlib_PATTERN']='cyg%s.dll' + v.append_value('LINKFLAGS_fcshlib',['-Wl,--enable-auto-image-base']) + v['FCFLAGS_fcshlib']=[] +def check_fortran_dummy_main(self,*k,**kw): + if not self.env.CC: + self.fatal('A c compiler is required for check_fortran_dummy_main') + lst=['MAIN__','__MAIN','_MAIN','MAIN_','MAIN'] + lst.extend([m.lower()for m in lst]) + lst.append('') + self.start_msg('Detecting whether we need a dummy main') + for main in lst: + kw['fortran_main']=main + try: + self.check_cc(fragment='int %s() { return 0; }\n'%(main or'test'),features='c fcprogram',mandatory=True) + if not main: + self.env.FC_MAIN=-1 + self.end_msg('no') + else: + self.env.FC_MAIN=main + self.end_msg('yes %s'%main) + break + except self.errors.ConfigurationError: + pass + else: + self.end_msg('not found') + self.fatal('could not detect whether fortran requires a dummy main, see the config.log') +GCC_DRIVER_LINE=re.compile('^Driving:') +POSIX_STATIC_EXT=re.compile('\S+\.a') +POSIX_LIB_FLAGS=re.compile('-l\S+') +def is_link_verbose(self,txt): + assert isinstance(txt,str) + for line in txt.splitlines(): + if not GCC_DRIVER_LINE.search(line): + if POSIX_STATIC_EXT.search(line)or POSIX_LIB_FLAGS.search(line): + return True + return False +def check_fortran_verbose_flag(self,*k,**kw): + self.start_msg('fortran link verbose flag') + for x in['-v','--verbose','-verbose','-V']: + try: + self.check_cc(features='fc fcprogram_test',fragment=FC_FRAGMENT2,compile_filename='test.f',linkflags=[x],mandatory=True) + except self.errors.ConfigurationError: + pass + else: + if self.is_link_verbose(self.test_bld.err)or self.is_link_verbose(self.test_bld.out): + self.end_msg(x) + break + else: + self.end_msg('failure') + self.fatal('Could not obtain the fortran link verbose flag (see config.log)') + self.env.FC_VERBOSE_FLAG=x + return x +LINKFLAGS_IGNORED=[r'-lang*',r'-lcrt[a-zA-Z0-9\.]*\.o',r'-lc$',r'-lSystem',r'-libmil',r'-LIST:*',r'-LNO:*'] +if os.name=='nt': + LINKFLAGS_IGNORED.extend([r'-lfrt*',r'-luser32',r'-lkernel32',r'-ladvapi32',r'-lmsvcrt',r'-lshell32',r'-lmingw',r'-lmoldname']) +else: + LINKFLAGS_IGNORED.append(r'-lgcc*') +RLINKFLAGS_IGNORED=[re.compile(f)for f in LINKFLAGS_IGNORED] +def _match_ignore(line): + for i in RLINKFLAGS_IGNORED: + if i.match(line): + return True + return False +def parse_fortran_link(lines): + final_flags=[] + for line in lines: + if not GCC_DRIVER_LINE.match(line): + _parse_flink_line(line,final_flags) + return final_flags +SPACE_OPTS=re.compile('^-[LRuYz]$') +NOSPACE_OPTS=re.compile('^-[RL]') +def _parse_flink_line(line,final_flags): + lexer=shlex.shlex(line,posix=True) + lexer.whitespace_split=True + t=lexer.get_token() + tmp_flags=[] + while t: + def parse(token): + if _match_ignore(token): + pass + elif token.startswith('-lkernel32')and sys.platform=='cygwin': + tmp_flags.append(token) + elif SPACE_OPTS.match(token): + t=lexer.get_token() + if t.startswith('P,'): + t=t[2:] + for opt in t.split(os.pathsep): + tmp_flags.append('-L%s'%opt) + elif NOSPACE_OPTS.match(token): + tmp_flags.append(token) + elif POSIX_LIB_FLAGS.match(token): + tmp_flags.append(token) + else: + pass + t=lexer.get_token() + return t + t=parse(t) + final_flags.extend(tmp_flags) + return final_flags +def check_fortran_clib(self,autoadd=True,*k,**kw): + if not self.env.FC_VERBOSE_FLAG: + self.fatal('env.FC_VERBOSE_FLAG is not set: execute check_fortran_verbose_flag?') + self.start_msg('Getting fortran runtime link flags') + try: + self.check_cc(fragment=FC_FRAGMENT2,compile_filename='test.f',features='fc fcprogram_test',linkflags=[self.env.FC_VERBOSE_FLAG]) + except: + self.end_msg(False) + if kw.get('mandatory',True): + conf.fatal('Could not find the c library flags') + else: + out=self.test_bld.err + flags=parse_fortran_link(out.splitlines()) + self.end_msg('ok (%s)'%' '.join(flags)) + self.env.LINKFLAGS_CLIB=flags + return flags + return[] +def getoutput(conf,cmd,stdin=False): + try: + if stdin: + stdin=Utils.subprocess.PIPE + else: + stdin=None + p=Utils.subprocess.Popen(cmd,stdin=stdin,stdout=Utils.subprocess.PIPE,stderr=Utils.subprocess.PIPE) + if stdin: + p.stdin.write('\n') + stdout,stderr=p.communicate() + except: + conf.fatal('could not determine the compiler version %r'%cmd) + else: + if not isinstance(stdout,str): + stdout=stdout.decode(sys.stdout.encoding) + if not isinstance(stderr,str): + stderr=stderr.decode(sys.stdout.encoding) + return stdout,stderr +ROUTINES_CODE="""\ + subroutine foobar() + return + end + subroutine foo_bar() + return + end +""" +MAIN_CODE=""" +void %(dummy_func_nounder)s(void); +void %(dummy_func_under)s(void); +int %(main_func_name)s() { + %(dummy_func_nounder)s(); + %(dummy_func_under)s(); + return 0; +} +""" +def link_main_routines_tg_method(self): + def write_test_file(task): + task.outputs[0].write(task.generator.code) + bld=self.bld + bld(rule=write_test_file,target='main.c',code=MAIN_CODE%self.__dict__) + bld(rule=write_test_file,target='test.f',code=ROUTINES_CODE) + bld(features='fc fcstlib',source='test.f',target='test') + bld(features='c fcprogram',source='main.c',target='app',use='test') +def mangling_schemes(): + for u in['_','']: + for du in['','_']: + for c in["lower","upper"]: + yield(u,du,c) +def mangle_name(u,du,c,name): + return getattr(name,c)()+u+(name.find('_')!=-1 and du or'') +def check_fortran_mangling(self,*k,**kw): + if not self.env.CC: + self.fatal('A c compiler is required for link_main_routines') + if not self.env.FC: + self.fatal('A fortran compiler is required for link_main_routines') + if not self.env.FC_MAIN: + self.fatal('Checking for mangling requires self.env.FC_MAIN (execute "check_fortran_dummy_main" first?)') + self.start_msg('Getting fortran mangling scheme') + for(u,du,c)in mangling_schemes(): + try: + self.check_cc(compile_filename=[],features='link_main_routines_func',msg='nomsg',errmsg='nomsg',mandatory=True,dummy_func_nounder=mangle_name(u,du,c,"foobar"),dummy_func_under=mangle_name(u,du,c,"foo_bar"),main_func_name=self.env.FC_MAIN) + except self.errors.ConfigurationError: + pass + else: + self.end_msg("ok ('%s', '%s', '%s-case')"%(u,du,c)) + self.env.FORTRAN_MANGLING=(u,du,c) + break + else: + self.end_msg(False) + self.fatal('mangler not found') + return(u,du,c) +def set_lib_pat(self): + self.env['fcshlib_PATTERN']=self.env['pyext_PATTERN'] +def detect_openmp(self): + for x in['-fopenmp','-openmp','-mp','-xopenmp','-omp','-qsmp=omp']: + try: + self.check_fc(msg='Checking for OpenMP flag %s'%x,fragment='program main\n call omp_get_num_threads()\nend program main',fcflags=x,linkflags=x,uselib_store='OPENMP') + except self.errors.ConfigurationError: + pass + else: + break + else: + self.fatal('Could not find OpenMP') + +conf(fc_flags) +conf(check_fortran) +conf(check_fc) +conf(fortran_modifier_darwin) +conf(fortran_modifier_win32) +conf(fortran_modifier_cygwin) +conf(check_fortran_dummy_main) +conf(is_link_verbose) +conf(check_fortran_verbose_flag) +conf(check_fortran_clib) +feature('link_main_routines_func')(link_main_routines_tg_method) +before_method('process_source')(link_main_routines_tg_method) +conf(check_fortran_mangling) +feature('pyext')(set_lib_pat) +before_method('propagate_uselib_vars','apply_link')(set_lib_pat) +conf(detect_openmp) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/fc.py jalv-1.0.0~dfsg0/waflib/Tools/fc.py --- jalv-0~svn3409/waflib/Tools/fc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/fc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,123 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import re +from waflib import Utils,Task,TaskGen,Logs +from waflib.Tools import ccroot,fc_config,fc_scan +from waflib.TaskGen import feature,before_method,after_method,extension +from waflib.Configure import conf +ccroot.USELIB_VARS['fc']=set(['FCFLAGS','DEFINES','INCLUDES']) +ccroot.USELIB_VARS['fcprogram_test']=ccroot.USELIB_VARS['fcprogram']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +ccroot.USELIB_VARS['fcshlib']=set(['LIB','STLIB','LIBPATH','STLIBPATH','LINKFLAGS','RPATH','LINKDEPS']) +ccroot.USELIB_VARS['fcstlib']=set(['ARFLAGS','LINKDEPS']) +def dummy(self): + pass +def fc_hook(self,node): + return self.create_compiled_task('fc',node) +def modfile(conf,name): + return{'lower':name.lower()+'.mod','lower.MOD':name.upper()+'.MOD','UPPER.mod':name.upper()+'.mod','UPPER':name.upper()+'.MOD'}[conf.env.FC_MOD_CAPITALIZATION or'lower'] +def get_fortran_tasks(tsk): + bld=tsk.generator.bld + tasks=bld.get_tasks_group(bld.get_group_idx(tsk.generator)) + return[x for x in tasks if isinstance(x,fc)and not getattr(x,'nomod',None)and not getattr(x,'mod_fortran_done',None)] +class fc(Task.Task): + color='GREEN' + run_str='${FC} ${FCFLAGS} ${FCINCPATH_ST:INCPATHS} ${FCDEFINES_ST:DEFINES} ${_FCMODOUTFLAGS} ${FC_TGT_F}${TGT[0].abspath()} ${FC_SRC_F}${SRC[0].abspath()}' + vars=["FORTRANMODPATHFLAG"] + def scan(self): + tmp=fc_scan.fortran_parser(self.generator.includes_nodes) + tmp.task=self + tmp.start(self.inputs[0]) + if Logs.verbose: + Logs.debug('deps: deps for %r: %r; unresolved %r'%(self.inputs,tmp.nodes,tmp.names)) + return(tmp.nodes,tmp.names) + def runnable_status(self): + if getattr(self,'mod_fortran_done',None): + return super(fc,self).runnable_status() + bld=self.generator.bld + lst=get_fortran_tasks(self) + for tsk in lst: + tsk.mod_fortran_done=True + for tsk in lst: + ret=tsk.runnable_status() + if ret==Task.ASK_LATER: + for x in lst: + x.mod_fortran_done=None + return Task.ASK_LATER + ins=Utils.defaultdict(set) + outs=Utils.defaultdict(set) + for tsk in lst: + key=tsk.uid() + for x in bld.raw_deps[key]: + if x.startswith('MOD@'): + name=bld.modfile(x.replace('MOD@','')) + node=bld.srcnode.find_or_declare(name) + tsk.set_outputs(node) + outs[id(node)].add(tsk) + for tsk in lst: + key=tsk.uid() + for x in bld.raw_deps[key]: + if x.startswith('USE@'): + name=bld.modfile(x.replace('USE@','')) + node=bld.srcnode.find_resource(name) + if node and node not in tsk.outputs: + if not node in bld.node_deps[key]: + bld.node_deps[key].append(node) + ins[id(node)].add(tsk) + for k in ins.keys(): + for a in ins[k]: + a.run_after.update(outs[k]) + tmp=[] + for t in outs[k]: + tmp.extend(t.outputs) + a.dep_nodes.extend(tmp) + try: + a.dep_nodes.sort(key=lambda x:x.abspath()) + except: + a.dep_nodes.sort(lambda x,y:cmp(x.abspath(),y.abspath())) + for tsk in lst: + try: + delattr(tsk,'cache_sig') + except AttributeError: + pass + return super(fc,self).runnable_status() +class fcprogram(ccroot.link_task): + color='YELLOW' + run_str='${FC} ${LINKFLAGS} ${FCLNK_SRC_F}${SRC} ${FCLNK_TGT_F}${TGT[0].abspath()} ${RPATH_ST:RPATH} ${FCSTLIB_MARKER} ${FCSTLIBPATH_ST:STLIBPATH} ${FCSTLIB_ST:STLIB} ${FCSHLIB_MARKER} ${FCLIBPATH_ST:LIBPATH} ${FCLIB_ST:LIB}' + inst_to='${BINDIR}' + chmod=Utils.O755 +class fcshlib(fcprogram): + inst_to='${LIBDIR}' +class fcprogram_test(fcprogram): + def can_retrieve_cache(self): + return False + def runnable_status(self): + ret=super(fcprogram_test,self).runnable_status() + if ret==Task.SKIP_ME: + ret=Task.RUN_ME + return ret + def exec_command(self,cmd,**kw): + bld=self.generator.bld + kw['shell']=isinstance(cmd,str) + kw['stdout']=kw['stderr']=Utils.subprocess.PIPE + kw['cwd']=bld.variant_dir + bld.out=bld.err='' + bld.to_log('command: %s\n'%cmd) + kw['output']=0 + try: + (bld.out,bld.err)=bld.cmd_and_log(cmd,**kw) + except Exception ,e: + return-1 + if bld.out: + bld.to_log("out: %s\n"%bld.out) + if bld.err: + bld.to_log("err: %s\n"%bld.err) +class fcstlib(ccroot.stlink_task): + pass + +feature('fcprogram','fcshlib','fcstlib','fcprogram_test')(dummy) +extension('.f','.f90','.F','.F90','.for','.FOR')(fc_hook) +conf(modfile) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/fc_scan.py jalv-1.0.0~dfsg0/waflib/Tools/fc_scan.py --- jalv-0~svn3409/waflib/Tools/fc_scan.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/fc_scan.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,68 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils,Task,TaskGen,Logs +from waflib.TaskGen import feature,before_method,after_method,extension +from waflib.Configure import conf +INC_REGEX="""(?:^|['">]\s*;)\s*INCLUDE\s+(?:\w+_)?[<"'](.+?)(?=["'>])""" +USE_REGEX="""(?:^|;)\s*USE(?:\s+|(?:(?:\s*,\s*(?:NON_)?INTRINSIC)?\s*::))\s*(\w+)""" +MOD_REGEX="""(?:^|;)\s*MODULE(?!\s*PROCEDURE)(?:\s+|(?:(?:\s*,\s*(?:NON_)?INTRINSIC)?\s*::))\s*(\w+)""" +re_inc=re.compile(INC_REGEX,re.I) +re_use=re.compile(USE_REGEX,re.I) +re_mod=re.compile(MOD_REGEX,re.I) +class fortran_parser(object): + def __init__(self,incpaths): + self.seen=[] + self.nodes=[] + self.names=[] + self.incpaths=incpaths + def find_deps(self,node): + txt=node.read() + incs=[] + uses=[] + mods=[] + for line in txt.splitlines(): + m=re_inc.search(line) + if m: + incs.append(m.group(1)) + m=re_use.search(line) + if m: + uses.append(m.group(1)) + m=re_mod.search(line) + if m: + mods.append(m.group(1)) + return(incs,uses,mods) + def start(self,node): + self.waiting=[node] + while self.waiting: + nd=self.waiting.pop(0) + self.iter(nd) + def iter(self,node): + path=node.abspath() + incs,uses,mods=self.find_deps(node) + for x in incs: + if x in self.seen: + continue + self.seen.append(x) + self.tryfind_header(x) + for x in uses: + name="USE@%s"%x + if not name in self.names: + self.names.append(name) + for x in mods: + name="MOD@%s"%x + if not name in self.names: + self.names.append(name) + def tryfind_header(self,filename): + found=None + for n in self.incpaths: + found=n.find_resource(filename) + if found: + self.nodes.append(found) + self.waiting.append(found) + break + if not found: + if not filename in self.names: + self.names.append(filename) diff -Nru jalv-0~svn3409/waflib/Tools/flex.py jalv-1.0.0~dfsg0/waflib/Tools/flex.py --- jalv-0~svn3409/waflib/Tools/flex.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/flex.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,27 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.TaskGen +def decide_ext(self,node): + if'cxx'in self.features: + return['.lex.cc'] + return['.lex.c'] +def flexfun(tsk): + env=tsk.env + bld=tsk.generator.bld + wd=bld.variant_dir + def to_list(xx): + if isinstance(xx,str):return[xx] + return xx + tsk.last_cmd=lst=[] + lst.extend(to_list(env['FLEX'])) + lst.extend(to_list(env['FLEXFLAGS'])) + lst.extend([a.path_from(bld.bldnode)for a in tsk.inputs]) + lst=[x for x in lst if x] + txt=bld.cmd_and_log(lst,cwd=wd,env=env.env or None,quiet=0) + tsk.outputs[0].write(txt) +waflib.TaskGen.declare_chain(name='flex',rule=flexfun,ext_in='.l',decider=decide_ext,) +def configure(conf): + conf.find_program('flex',var='FLEX') + conf.env.FLEXFLAGS=['-t'] diff -Nru jalv-0~svn3409/waflib/Tools/g95.py jalv-1.0.0~dfsg0/waflib/Tools/g95.py --- jalv-0~svn3409/waflib/Tools/g95.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/g95.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,55 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils +from waflib.Tools import fc,fc_config,fc_scan +from waflib.Configure import conf +def find_g95(conf): + fc=conf.find_program('g95',var='FC') + fc=conf.cmd_to_list(fc) + conf.get_g95_version(fc) + conf.env.FC_NAME='G95' +def g95_flags(conf): + v=conf.env + v['FCFLAGS_fcshlib']=['-fPIC'] + v['FORTRANMODFLAG']=['-fmod=',''] + v['FCFLAGS_DEBUG']=['-Werror'] +def g95_modifier_win32(conf): + fc_config.fortran_modifier_win32(conf) +def g95_modifier_cygwin(conf): + fc_config.fortran_modifier_cygwin(conf) +def g95_modifier_darwin(conf): + fc_config.fortran_modifier_darwin(conf) +def g95_modifier_platform(conf): + dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform() + g95_modifier_func=getattr(conf,'g95_modifier_'+dest_os,None) + if g95_modifier_func: + g95_modifier_func() +def get_g95_version(conf,fc): + version_re=re.compile(r"g95\s*(?P\d*)\.(?P\d*)").search + cmd=fc+['--version'] + out,err=fc_config.getoutput(conf,cmd,stdin=False) + if out: + match=version_re(out) + else: + match=version_re(err) + if not match: + conf.fatal('cannot determine g95 version') + k=match.groupdict() + conf.env['FC_VERSION']=(k['major'],k['minor']) +def configure(conf): + conf.find_g95() + conf.find_ar() + conf.fc_flags() + conf.g95_flags() + conf.g95_modifier_platform() + +conf(find_g95) +conf(g95_flags) +conf(g95_modifier_win32) +conf(g95_modifier_cygwin) +conf(g95_modifier_darwin) +conf(g95_modifier_platform) +conf(get_g95_version) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/gas.py jalv-1.0.0~dfsg0/waflib/Tools/gas.py --- jalv-0~svn3409/waflib/Tools/gas.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/gas.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,11 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.Tools.asm +from waflib.Tools import ar +def configure(conf): + conf.find_program(['gas','as','gcc'],var='AS') + conf.env.AS_TGT_F=['-o'] + conf.env.ASLNK_TGT_F=['-o'] + conf.find_ar() diff -Nru jalv-0~svn3409/waflib/Tools/gcc.py jalv-1.0.0~dfsg0/waflib/Tools/gcc.py --- jalv-0~svn3409/waflib/Tools/gcc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/gcc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,98 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib import Configure,Options,Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_gcc(conf): + cc=conf.find_program(['gcc','cc'],var='CC') + cc=conf.cmd_to_list(cc) + conf.get_cc_version(cc,gcc=True) + conf.env.CC_NAME='gcc' + conf.env.CC=cc +def gcc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']=[] + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Wl,-Bdynamic' + v['STLIB_MARKER']='-Wl,-Bstatic' + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-fPIC'] + v['LINKFLAGS_cshlib']=['-shared'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=['-Wl,-Bstatic'] + v['cstlib_PATTERN']='lib%s.a' + v['LINKFLAGS_MACBUNDLE']=['-bundle','-undefined','dynamic_lookup'] + v['CFLAGS_MACBUNDLE']=['-fPIC'] + v['macbundle_PATTERN']='%s.bundle' +def gcc_modifier_win32(conf): + v=conf.env + v['cprogram_PATTERN']='%s.exe' + v['cshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='lib%s.dll.a' + v['IMPLIB_ST']='-Wl,--out-implib,%s' + v['CFLAGS_cshlib']=[] + v.append_value('CFLAGS_cshlib',['-DDLL_EXPORT']) + v.append_value('LINKFLAGS',['-Wl,--enable-auto-import']) +def gcc_modifier_cygwin(conf): + gcc_modifier_win32(conf) + v=conf.env + v['cshlib_PATTERN']='cyg%s.dll' + v.append_value('LINKFLAGS_cshlib',['-Wl,--enable-auto-image-base']) + v['CFLAGS_cshlib']=[] +def gcc_modifier_darwin(conf): + v=conf.env + v['CFLAGS_cshlib']=['-fPIC','-compatibility_version','1','-current_version','1'] + v['LINKFLAGS_cshlib']=['-dynamiclib'] + v['cshlib_PATTERN']='lib%s.dylib' + v['FRAMEWORKPATH_ST']='-F%s' + v['FRAMEWORK_ST']=['-framework'] + v['ARCH_ST']=['-arch'] + v['LINKFLAGS_cstlib']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['SONAME_ST']=[] +def gcc_modifier_aix(conf): + v=conf.env + v['LINKFLAGS_cprogram']=['-Wl,-brtl'] + v['LINKFLAGS_cshlib']=['-shared','-Wl,-brtl,-bexpfull'] + v['SHLIB_MARKER']=[] +def gcc_modifier_hpux(conf): + v=conf.env + v['SHLIB_MARKER']=[] + v['CFLAGS_cshlib']=['-fPIC','-DPIC'] + v['cshlib_PATTERN']='lib%s.sl' +def gcc_modifier_platform(conf): + gcc_modifier_func=getattr(conf,'gcc_modifier_'+conf.env.DEST_OS,None) + if gcc_modifier_func: + gcc_modifier_func() +def configure(conf): + conf.find_gcc() + conf.find_ar() + conf.gcc_common_flags() + conf.gcc_modifier_platform() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() + +conf(find_gcc) +conf(gcc_common_flags) +conf(gcc_modifier_win32) +conf(gcc_modifier_cygwin) +conf(gcc_modifier_darwin) +conf(gcc_modifier_aix) +conf(gcc_modifier_hpux) +conf(gcc_modifier_platform) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/gdc.py jalv-1.0.0~dfsg0/waflib/Tools/gdc.py --- jalv-0~svn3409/waflib/Tools/gdc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/gdc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,34 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +from waflib.Tools import ar,d +from waflib.Configure import conf +def find_gdc(conf): + conf.find_program('gdc',var='D') +def common_flags_gdc(conf): + v=conf.env + v['DFLAGS']=[] + v['D_SRC_F']=['-c'] + v['D_TGT_F']='-o%s' + v['D_LINKER']=v['D'] + v['DLNK_SRC_F']='' + v['DLNK_TGT_F']='-o%s' + v['DINC_ST']='-I%s' + v['DSHLIB_MARKER']=v['DSTLIB_MARKER']='' + v['DSTLIB_ST']=v['DSHLIB_ST']='-l%s' + v['DSTLIBPATH_ST']=v['DLIBPATH_ST']='-L%s' + v['LINKFLAGS_dshlib']=['-shared'] + v['DHEADER_ext']='.di' + v.DFLAGS_d_with_header='-fintfc' + v['D_HDR_F']='-fintfc-file=%s' +def configure(conf): + conf.find_gdc() + conf.load('ar') + conf.load('d') + conf.common_flags_gdc() + conf.d_platform_flags() + +conf(find_gdc) +conf(common_flags_gdc) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/gfortran.py jalv-1.0.0~dfsg0/waflib/Tools/gfortran.py --- jalv-0~svn3409/waflib/Tools/gfortran.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/gfortran.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,69 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import re +from waflib import Utils +from waflib.Tools import fc,fc_config,fc_scan +from waflib.Configure import conf +def find_gfortran(conf): + fc=conf.find_program(['gfortran','g77'],var='FC') + fc=conf.cmd_to_list(fc) + conf.get_gfortran_version(fc) + conf.env.FC_NAME='GFORTRAN' +def gfortran_flags(conf): + v=conf.env + v['FCFLAGS_fcshlib']=['-fPIC'] + v['FORTRANMODFLAG']=['-J',''] + v['FCFLAGS_DEBUG']=['-Werror'] +def gfortran_modifier_win32(conf): + fc_config.fortran_modifier_win32(conf) +def gfortran_modifier_cygwin(conf): + fc_config.fortran_modifier_cygwin(conf) +def gfortran_modifier_darwin(conf): + fc_config.fortran_modifier_darwin(conf) +def gfortran_modifier_platform(conf): + dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform() + gfortran_modifier_func=getattr(conf,'gfortran_modifier_'+dest_os,None) + if gfortran_modifier_func: + gfortran_modifier_func() +def get_gfortran_version(conf,fc): + version_re=re.compile(r"GNU\s*Fortran",re.I).search + cmd=fc+['--version'] + out,err=fc_config.getoutput(conf,cmd,stdin=False) + if out:match=version_re(out) + else:match=version_re(err) + if not match: + conf.fatal('Could not determine the compiler type') + cmd=fc+['-dM','-E','-'] + out,err=fc_config.getoutput(conf,cmd,stdin=True) + if out.find('__GNUC__')<0: + conf.fatal('Could not determine the compiler type') + k={} + out=out.split('\n') + import shlex + for line in out: + lst=shlex.split(line) + if len(lst)>2: + key=lst[1] + val=lst[2] + k[key]=val + def isD(var): + return var in k + def isT(var): + return var in k and k[var]!='0' + conf.env['FC_VERSION']=(k['__GNUC__'],k['__GNUC_MINOR__'],k['__GNUC_PATCHLEVEL__']) +def configure(conf): + conf.find_gfortran() + conf.find_ar() + conf.fc_flags() + conf.gfortran_flags() + conf.gfortran_modifier_platform() + +conf(find_gfortran) +conf(gfortran_flags) +conf(gfortran_modifier_win32) +conf(gfortran_modifier_cygwin) +conf(gfortran_modifier_darwin) +conf(gfortran_modifier_platform) +conf(get_gfortran_version) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/glib2.py jalv-1.0.0~dfsg0/waflib/Tools/glib2.py --- jalv-0~svn3409/waflib/Tools/glib2.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/glib2.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,174 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Utils,Options,Errors,Logs +from waflib.TaskGen import taskgen_method,before_method,after_method,feature +def add_marshal_file(self,filename,prefix): + if not hasattr(self,'marshal_list'): + self.marshal_list=[] + self.meths.append('process_marshal') + self.marshal_list.append((filename,prefix)) +def process_marshal(self): + for f,prefix in getattr(self,'marshal_list',[]): + node=self.path.find_resource(f) + if not node: + raise Errors.WafError('file not found %r'%f) + h_node=node.change_ext('.h') + c_node=node.change_ext('.c') + task=self.create_task('glib_genmarshal',node,[h_node,c_node]) + task.env.GLIB_GENMARSHAL_PREFIX=prefix + self.source=self.to_nodes(getattr(self,'source',[])) + self.source.append(c_node) +class glib_genmarshal(Task.Task): + def run(self): + bld=self.inputs[0].__class__.ctx + get=self.env.get_flat + cmd1="%s %s --prefix=%s --header > %s"%(get('GLIB_GENMARSHAL'),self.inputs[0].srcpath(),get('GLIB_GENMARSHAL_PREFIX'),self.outputs[0].abspath()) + ret=bld.exec_command(cmd1) + if ret:return ret + c='''#include "%s"\n'''%self.outputs[0].name + self.outputs[1].write(c) + cmd2="%s %s --prefix=%s --body >> %s"%(get('GLIB_GENMARSHAL'),self.inputs[0].srcpath(),get('GLIB_GENMARSHAL_PREFIX'),self.outputs[1].abspath()) + return bld.exec_command(cmd2) + vars=['GLIB_GENMARSHAL_PREFIX','GLIB_GENMARSHAL'] + color='BLUE' + ext_out=['.h'] +def add_enums_from_template(self,source='',target='',template='',comments=''): + if not hasattr(self,'enums_list'): + self.enums_list=[] + self.meths.append('process_enums') + self.enums_list.append({'source':source,'target':target,'template':template,'file-head':'','file-prod':'','file-tail':'','enum-prod':'','value-head':'','value-prod':'','value-tail':'','comments':comments}) +def add_enums(self,source='',target='',file_head='',file_prod='',file_tail='',enum_prod='',value_head='',value_prod='',value_tail='',comments=''): + if not hasattr(self,'enums_list'): + self.enums_list=[] + self.meths.append('process_enums') + self.enums_list.append({'source':source,'template':'','target':target,'file-head':file_head,'file-prod':file_prod,'file-tail':file_tail,'enum-prod':enum_prod,'value-head':value_head,'value-prod':value_prod,'value-tail':value_tail,'comments':comments}) +def process_enums(self): + for enum in getattr(self,'enums_list',[]): + task=self.create_task('glib_mkenums') + env=task.env + inputs=[] + source_list=self.to_list(enum['source']) + if not source_list: + raise Errors.WafError('missing source '+str(enum)) + source_list=[self.path.find_resource(k)for k in source_list] + inputs+=source_list + env['GLIB_MKENUMS_SOURCE']=[k.abspath()for k in source_list] + if not enum['target']: + raise Errors.WafError('missing target '+str(enum)) + tgt_node=self.path.find_or_declare(enum['target']) + if tgt_node.name.endswith('.c'): + self.source.append(tgt_node) + env['GLIB_MKENUMS_TARGET']=tgt_node.abspath() + options=[] + if enum['template']: + template_node=self.path.find_resource(enum['template']) + options.append('--template %s'%(template_node.abspath())) + inputs.append(template_node) + params={'file-head':'--fhead','file-prod':'--fprod','file-tail':'--ftail','enum-prod':'--eprod','value-head':'--vhead','value-prod':'--vprod','value-tail':'--vtail','comments':'--comments'} + for param,option in params.items(): + if enum[param]: + options.append('%s %r'%(option,enum[param])) + env['GLIB_MKENUMS_OPTIONS']=' '.join(options) + task.set_inputs(inputs) + task.set_outputs(tgt_node) +class glib_mkenums(Task.Task): + run_str='${GLIB_MKENUMS} ${GLIB_MKENUMS_OPTIONS} ${GLIB_MKENUMS_SOURCE} > ${GLIB_MKENUMS_TARGET}' + color='PINK' + ext_out=['.h'] +def add_settings_schemas(self,filename_list): + if not hasattr(self,'settings_schema_files'): + self.settings_schema_files=[] + if not isinstance(filename_list,list): + filename_list=[filename_list] + self.settings_schema_files.extend(filename_list) +def add_settings_enums(self,namespace,filename_list): + if hasattr(self,'settings_enum_namespace'): + raise Errors.WafError("Tried to add gsettings enums to '%s' more than once"%self.name) + self.settings_enum_namespace=namespace + if type(filename_list)!='list': + filename_list=[filename_list] + self.settings_enum_files=filename_list +def r_change_ext(self,ext): + name=self.name + k=name.rfind('.') + if k>=0: + name=name[:k]+ext + else: + name=name+ext + return self.parent.find_or_declare([name]) +def process_settings(self): + enums_tgt_node=[] + install_files=[] + settings_schema_files=getattr(self,'settings_schema_files',[]) + if settings_schema_files and not self.env['GLIB_COMPILE_SCHEMAS']: + raise Errors.WafError("Unable to process GSettings schemas - glib-compile-schemas was not found during configure") + if hasattr(self,'settings_enum_files'): + enums_task=self.create_task('glib_mkenums') + source_list=self.settings_enum_files + source_list=[self.path.find_resource(k)for k in source_list] + enums_task.set_inputs(source_list) + enums_task.env['GLIB_MKENUMS_SOURCE']=[k.abspath()for k in source_list] + target=self.settings_enum_namespace+'.enums.xml' + tgt_node=self.path.find_or_declare(target) + enums_task.set_outputs(tgt_node) + enums_task.env['GLIB_MKENUMS_TARGET']=tgt_node.abspath() + enums_tgt_node=[tgt_node] + install_files.append(tgt_node) + options='--comments "" --fhead "" --vhead " <@type@ id=\\"%s.@EnumName@\\">" --vprod " " --vtail " " --ftail "" '%(self.settings_enum_namespace) + enums_task.env['GLIB_MKENUMS_OPTIONS']=options + for schema in settings_schema_files: + schema_task=self.create_task('glib_validate_schema') + schema_node=self.path.find_resource(schema) + if not schema_node: + raise Errors.WafError("Cannot find the schema file '%s'"%schema) + install_files.append(schema_node) + source_list=enums_tgt_node+[schema_node] + schema_task.set_inputs(source_list) + schema_task.env['GLIB_COMPILE_SCHEMAS_OPTIONS']=[("--schema-file="+k.abspath())for k in source_list] + target_node=r_change_ext(schema_node,'.xml.valid') + schema_task.set_outputs(target_node) + schema_task.env['GLIB_VALIDATE_SCHEMA_OUTPUT']=target_node.abspath() + def compile_schemas_callback(bld): + if not bld.is_install:return + Logs.pprint('YELLOW','Updating GSettings schema cache') + command=Utils.subst_vars("${GLIB_COMPILE_SCHEMAS} ${GSETTINGSSCHEMADIR}",bld.env) + ret=self.bld.exec_command(command) + if self.bld.is_install: + if not self.env['GSETTINGSSCHEMADIR']: + raise Errors.WafError('GSETTINGSSCHEMADIR not defined (should have been set up automatically during configure)') + if install_files: + self.bld.install_files(self.env['GSETTINGSSCHEMADIR'],install_files) + if not hasattr(self.bld,'_compile_schemas_registered'): + self.bld.add_post_fun(compile_schemas_callback) + self.bld._compile_schemas_registered=True +class glib_validate_schema(Task.Task): + run_str='rm -f ${GLIB_VALIDATE_SCHEMA_OUTPUT} && ${GLIB_COMPILE_SCHEMAS} --dry-run ${GLIB_COMPILE_SCHEMAS_OPTIONS} && touch ${GLIB_VALIDATE_SCHEMA_OUTPUT}' + color='PINK' +def configure(conf): + conf.find_program('glib-genmarshal',var='GLIB_GENMARSHAL') + conf.find_perl_program('glib-mkenums',var='GLIB_MKENUMS') + conf.find_program('glib-compile-schemas',var='GLIB_COMPILE_SCHEMAS',mandatory=False) + def getstr(varname): + return getattr(Options.options,varname,getattr(conf.env,varname,'')) + gsettingsschemadir=getstr('GSETTINGSSCHEMADIR') + if not gsettingsschemadir: + datadir=getstr('DATADIR') + if not datadir: + prefix=conf.env['PREFIX'] + datadir=os.path.join(prefix,'share') + gsettingsschemadir=os.path.join(datadir,'glib-2.0','schemas') + conf.env['GSETTINGSSCHEMADIR']=gsettingsschemadir +def options(opt): + opt.add_option('--gsettingsschemadir',help='GSettings schema location [Default: ${datadir}/glib-2.0/schemas]',default='',dest='GSETTINGSSCHEMADIR') + +taskgen_method(add_marshal_file) +before_method('process_source')(process_marshal) +taskgen_method(add_enums_from_template) +taskgen_method(add_enums) +before_method('process_source')(process_enums) +taskgen_method(add_settings_schemas) +taskgen_method(add_settings_enums) +feature('glib2')(process_settings) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/gnu_dirs.py jalv-1.0.0~dfsg0/waflib/Tools/gnu_dirs.py --- jalv-0~svn3409/waflib/Tools/gnu_dirs.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/gnu_dirs.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,65 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils,Options,Context +_options=[x.split(', ')for x in''' +bindir, user executables, ${EXEC_PREFIX}/bin +sbindir, system admin executables, ${EXEC_PREFIX}/sbin +libexecdir, program executables, ${EXEC_PREFIX}/libexec +sysconfdir, read-only single-machine data, ${PREFIX}/etc +sharedstatedir, modifiable architecture-independent data, ${PREFIX}/com +localstatedir, modifiable single-machine data, ${PREFIX}/var +libdir, object code libraries, ${EXEC_PREFIX}/lib +includedir, C header files, ${PREFIX}/include +oldincludedir, C header files for non-gcc, /usr/include +datarootdir, read-only arch.-independent data root, ${PREFIX}/share +datadir, read-only architecture-independent data, ${DATAROOTDIR} +infodir, info documentation, ${DATAROOTDIR}/info +localedir, locale-dependent data, ${DATAROOTDIR}/locale +mandir, man documentation, ${DATAROOTDIR}/man +docdir, documentation root, ${DATAROOTDIR}/doc/${PACKAGE} +htmldir, html documentation, ${DOCDIR} +dvidir, dvi documentation, ${DOCDIR} +pdfdir, pdf documentation, ${DOCDIR} +psdir, ps documentation, ${DOCDIR} +'''.split('\n')if x] +def configure(conf): + def get_param(varname,default): + return getattr(Options.options,varname,'')or default + env=conf.env + conf.env.LIBDIR=conf.env.BINDIR=[] + env['EXEC_PREFIX']=get_param('EXEC_PREFIX',env['PREFIX']) + env['PACKAGE']=getattr(Context.g_module,'APPNAME',None)or env['PACKAGE'] + complete=False + iter=0 + while not complete and iter\d*)\.(?P\d*)",re.I).search + cmd=fc+['--version'] + out,err=fc_config.getoutput(conf,cmd,stdin=False) + if out: + match=version_re(out) + else: + match=version_re(err) + if not match: + conf.fatal('cannot determine ifort version.') + k=match.groupdict() + conf.env['FC_VERSION']=(k['major'],k['minor']) +def configure(conf): + conf.find_ifort() + conf.find_ar() + conf.fc_flags() + conf.ifort_modifier_platform() + +conf(find_ifort) +conf(ifort_modifier_cygwin) +conf(ifort_modifier_win32) +conf(ifort_modifier_darwin) +conf(ifort_modifier_platform) +conf(get_ifort_version) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/__init__.py jalv-1.0.0~dfsg0/waflib/Tools/__init__.py --- jalv-0~svn3409/waflib/Tools/__init__.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/__init__.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,4 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + diff -Nru jalv-0~svn3409/waflib/Tools/intltool.py jalv-1.0.0~dfsg0/waflib/Tools/intltool.py --- jalv-0~svn3409/waflib/Tools/intltool.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/intltool.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,78 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re +from waflib import Configure,TaskGen,Task,Utils,Runner,Options,Build,Logs +import waflib.Tools.ccroot +from waflib.TaskGen import feature,before_method +from waflib.Logs import error +def apply_intltool_in_f(self): + try:self.meths.remove('process_source') + except ValueError:pass + if not self.env.LOCALEDIR: + self.env.LOCALEDIR=self.env.PREFIX+'/share/locale' + for i in self.to_list(self.source): + node=self.path.find_resource(i) + podir=getattr(self,'podir','po') + podirnode=self.path.find_dir(podir) + if not podirnode: + error("could not find the podir %r"%podir) + continue + cache=getattr(self,'intlcache','.intlcache') + self.env['INTLCACHE']=os.path.join(self.path.bldpath(),podir,cache) + self.env['INTLPODIR']=podirnode.bldpath() + self.env['INTLFLAGS']=getattr(self,'flags',['-q','-u','-c']) + task=self.create_task('intltool',node,node.change_ext('')) + inst=getattr(self,'install_path','${LOCALEDIR}') + if inst: + self.bld.install_files(inst,task.outputs) +def apply_intltool_po(self): + try:self.meths.remove('process_source') + except ValueError:pass + if not self.env.LOCALEDIR: + self.env.LOCALEDIR=self.env.PREFIX+'/share/locale' + appname=getattr(self,'appname','set_your_app_name') + podir=getattr(self,'podir','') + inst=getattr(self,'install_path','${LOCALEDIR}') + linguas=self.path.find_node(os.path.join(podir,'LINGUAS')) + if linguas: + file=open(linguas.abspath()) + langs=[] + for line in file.readlines(): + if not line.startswith('#'): + langs+=line.split() + file.close() + re_linguas=re.compile('[-a-zA-Z_@.]+') + for lang in langs: + if re_linguas.match(lang): + node=self.path.find_resource(os.path.join(podir,re_linguas.match(lang).group()+'.po')) + task=self.create_task('po',node,node.change_ext('.mo')) + if inst: + filename=task.outputs[0].name + (langname,ext)=os.path.splitext(filename) + inst_file=inst+os.sep+langname+os.sep+'LC_MESSAGES'+os.sep+appname+'.mo' + self.bld.install_as(inst_file,task.outputs[0],chmod=getattr(self,'chmod',Utils.O644),env=task.env) + else: + Logs.pprint('RED',"Error no LINGUAS file found in po directory") +class po(Task.Task): + run_str='${MSGFMT} -o ${TGT} ${SRC}' + color='BLUE' +class intltool(Task.Task): + run_str='${INTLTOOL} ${INTLFLAGS} ${INTLCACHE} ${INTLPODIR} ${SRC} ${TGT}' + color='BLUE' +def configure(conf): + conf.find_program('msgfmt',var='MSGFMT') + conf.find_perl_program('intltool-merge',var='INTLTOOL') + prefix=conf.env.PREFIX + datadir=conf.env.DATADIR + if not datadir: + datadir=os.path.join(prefix,'share') + conf.define('LOCALEDIR',os.path.join(datadir,'locale').replace('\\','\\\\')) + conf.define('DATADIR',datadir.replace('\\','\\\\')) + if conf.env.CC or conf.env.CXX: + conf.check(header_name='locale.h') + +before_method('process_source')(apply_intltool_in_f) +feature('intltool_in')(apply_intltool_in_f) +feature('intltool_po')(apply_intltool_po) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/irixcc.py jalv-1.0.0~dfsg0/waflib/Tools/irixcc.py --- jalv-0~svn3409/waflib/Tools/irixcc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/irixcc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,49 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_irixcc(conf): + v=conf.env + cc=None + if v['CC']:cc=v['CC'] + elif'CC'in conf.environ:cc=conf.environ['CC'] + if not cc:cc=conf.find_program('cc',var='CC') + if not cc:conf.fatal('irixcc was not found') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-version']) + except: + conf.fatal('%r -version could not be executed'%cc) + v['CC']=cc + v['CC_NAME']='irix' +def irixcc_common_flags(conf): + v=conf.env + v['CC_SRC_F']='' + v['CC_TGT_F']=['-c','-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']='' + v['CCLNK_TGT_F']=['-o'] + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['cprogram_PATTERN']='%s' + v['cshlib_PATTERN']='lib%s.so' + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_irixcc() + conf.find_cpp() + conf.find_ar() + conf.irixcc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() + +conf(find_irixcc) +conf(irixcc_common_flags) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/javaw.py jalv-1.0.0~dfsg0/waflib/Tools/javaw.py --- jalv-0~svn3409/waflib/Tools/javaw.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/javaw.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,276 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +import os,re,tempfile +from waflib.Configure import conf +from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node,Logs +from waflib.TaskGen import feature,before_method,after_method +from waflib.Tools import ccroot +ccroot.USELIB_VARS['javac']=set(['CLASSPATH','JAVACFLAGS']) +SOURCE_RE='**/*.java' +JAR_RE='**/*' +class_check_source=''' +public class Test { + public static void main(String[] argv) { + Class lib; + if (argv.length < 1) { + System.err.println("Missing argument"); + System.exit(77); + } + try { + lib = Class.forName(argv[0]); + } catch (ClassNotFoundException e) { + System.err.println("ClassNotFoundException"); + System.exit(1); + } + lib = null; + System.exit(0); + } +} +''' +def apply_java(self): + Utils.def_attrs(self,jarname='',classpath='',sourcepath='.',srcdir='.',jar_mf_attributes={},jar_mf_classpath=[]) + nodes_lst=[] + outdir=getattr(self,'outdir',None) + if outdir: + if not isinstance(outdir,Node.Node): + outdir=self.path.get_bld().make_node(self.outdir) + else: + outdir=self.path.get_bld() + outdir.mkdir() + self.outdir=outdir + self.env['OUTDIR']=outdir.abspath() + self.javac_task=tsk=self.create_task('javac') + tmp=[] + srcdir=getattr(self,'srcdir','') + if isinstance(srcdir,Node.Node): + srcdir=[srcdir] + for x in Utils.to_list(srcdir): + if isinstance(x,Node.Node): + y=x + else: + y=self.path.find_dir(x) + if not y: + self.bld.fatal('Could not find the folder %s from %s'%(x,self.path)) + tmp.append(y) + tsk.srcdir=tmp + if getattr(self,'compat',None): + tsk.env.append_value('JAVACFLAGS',['-source',self.compat]) + if hasattr(self,'sourcepath'): + fold=[isinstance(x,Node.Node)and x or self.path.find_dir(x)for x in self.to_list(self.sourcepath)] + names=os.pathsep.join([x.srcpath()for x in fold]) + else: + names=[x.srcpath()for x in tsk.srcdir] + if names: + tsk.env.append_value('JAVACFLAGS',['-sourcepath',names]) +def use_javac_files(self): + lst=[] + self.uselib=self.to_list(getattr(self,'uselib',[])) + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except: + self.uselib.append(x) + else: + y.post() + lst.append(y.jar_task.outputs[0].abspath()) + self.javac_task.set_run_after(y.jar_task) + if lst: + self.env.append_value('CLASSPATH',lst) +def set_classpath(self): + self.env.append_value('CLASSPATH',getattr(self,'classpath',[])) + for x in self.tasks: + x.env.CLASSPATH=os.pathsep.join(self.env.CLASSPATH)+os.pathsep +def jar_files(self): + destfile=getattr(self,'destfile','test.jar') + jaropts=getattr(self,'jaropts',[]) + manifest=getattr(self,'manifest',None) + basedir=getattr(self,'basedir',None) + if basedir: + if not isinstance(self.basedir,Node.Node): + basedir=self.path.get_bld().make_node(basedir) + else: + basedir=self.path.get_bld() + if not basedir: + self.bld.fatal('Could not find the basedir %r for %r'%(self.basedir,self)) + self.jar_task=tsk=self.create_task('jar_create') + if manifest: + jarcreate=getattr(self,'jarcreate','cfm') + node=self.path.find_node(manifest) + tsk.dep_nodes.append(node) + jaropts.insert(0,node.abspath()) + else: + jarcreate=getattr(self,'jarcreate','cf') + if not isinstance(destfile,Node.Node): + destfile=self.path.find_or_declare(destfile) + if not destfile: + self.bld.fatal('invalid destfile %r for %r'%(destfile,self)) + tsk.set_outputs(destfile) + tsk.basedir=basedir + jaropts.append('-C') + jaropts.append(basedir.bldpath()) + jaropts.append('.') + tsk.env['JAROPTS']=jaropts + tsk.env['JARCREATE']=jarcreate + if getattr(self,'javac_task',None): + tsk.set_run_after(self.javac_task) +def use_jar_files(self): + lst=[] + self.uselib=self.to_list(getattr(self,'uselib',[])) + names=self.to_list(getattr(self,'use',[])) + get=self.bld.get_tgen_by_name + for x in names: + try: + y=get(x) + except: + self.uselib.append(x) + else: + y.post() + self.jar_task.run_after.update(y.tasks) +class jar_create(Task.Task): + color='GREEN' + run_str='${JAR} ${JARCREATE} ${TGT} ${JAROPTS}' + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + if not self.inputs: + global JAR_RE + try: + self.inputs=[x for x in self.basedir.ant_glob(JAR_RE,remove=False)if id(x)!=id(self.outputs[0])] + except: + raise Errors.WafError('Could not find the basedir %r for %r'%(self.basedir,self)) + return super(jar_create,self).runnable_status() +class javac(Task.Task): + color='BLUE' + nocache=True + vars=['CLASSPATH','JAVACFLAGS','JAVAC','OUTDIR'] + def runnable_status(self): + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + if not self.inputs: + global SOURCE_RE + self.inputs=[] + for x in self.srcdir: + self.inputs.extend(x.ant_glob(SOURCE_RE,remove=False)) + return super(javac,self).runnable_status() + def run(self): + env=self.env + gen=self.generator + bld=gen.bld + wd=bld.bldnode.abspath() + def to_list(xx): + if isinstance(xx,str):return[xx] + return xx + cmd=[] + cmd.extend(to_list(env['JAVAC'])) + cmd.extend(['-classpath']) + cmd.extend(to_list(env['CLASSPATH'])) + cmd.extend(['-d']) + cmd.extend(to_list(env['OUTDIR'])) + cmd.extend(to_list(env['JAVACFLAGS'])) + files=[a.path_from(bld.bldnode)for a in self.inputs] + tmp=None + try: + if len(str(files))+len(str(cmd))>8192: + (fd,tmp)=tempfile.mkstemp(dir=bld.bldnode.abspath()) + try: + os.write(fd,'\n'.join(files)) + finally: + if tmp: + os.close(fd) + if Logs.verbose: + Logs.debug('runner: %r'%(cmd+files)) + cmd.append('@'+tmp) + else: + cmd+=files + ret=self.exec_command(cmd,cwd=wd,env=env.env or None) + finally: + if tmp: + os.unlink(tmp) + return ret + def post_run(self): + for n in self.generator.outdir.ant_glob('**/*.class'): + n.sig=Utils.h_file(n.abspath()) + self.generator.bld.task_sigs[self.uid()]=self.cache_sig +def configure(self): + java_path=self.environ['PATH'].split(os.pathsep) + v=self.env + if'JAVA_HOME'in self.environ: + java_path=[os.path.join(self.environ['JAVA_HOME'],'bin')]+java_path + self.env['JAVA_HOME']=[self.environ['JAVA_HOME']] + for x in'javac java jar'.split(): + self.find_program(x,var=x.upper(),path_list=java_path) + self.env[x.upper()]=self.cmd_to_list(self.env[x.upper()]) + if'CLASSPATH'in self.environ: + v['CLASSPATH']=self.environ['CLASSPATH'] + if not v['JAR']:self.fatal('jar is required for making java packages') + if not v['JAVAC']:self.fatal('javac is required for compiling java classes') + v['JARCREATE']='cf' + v['JAVACFLAGS']=[] +def check_java_class(self,classname,with_classpath=None): + import shutil + javatestdir='.waf-javatest' + classpath=javatestdir + if self.env['CLASSPATH']: + classpath+=os.pathsep+self.env['CLASSPATH'] + if isinstance(with_classpath,str): + classpath+=os.pathsep+with_classpath + shutil.rmtree(javatestdir,True) + os.mkdir(javatestdir) + java_file=open(os.path.join(javatestdir,'Test.java'),'w') + java_file.write(class_check_source) + java_file.close() + self.exec_command(self.env['JAVAC']+[os.path.join(javatestdir,'Test.java')],shell=False) + cmd=self.env['JAVA']+['-cp',classpath,'Test',classname] + self.to_log("%s\n"%str(cmd)) + found=self.exec_command(cmd,shell=False) + self.msg('Checking for java class %s'%classname,not found) + shutil.rmtree(javatestdir,True) + return found +def check_jni_headers(conf): + if not conf.env.CC_NAME and not conf.env.CXX_NAME: + conf.fatal('load a compiler first (gcc, g++, ..)') + if not conf.env.JAVA_HOME: + conf.fatal('set JAVA_HOME in the system environment') + javaHome=conf.env['JAVA_HOME'][0] + dir=conf.root.find_dir(conf.env.JAVA_HOME[0]+'/include') + if dir is None: + conf.fatal('JAVA_HOME does not seem to be set properly') + f=dir.ant_glob('**/(jni|jni_md).h') + incDirs=[x.parent.abspath()for x in f] + dir=conf.root.find_dir(conf.env.JAVA_HOME[0]) + f=dir.ant_glob('**/*jvm.(so|dll|dylib)') + libDirs=[x.parent.abspath()for x in f]or[javaHome] + f=dir.ant_glob('**/*jvm.(lib)') + if f: + libDirs=[[x,y.parent.abspath()]for x in libDirs for y in f] + for d in libDirs: + try: + conf.check(header_name='jni.h',define_name='HAVE_JNI_H',lib='jvm',libpath=d,includes=incDirs,uselib_store='JAVA',uselib='JAVA') + except: + pass + else: + break + else: + conf.fatal('could not find lib jvm in %r (see config.log)'%libDirs) + +feature('javac')(apply_java) +before_method('process_source')(apply_java) +feature('javac')(use_javac_files) +after_method('apply_java')(use_javac_files) +feature('javac')(set_classpath) +after_method('apply_java','propagate_uselib_vars','use_javac_files')(set_classpath) +feature('jar')(jar_files) +after_method('apply_java','use_javac_files')(jar_files) +before_method('process_source')(jar_files) +feature('jar')(use_jar_files) +after_method('jar_files')(use_jar_files) +conf(check_java_class) +conf(check_jni_headers) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/kde4.py jalv-1.0.0~dfsg0/waflib/Tools/kde4.py --- jalv-0~svn3409/waflib/Tools/kde4.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/kde4.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,49 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,re +from waflib import Options,TaskGen,Task,Utils +from waflib.TaskGen import feature,after_method +def apply_msgfmt(self): + for lang in self.to_list(self.langs): + node=self.path.find_resource(lang+'.po') + task=self.create_task('msgfmt',node,node.change_ext('.mo')) + langname=lang.split('/') + langname=langname[-1] + inst=getattr(self,'install_path','${KDE4_LOCALE_INSTALL_DIR}') + self.bld.install_as(inst+os.sep+langname+os.sep+'LC_MESSAGES'+os.sep+getattr(self,'appname','set_your_appname')+'.mo',task.outputs[0],chmod=getattr(self,'chmod',Utils.O644)) +class msgfmt(Task.Task): + color='BLUE' + run_str='${MSGFMT} ${SRC} -o ${TGT}' +def configure(self): + kdeconfig=self.find_program('kde4-config') + prefix=self.cmd_and_log('%s --prefix'%kdeconfig).strip() + fname='%s/share/apps/cmake/modules/KDELibsDependencies.cmake'%prefix + try:os.stat(fname) + except OSError: + fname='%s/share/kde4/apps/cmake/modules/KDELibsDependencies.cmake'%prefix + try:os.stat(fname) + except OSError:self.fatal('could not open %s'%fname) + try: + txt=Utils.readf(fname) + except(OSError,IOError): + self.fatal('could not read %s'%fname) + txt=txt.replace('\\\n','\n') + fu=re.compile('#(.*)\n') + txt=fu.sub('',txt) + setregexp=re.compile('([sS][eE][tT]\s*\()\s*([^\s]+)\s+\"([^"]+)\"\)') + found=setregexp.findall(txt) + for(_,key,val)in found: + self.env[key]=val + self.env['LIB_KDECORE']=['kdecore'] + self.env['LIB_KDEUI']=['kdeui'] + self.env['LIB_KIO']=['kio'] + self.env['LIB_KHTML']=['khtml'] + self.env['LIB_KPARTS']=['kparts'] + self.env['LIBPATH_KDECORE']=[self.env['KDE4_LIB_INSTALL_DIR']] + self.env['INCLUDES_KDECORE']=[self.env['KDE4_INCLUDE_INSTALL_DIR']] + self.env.append_value('INCLUDES_KDECORE',[self.env['KDE4_INCLUDE_INSTALL_DIR']+os.sep+'KDE']) + self.find_program('msgfmt',var='MSGFMT') + +feature('msgfmt')(apply_msgfmt) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/lua.py jalv-1.0.0~dfsg0/waflib/Tools/lua.py --- jalv-0~svn3409/waflib/Tools/lua.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/lua.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,19 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.TaskGen import extension +from waflib import Task,Utils +def add_lua(self,node): + tsk=self.create_task('luac',node,node.change_ext('.luac')) + inst_to=getattr(self,'install_path',self.env.LUADIR and'${LUADIR}'or None) + if inst_to: + self.bld.install_files(inst_to,tsk.outputs) + return tsk +class luac(Task.Task): + run_str='${LUAC} -s -o ${TGT} ${SRC}' + color='PINK' +def configure(conf): + conf.find_program('luac',var='LUAC') + +extension('.lua')(add_lua) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/msvc.py jalv-1.0.0~dfsg0/waflib/Tools/msvc.py --- jalv-0~svn3409/waflib/Tools/msvc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/msvc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,654 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,re,tempfile +try: + import _winreg +except: + try: + import winreg as _winreg + except: + _winreg=None +from waflib import Utils,TaskGen,Runner,Configure,Task,Options +from waflib.Logs import debug,info,warn,error +from waflib.TaskGen import after_method,before_method,feature +from waflib.Configure import conf +from waflib.Tools import ccroot,c,cxx,ar,winres +g_msvc_systemlibs=''' +aclui activeds ad1 adptif adsiid advapi32 asycfilt authz bhsupp bits bufferoverflowu cabinet +cap certadm certidl ciuuid clusapi comctl32 comdlg32 comsupp comsuppd comsuppw comsuppwd comsvcs +credui crypt32 cryptnet cryptui d3d8thk daouuid dbgeng dbghelp dciman32 ddao35 ddao35d +ddao35u ddao35ud delayimp dhcpcsvc dhcpsapi dlcapi dnsapi dsprop dsuiext dtchelp +faultrep fcachdll fci fdi framedyd framedyn gdi32 gdiplus glauxglu32 gpedit gpmuuid +gtrts32w gtrtst32hlink htmlhelp httpapi icm32 icmui imagehlp imm32 iphlpapi iprop +kernel32 ksguid ksproxy ksuser libcmt libcmtd libcpmt libcpmtd loadperf lz32 mapi +mapi32 mgmtapi minidump mmc mobsync mpr mprapi mqoa mqrt msacm32 mscms mscoree +msdasc msimg32 msrating mstask msvcmrt msvcurt msvcurtd mswsock msxml2 mtx mtxdm +netapi32 nmapinmsupp npptools ntdsapi ntdsbcli ntmsapi ntquery odbc32 odbcbcp +odbccp32 oldnames ole32 oleacc oleaut32 oledb oledlgolepro32 opends60 opengl32 +osptk parser pdh penter pgobootrun pgort powrprof psapi ptrustm ptrustmd ptrustu +ptrustud qosname rasapi32 rasdlg rassapi resutils riched20 rpcndr rpcns4 rpcrt4 rtm +rtutils runtmchk scarddlg scrnsave scrnsavw secur32 sensapi setupapi sfc shell32 +shfolder shlwapi sisbkup snmpapi sporder srclient sti strsafe svcguid tapi32 thunk32 +traffic unicows url urlmon user32 userenv usp10 uuid uxtheme vcomp vcompd vdmdbg +version vfw32 wbemuuid webpost wiaguid wininet winmm winscard winspool winstrm +wintrust wldap32 wmiutils wow32 ws2_32 wsnmp32 wsock32 wst wtsapi32 xaswitch xolehlp +'''.split() +all_msvc_platforms=[('x64','amd64'),('x86','x86'),('ia64','ia64'),('x86_amd64','amd64'),('x86_ia64','ia64')] +all_wince_platforms=[('armv4','arm'),('armv4i','arm'),('mipsii','mips'),('mipsii_fp','mips'),('mipsiv','mips'),('mipsiv_fp','mips'),('sh4','sh'),('x86','cex86')] +all_icl_platforms=[('intel64','amd64'),('em64t','amd64'),('ia32','x86'),('Itanium','ia64')] +def options(opt): + opt.add_option('--msvc_version',type='string',help='msvc version, eg: "msvc 10.0,msvc 9.0"',default='') + opt.add_option('--msvc_targets',type='string',help='msvc targets, eg: "x64,arm"',default='') +def setup_msvc(conf,versions): + platforms=getattr(Options.options,'msvc_targets','').split(',') + if platforms==['']: + platforms=Utils.to_list(conf.env['MSVC_TARGETS'])or[i for i,j in all_msvc_platforms+all_icl_platforms+all_wince_platforms] + desired_versions=getattr(Options.options,'msvc_version','').split(',') + if desired_versions==['']: + desired_versions=conf.env['MSVC_VERSIONS']or[v for v,_ in versions][::-1] + versiondict=dict(versions) + for version in desired_versions: + try: + targets=dict(versiondict[version]) + for target in platforms: + try: + arch,(p1,p2,p3)=targets[target] + compiler,revision=version.rsplit(' ',1) + return compiler,revision,p1,p2,p3 + except KeyError:continue + except KeyError:continue + conf.fatal('msvc: Impossible to find a valid architecture for building (in setup_msvc)') +def get_msvc_version(conf,compiler,version,target,vcvars): + debug('msvc: get_msvc_version: %r %r %r',compiler,version,target) + batfile=conf.bldnode.make_node('waf-print-msvc.bat') + batfile.write("""@echo off +set INCLUDE= +set LIB= +call "%s" %s +echo PATH=%%PATH%% +echo INCLUDE=%%INCLUDE%% +echo LIB=%%LIB%% +"""%(vcvars,target)) + sout=conf.cmd_and_log(['cmd','/E:on','/V:on','/C',batfile.abspath()]) + lines=sout.splitlines() + if not lines[0]:lines=lines[1:] + for x in('Setting environment','Setting SDK environment','Intel(R) C++ Compiler','Intel Parallel Studio'): + if lines[0].find(x)!=-1: + break + else: + debug('msvc: get_msvc_version: %r %r %r -> not found',compiler,version,target) + conf.fatal('msvc: Impossible to find a valid architecture for building (in get_msvc_version)') + for line in lines[1:]: + if line.startswith('PATH='): + path=line[5:] + MSVC_PATH=path.split(';') + elif line.startswith('INCLUDE='): + MSVC_INCDIR=[i for i in line[8:].split(';')if i] + elif line.startswith('LIB='): + MSVC_LIBDIR=[i for i in line[4:].split(';')if i] + env={} + env.update(os.environ) + env.update(PATH=path) + compiler_name,linker_name,lib_name=_get_prog_names(conf,compiler) + cxx=conf.find_program(compiler_name,path_list=MSVC_PATH) + cxx=conf.cmd_to_list(cxx) + if'CL'in env: + del(env['CL']) + try: + try: + conf.cmd_and_log(cxx+['/help'],env=env) + except Exception ,e: + debug('msvc: get_msvc_version: %r %r %r -> failure'%(compiler,version,target)) + debug(str(e)) + conf.fatal('msvc: cannot run the compiler (in get_msvc_version)') + else: + debug('msvc: get_msvc_version: %r %r %r -> OK',compiler,version,target) + finally: + conf.env[compiler_name]='' + return(MSVC_PATH,MSVC_INCDIR,MSVC_LIBDIR) +def gather_wsdk_versions(conf,versions): + version_pattern=re.compile('^v..?.?\...?.?') + try: + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Microsoft\\Microsoft SDKs\\Windows') + except WindowsError: + try: + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Microsoft\\Microsoft SDKs\\Windows') + except WindowsError: + return + index=0 + while 1: + try: + version=_winreg.EnumKey(all_versions,index) + except WindowsError: + break + index=index+1 + if not version_pattern.match(version): + continue + try: + msvc_version=_winreg.OpenKey(all_versions,version) + path,type=_winreg.QueryValueEx(msvc_version,'InstallationFolder') + except WindowsError: + continue + if os.path.isfile(os.path.join(path,'bin','SetEnv.cmd')): + targets=[] + for target,arch in all_msvc_platforms: + try: + targets.append((target,(arch,conf.get_msvc_version('wsdk',version,'/'+target,os.path.join(path,'bin','SetEnv.cmd'))))) + except conf.errors.ConfigurationError: + pass + versions.append(('wsdk '+version[1:],targets)) +def gather_wince_supported_platforms(): + supported_wince_platforms=[] + try: + ce_sdk=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Microsoft\\Windows CE Tools\\SDKs') + except WindowsError: + try: + ce_sdk=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Microsoft\\Windows CE Tools\\SDKs') + except WindowsError: + ce_sdk='' + if not ce_sdk: + return supported_wince_platforms + ce_index=0 + while 1: + try: + sdk_device=_winreg.EnumKey(ce_sdk,ce_index) + except WindowsError: + break + ce_index=ce_index+1 + sdk=_winreg.OpenKey(ce_sdk,sdk_device) + try: + path,type=_winreg.QueryValueEx(sdk,'SDKRootDir') + except WindowsError: + try: + path,type=_winreg.QueryValueEx(sdk,'SDKInformation') + path,xml=os.path.split(path) + except WindowsError: + continue + path=str(path) + path,device=os.path.split(path) + if not device: + path,device=os.path.split(path) + for arch,compiler in all_wince_platforms: + platforms=[] + if os.path.isdir(os.path.join(path,device,'Lib',arch)): + platforms.append((arch,compiler,os.path.join(path,device,'Include',arch),os.path.join(path,device,'Lib',arch))) + if platforms: + supported_wince_platforms.append((device,platforms)) + return supported_wince_platforms +def gather_msvc_detected_versions(): + version_pattern=re.compile('^(\d\d?\.\d\d?)(Exp)?$') + detected_versions=[] + for vcver,vcvar in[('VCExpress','Exp'),('VisualStudio','')]: + try: + prefix='SOFTWARE\\Wow6432node\\Microsoft\\'+vcver + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,prefix) + except WindowsError: + try: + prefix='SOFTWARE\\Microsoft\\'+vcver + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,prefix) + except WindowsError: + continue + index=0 + while 1: + try: + version=_winreg.EnumKey(all_versions,index) + except WindowsError: + break + index=index+1 + match=version_pattern.match(version) + if not match: + continue + else: + versionnumber=float(match.group(1)) + detected_versions.append((versionnumber,version+vcvar,prefix+"\\"+version)) + def fun(tup): + return tup[0] + try: + detected_versions.sort(key=fun) + except: + detected_versions.sort(lambda x,y:cmp(x[0],y[0])) + return detected_versions +def gather_msvc_targets(conf,versions,version,vc_path): + targets=[] + if os.path.isfile(os.path.join(vc_path,'vcvarsall.bat')): + for target,realtarget in all_msvc_platforms[::-1]: + try: + targets.append((target,(realtarget,conf.get_msvc_version('msvc',version,target,os.path.join(vc_path,'vcvarsall.bat'))))) + except conf.errors.ConfigurationError: + pass + elif os.path.isfile(os.path.join(vc_path,'Common7','Tools','vsvars32.bat')): + try: + targets.append(('x86',('x86',conf.get_msvc_version('msvc',version,'x86',os.path.join(vc_path,'Common7','Tools','vsvars32.bat'))))) + except conf.errors.ConfigurationError: + pass + elif os.path.isfile(os.path.join(vc_path,'Bin','vcvars32.bat')): + try: + targets.append(('x86',('x86',conf.get_msvc_version('msvc',version,'',os.path.join(vc_path,'Bin','vcvars32.bat'))))) + except conf.errors.ConfigurationError: + pass + versions.append(('msvc '+version,targets)) +def gather_wince_targets(conf,versions,version,vc_path,vsvars,supported_platforms): + for device,platforms in supported_platforms: + cetargets=[] + for platform,compiler,include,lib in platforms: + winCEpath=os.path.join(vc_path,'ce') + if not os.path.isdir(winCEpath): + continue + try: + common_bindirs,_1,_2=conf.get_msvc_version('msvc',version,'x86',vsvars) + except conf.errors.ConfigurationError: + continue + if os.path.isdir(os.path.join(winCEpath,'lib',platform)): + bindirs=[os.path.join(winCEpath,'bin',compiler),os.path.join(winCEpath,'bin','x86_'+compiler)]+common_bindirs + incdirs=[os.path.join(winCEpath,'include'),os.path.join(winCEpath,'atlmfc','include'),include] + libdirs=[os.path.join(winCEpath,'lib',platform),os.path.join(winCEpath,'atlmfc','lib',platform),lib] + cetargets.append((platform,(platform,(bindirs,incdirs,libdirs)))) + if cetargets: + versions.append((device+' '+version,cetargets)) +def gather_msvc_versions(conf,versions): + vc_paths=[] + for(v,version,reg)in gather_msvc_detected_versions(): + try: + try: + msvc_version=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,reg+"\\Setup\\VC") + except WindowsError: + msvc_version=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,reg+"\\Setup\\Microsoft Visual C++") + path,type=_winreg.QueryValueEx(msvc_version,'ProductDir') + vc_paths.append((version,os.path.abspath(str(path)))) + except WindowsError: + continue + wince_supported_platforms=gather_wince_supported_platforms() + for version,vc_path in vc_paths: + vs_path=os.path.dirname(vc_path) + vsvars=os.path.join(vs_path,'Common7','Tools','vsvars32.bat') + if wince_supported_platforms and os.path.isfile(vsvars): + conf.gather_wince_targets(versions,version,vc_path,vsvars,wince_supported_platforms) + for version,vc_path in vc_paths: + vs_path=os.path.dirname(vc_path) + conf.gather_msvc_targets(versions,version,vc_path) +def gather_icl_versions(conf,versions): + version_pattern=re.compile('^...?.?\....?.?') + try: + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Wow6432node\\Intel\\Compilers\\C++') + except WindowsError: + try: + all_versions=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,'SOFTWARE\\Intel\\Compilers\\C++') + except WindowsError: + return + index=0 + while 1: + try: + version=_winreg.EnumKey(all_versions,index) + except WindowsError: + break + index=index+1 + if not version_pattern.match(version): + continue + targets=[] + for target,arch in all_icl_platforms: + try: + if target=='intel64':targetDir='EM64T_NATIVE' + else:targetDir=target + _winreg.OpenKey(all_versions,version+'\\'+targetDir) + icl_version=_winreg.OpenKey(all_versions,version) + path,type=_winreg.QueryValueEx(icl_version,'ProductDir') + if os.path.isfile(os.path.join(path,'bin','iclvars.bat')): + try: + targets.append((target,(arch,conf.get_msvc_version('intel',version,target,os.path.join(path,'bin','iclvars.bat'))))) + except conf.errors.ConfigurationError: + pass + except WindowsError: + pass + for target,arch in all_icl_platforms: + try: + icl_version=_winreg.OpenKey(all_versions,version+'\\'+target) + path,type=_winreg.QueryValueEx(icl_version,'ProductDir') + if os.path.isfile(os.path.join(path,'bin','iclvars.bat')): + try: + targets.append((target,(arch,conf.get_msvc_version('intel',version,target,os.path.join(path,'bin','iclvars.bat'))))) + except conf.errors.ConfigurationError: + pass + except WindowsError: + continue + major=version[0:2] + versions.append(('intel '+major,targets)) +def get_msvc_versions(conf): + if not conf.env['MSVC_INSTALLED_VERSIONS']: + lst=[] + conf.gather_icl_versions(lst) + conf.gather_wsdk_versions(lst) + conf.gather_msvc_versions(lst) + conf.env['MSVC_INSTALLED_VERSIONS']=lst + return conf.env['MSVC_INSTALLED_VERSIONS'] +def print_all_msvc_detected(conf): + for version,targets in conf.env['MSVC_INSTALLED_VERSIONS']: + info(version) + for target,l in targets: + info("\t"+target) +def detect_msvc(conf): + versions=get_msvc_versions(conf) + return setup_msvc(conf,versions) +def find_lt_names_msvc(self,libname,is_static=False): + lt_names=['lib%s.la'%libname,'%s.la'%libname,] + for path in self.env['LIBPATH']: + for la in lt_names: + laf=os.path.join(path,la) + dll=None + if os.path.exists(laf): + ltdict=Utils.read_la_file(laf) + lt_libdir=None + if ltdict.get('libdir',''): + lt_libdir=ltdict['libdir'] + if not is_static and ltdict.get('library_names',''): + dllnames=ltdict['library_names'].split() + dll=dllnames[0].lower() + dll=re.sub('\.dll$','',dll) + return(lt_libdir,dll,False) + elif ltdict.get('old_library',''): + olib=ltdict['old_library'] + if os.path.exists(os.path.join(path,olib)): + return(path,olib,True) + elif lt_libdir!=''and os.path.exists(os.path.join(lt_libdir,olib)): + return(lt_libdir,olib,True) + else: + return(None,olib,True) + else: + raise self.errors.WafError('invalid libtool object file: %s'%laf) + return(None,None,None) +def libname_msvc(self,libname,is_static=False): + lib=libname.lower() + lib=re.sub('\.lib$','',lib) + if lib in g_msvc_systemlibs: + return lib + lib=re.sub('^lib','',lib) + if lib=='m': + return None + (lt_path,lt_libname,lt_static)=self.find_lt_names_msvc(lib,is_static) + if lt_path!=None and lt_libname!=None: + if lt_static==True: + return os.path.join(lt_path,lt_libname) + if lt_path!=None: + _libpaths=[lt_path]+self.env['LIBPATH'] + else: + _libpaths=self.env['LIBPATH'] + static_libs=['lib%ss.lib'%lib,'lib%s.lib'%lib,'%ss.lib'%lib,'%s.lib'%lib,] + dynamic_libs=['lib%s.dll.lib'%lib,'lib%s.dll.a'%lib,'%s.dll.lib'%lib,'%s.dll.a'%lib,'lib%s_d.lib'%lib,'%s_d.lib'%lib,'%s.lib'%lib,] + libnames=static_libs + if not is_static: + libnames=dynamic_libs+static_libs + for path in _libpaths: + for libn in libnames: + if os.path.exists(os.path.join(path,libn)): + debug('msvc: lib found: %s'%os.path.join(path,libn)) + return re.sub('\.lib$','',libn) + self.fatal("The library %r could not be found"%libname) + return re.sub('\.lib$','',libname) +def check_lib_msvc(self,libname,is_static=False,uselib_store=None): + libn=self.libname_msvc(libname,is_static) + if not uselib_store: + uselib_store=libname.upper() + if False and is_static: + self.env['STLIB_'+uselib_store]=[libn] + else: + self.env['LIB_'+uselib_store]=[libn] +def check_libs_msvc(self,libnames,is_static=False): + for libname in Utils.to_list(libnames): + self.check_lib_msvc(libname,is_static) +def configure(conf): + conf.autodetect() + conf.find_msvc() + conf.msvc_common_flags() + conf.cc_load_tools() + conf.cxx_load_tools() + conf.cc_add_flags() + conf.cxx_add_flags() + conf.link_add_flags() + conf.visual_studio_add_flags() +def no_autodetect(conf): + conf.env.NO_MSVC_DETECT=1 + configure(conf) +def autodetect(conf): + v=conf.env + if v.NO_MSVC_DETECT: + return + compiler,version,path,includes,libdirs=conf.detect_msvc() + v['PATH']=path + v['INCLUDES']=includes + v['LIBPATH']=libdirs + v['MSVC_COMPILER']=compiler + try: + v['MSVC_VERSION']=float(version) + except: + v['MSVC_VERSION']=float(version[:-3]) +def _get_prog_names(conf,compiler): + if compiler=='intel': + compiler_name='ICL' + linker_name='XILINK' + lib_name='XILIB' + else: + compiler_name='CL' + linker_name='LINK' + lib_name='LIB' + return compiler_name,linker_name,lib_name +def find_msvc(conf): + if sys.platform=='cygwin': + conf.fatal('MSVC module does not work under cygwin Python!') + v=conf.env + path=v['PATH'] + compiler=v['MSVC_COMPILER'] + version=v['MSVC_VERSION'] + compiler_name,linker_name,lib_name=_get_prog_names(conf,compiler) + v.MSVC_MANIFEST=(compiler=='msvc'and version>=8)or(compiler=='wsdk'and version>=6)or(compiler=='intel'and version>=11) + cxx=None + if v['CXX']:cxx=v['CXX'] + elif'CXX'in conf.environ:cxx=conf.environ['CXX'] + cxx=conf.find_program(compiler_name,var='CXX',path_list=path) + cxx=conf.cmd_to_list(cxx) + env=dict(conf.environ) + if path:env.update(PATH=';'.join(path)) + if not conf.cmd_and_log(cxx+['/nologo','/help'],env=env): + conf.fatal('the msvc compiler could not be identified') + v['CC']=v['CXX']=cxx + v['CC_NAME']=v['CXX_NAME']='msvc' + if not v['LINK_CXX']: + link=conf.find_program(linker_name,path_list=path) + if link:v['LINK_CXX']=link + else:conf.fatal('%s was not found (linker)'%linker_name) + v['LINK']=link + if not v['LINK_CC']: + v['LINK_CC']=v['LINK_CXX'] + if not v['AR']: + stliblink=conf.find_program(lib_name,path_list=path,var='AR') + if not stliblink:return + v['ARFLAGS']=['/NOLOGO'] + if v.MSVC_MANIFEST: + mt=conf.find_program('MT',path_list=path,var='MT') + v['MTFLAGS']=['/NOLOGO'] + conf.load('winres') + if not conf.env['WINRC']: + warn('Resource compiler not found. Compiling resource file is disabled') +def visual_studio_add_flags(self): + v=self.env + try:v.prepend_value('INCLUDES',self.environ['INCLUDE'].split(';')) + except:pass + try:v.prepend_value('LIBPATH',self.environ['LIB'].split(';')) + except:pass +def msvc_common_flags(conf): + v=conf.env + v['DEST_BINFMT']='pe' + v.append_value('CFLAGS',['/nologo']) + v.append_value('CXXFLAGS',['/nologo']) + v['DEFINES_ST']='/D%s' + v['CC_SRC_F']='' + v['CC_TGT_F']=['/c','/Fo'] + if v['MSVC_VERSION']>=8: + v['CC_TGT_F']=['/FC']+v['CC_TGT_F'] + v['CXX_SRC_F']='' + v['CXX_TGT_F']=['/c','/Fo'] + if v['MSVC_VERSION']>=8: + v['CXX_TGT_F']=['/FC']+v['CXX_TGT_F'] + v['CPPPATH_ST']='/I%s' + v['AR_TGT_F']=v['CCLNK_TGT_F']=v['CXXLNK_TGT_F']='/OUT:' + v['CFLAGS_CONSOLE']=v['CXXFLAGS_CONSOLE']=['/SUBSYSTEM:CONSOLE'] + v['CFLAGS_NATIVE']=v['CXXFLAGS_NATIVE']=['/SUBSYSTEM:NATIVE'] + v['CFLAGS_POSIX']=v['CXXFLAGS_POSIX']=['/SUBSYSTEM:POSIX'] + v['CFLAGS_WINDOWS']=v['CXXFLAGS_WINDOWS']=['/SUBSYSTEM:WINDOWS'] + v['CFLAGS_WINDOWSCE']=v['CXXFLAGS_WINDOWSCE']=['/SUBSYSTEM:WINDOWSCE'] + v['CFLAGS_CRT_MULTITHREADED']=v['CXXFLAGS_CRT_MULTITHREADED']=['/MT'] + v['CFLAGS_CRT_MULTITHREADED_DLL']=v['CXXFLAGS_CRT_MULTITHREADED_DLL']=['/MD'] + v['CFLAGS_CRT_MULTITHREADED_DBG']=v['CXXFLAGS_CRT_MULTITHREADED_DBG']=['/MTd'] + v['CFLAGS_CRT_MULTITHREADED_DLL_DBG']=v['CXXFLAGS_CRT_MULTITHREADED_DLL_DBG']=['/MDd'] + v['LIB_ST']='%s.lib' + v['LIBPATH_ST']='/LIBPATH:%s' + v['STLIB_ST']='lib%s.lib' + v['STLIBPATH_ST']='/LIBPATH:%s' + v.append_value('LINKFLAGS',['/NOLOGO']) + if v['MSVC_MANIFEST']: + v.append_value('LINKFLAGS',['/MANIFEST']) + v['CFLAGS_cshlib']=[] + v['CXXFLAGS_cxxshlib']=[] + v['LINKFLAGS_cshlib']=v['LINKFLAGS_cxxshlib']=['/DLL'] + v['cshlib_PATTERN']=v['cxxshlib_PATTERN']='%s.dll' + v['implib_PATTERN']='%s.lib' + v['IMPLIB_ST']='/IMPLIB:%s' + v['LINKFLAGS_cstlib']=[] + v['cstlib_PATTERN']=v['cxxstlib_PATTERN']='lib%s.lib' + v['cprogram_PATTERN']=v['cxxprogram_PATTERN']='%s.exe' +def apply_flags_msvc(self): + if self.env.CC_NAME!='msvc'or not getattr(self,'link_task',None): + return + is_static=isinstance(self.link_task,ccroot.stlink_task) + subsystem=getattr(self,'subsystem','') + if subsystem: + subsystem='/subsystem:%s'%subsystem + flags=is_static and'ARFLAGS'or'LINKFLAGS' + self.env.append_value(flags,subsystem) + if not is_static: + for f in self.env.LINKFLAGS: + d=f.lower() + if d[1:]=='debug': + pdbnode=self.link_task.outputs[0].change_ext('.pdb') + self.link_task.outputs.append(pdbnode) + try: + self.install_task.source.append(pdbnode) + except AttributeError: + pass + break +def apply_manifest(self): + if self.env.CC_NAME=='msvc'and self.env.MSVC_MANIFEST and getattr(self,'link_task',None): + out_node=self.link_task.outputs[0] + man_node=out_node.parent.find_or_declare(out_node.name+'.manifest') + self.link_task.outputs.append(man_node) + self.link_task.do_manifest=True +def exec_mf(self): + env=self.env + mtool=env['MT'] + if not mtool: + return 0 + self.do_manifest=False + outfile=self.outputs[0].abspath() + manifest=None + for out_node in self.outputs: + if out_node.name.endswith('.manifest'): + manifest=out_node.abspath() + break + if manifest is None: + return 0 + mode='' + if'cprogram'in self.generator.features or'cxxprogram'in self.generator.features: + mode='1' + elif'cshlib'in self.generator.features or'cxxshlib'in self.generator.features: + mode='2' + debug('msvc: embedding manifest in mode %r'%mode) + lst=[] + lst.append(env['MT']) + lst.extend(Utils.to_list(env['MTFLAGS'])) + lst.extend(['-manifest',manifest]) + lst.append('-outputresource:%s;%s'%(outfile,mode)) + lst=[lst] + return self.exec_command(*lst) +def quote_response_command(self,flag): + if flag.find(' ')>-1: + for x in('/LIBPATH:','/IMPLIB:','/OUT:','/I'): + if flag.startswith(x): + flag='%s"%s"'%(x,flag[len(x):]) + break + else: + flag='"%s"'%flag + return flag +def exec_response_command(self,cmd,**kw): + try: + tmp=None + if sys.platform.startswith('win')and isinstance(cmd,list)and len(' '.join(cmd))>=8192: + program=cmd[0] + cmd=[self.quote_response_command(x)for x in cmd] + (fd,tmp)=tempfile.mkstemp() + os.write(fd,'\r\n'.join(i.replace('\\','\\\\')for i in cmd[1:])) + os.close(fd) + cmd=[program,'@'+tmp] + ret=self.generator.bld.exec_command(cmd,**kw) + finally: + if tmp: + try: + os.remove(tmp) + except: + pass + return ret +def exec_command_msvc(self,*k,**kw): + if self.env['CC_NAME']=='msvc': + if isinstance(k[0],list): + lst=[] + carry='' + for a in k[0]: + if a=='/Fo'or a=='/doc'or a[-1]==':': + carry=a + else: + lst.append(carry+a) + carry='' + k=[lst] + if self.env['PATH']: + env=dict(os.environ) + env.update(PATH=';'.join(self.env['PATH'])) + kw['env']=env + bld=self.generator.bld + try: + if not kw.get('cwd',None): + kw['cwd']=bld.cwd + except AttributeError: + bld.cwd=kw['cwd']=bld.variant_dir + ret=self.exec_response_command(k[0],**kw) + if not ret and getattr(self,'do_manifest',None): + ret=self.exec_mf() + return ret +for k in'c cxx cprogram cxxprogram cshlib cxxshlib cstlib cxxstlib'.split(): + cls=Task.classes.get(k,None) + if cls: + cls.exec_command=exec_command_msvc + cls.exec_response_command=exec_response_command + cls.quote_response_command=quote_response_command + cls.exec_mf=exec_mf + +conf(get_msvc_version) +conf(gather_wsdk_versions) +conf(gather_msvc_targets) +conf(gather_wince_targets) +conf(gather_msvc_versions) +conf(gather_icl_versions) +conf(get_msvc_versions) +conf(print_all_msvc_detected) +conf(detect_msvc) +conf(find_lt_names_msvc) +conf(libname_msvc) +conf(check_lib_msvc) +conf(check_libs_msvc) +conf(no_autodetect) +conf(autodetect) +conf(find_msvc) +conf(visual_studio_add_flags) +conf(msvc_common_flags) +after_method('apply_link')(apply_flags_msvc) +feature('c','cxx')(apply_flags_msvc) +feature('cprogram','cshlib','cxxprogram','cxxshlib')(apply_manifest) +after_method('apply_link')(apply_manifest) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/nasm.py jalv-1.0.0~dfsg0/waflib/Tools/nasm.py --- jalv-0~svn3409/waflib/Tools/nasm.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/nasm.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,14 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import waflib.Tools.asm +from waflib.TaskGen import feature +def apply_nasm_vars(self): + self.env.append_value('ASFLAGS',self.to_list(getattr(self,'nasm_flags',[]))) +def configure(conf): + nasm=conf.find_program(['nasm','yasm'],var='AS') + conf.env.AS_TGT_F=['-o'] + conf.env.ASLNK_TGT_F=['-o'] + +feature('asm')(apply_nasm_vars) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/perl.py jalv-1.0.0~dfsg0/waflib/Tools/perl.py --- jalv-0~svn3409/waflib/Tools/perl.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/perl.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,81 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Options,Utils +from waflib.Configure import conf +from waflib.TaskGen import extension,feature,before_method +def init_perlext(self): + self.uselib=self.to_list(getattr(self,'uselib',[])) + if not'PERLEXT'in self.uselib:self.uselib.append('PERLEXT') + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['perlext_PATTERN'] +def xsubpp_file(self,node): + outnode=node.change_ext('.c') + self.create_task('xsubpp',node,outnode) + self.source.append(outnode) +class xsubpp(Task.Task): + run_str='${PERL} ${XSUBPP} -noprototypes -typemap ${EXTUTILS_TYPEMAP} ${SRC} > ${TGT}' + color='BLUE' + ext_out=['.h'] +def check_perl_version(self,minver=None): + res=True + if minver: + cver='.'.join(map(str,minver)) + else: + cver='' + self.start_msg('Checking for minimum perl version %s'%cver) + perl=getattr(Options.options,'perlbinary',None) + if not perl: + perl=self.find_program('perl',var='PERL') + if not perl: + self.end_msg("Perl not found",color="YELLOW") + return False + self.env['PERL']=perl + version=self.cmd_and_log([perl,"-e",'printf \"%vd\", $^V']) + if not version: + res=False + version="Unknown" + elif not minver is None: + ver=tuple(map(int,version.split("."))) + if ver +#ifdef __cplusplus +extern "C" { +#endif + void Py_Initialize(void); + void Py_Finalize(void); +#ifdef __cplusplus +} +#endif +int main() +{ + Py_Initialize(); + Py_Finalize(); + return 0; +} +''' +INST=''' +import sys, py_compile +py_compile.compile(sys.argv[1], sys.argv[2], sys.argv[3]) +''' +DISTUTILS_IMP=['from distutils.sysconfig import get_config_var, get_python_lib'] +def process_py(self,node): + try: + if not self.bld.is_install: + return + except: + return + try: + if not self.install_path: + return + except AttributeError: + self.install_path='${PYTHONDIR}' + def inst_py(ctx): + install_from=getattr(self,'install_from',None) + if install_from: + install_from=self.path.find_dir(install_from) + install_pyfile(self,node,install_from) + self.bld.add_post_fun(inst_py) +def install_pyfile(self,node,install_from=None): + from_node=install_from or node.parent + tsk=self.bld.install_as(self.install_path+'/'+node.path_from(from_node),node,postpone=False) + path=tsk.get_install_path() + if self.bld.is_install<0: + info("+ removing byte compiled python files") + for x in'co': + try: + os.remove(path+x) + except OSError: + pass + if self.bld.is_install>0: + try: + st1=os.stat(path) + except: + error('The python file is missing, this should not happen') + for x in['c','o']: + do_inst=self.env['PY'+x.upper()] + try: + st2=os.stat(path+x) + except OSError: + pass + else: + if st1.st_mtime<=st2.st_mtime: + do_inst=False + if do_inst: + lst=(x=='o')and[self.env['PYFLAGS_OPT']]or[] + (a,b,c)=(path,path+x,tsk.get_install_path(destdir=False)+x) + argv=self.env['PYTHON']+lst+['-c',INST,a,b,c] + info('+ byte compiling %r'%(path+x)) + ret=Utils.subprocess.Popen(argv).wait() + if ret: + raise Errors.WafError('py%s compilation failed %r'%(x,path)) +def feature_py(self): + pass +def init_pyext(self): + try: + if not self.install_path: + return + except AttributeError: + self.install_path='${PYTHONARCHDIR}' + self.uselib=self.to_list(getattr(self,'uselib',[])) + if not'PYEXT'in self.uselib: + self.uselib.append('PYEXT') + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['macbundle_PATTERN']=self.env['pyext_PATTERN'] +def set_bundle(self): + if Utils.unversioned_sys_platform=='darwin': + self.mac_bundle=True +def init_pyembed(self): + self.uselib=self.to_list(getattr(self,'uselib',[])) + if not'PYEMBED'in self.uselib: + self.uselib.append('PYEMBED') +def get_python_variables(self,variables,imports=None): + if not imports: + try: + imports=self.python_imports + except AttributeError: + imports=DISTUTILS_IMP + program=list(imports) + program.append('') + for v in variables: + program.append("print(repr(%s))"%v) + os_env=dict(os.environ) + try: + del os_env['MACOSX_DEPLOYMENT_TARGET'] + except KeyError: + pass + try: + out=self.cmd_and_log(self.env.PYTHON+['-c','\n'.join(program)],env=os_env) + except Errors.WafError: + self.fatal('The distutils module is unusable: install "python-devel"?') + return_values=[] + for s in out.split('\n'): + s=s.strip() + if not s: + continue + if s=='None': + return_values.append(None) + elif s[0]=="'"and s[-1]=="'": + return_values.append(s[1:-1]) + elif s[0].isdigit(): + return_values.append(int(s)) + else:break + return return_values +def check_python_headers(conf): + if not conf.env['CC_NAME']and not conf.env['CXX_NAME']: + conf.fatal('load a compiler first (gcc, g++, ..)') + if not conf.env['PYTHON_VERSION']: + conf.check_python_version() + env=conf.env + pybin=conf.env.PYTHON + if not pybin: + conf.fatal('could not find the python executable') + v='prefix SO LDFLAGS LIBDIR LIBPL INCLUDEPY Py_ENABLE_SHARED MACOSX_DEPLOYMENT_TARGET LDSHARED CFLAGS'.split() + try: + lst=conf.get_python_variables(["get_config_var('%s') or ''"%x for x in v]) + except RuntimeError: + conf.fatal("Python development headers not found (-v for details).") + vals=['%s = %r'%(x,y)for(x,y)in zip(v,lst)] + conf.to_log("Configuration returned from %r:\n%r\n"%(pybin,'\n'.join(vals))) + dct=dict(zip(v,lst)) + x='MACOSX_DEPLOYMENT_TARGET' + if dct[x]: + conf.env[x]=conf.environ[x]=dct[x] + env['pyext_PATTERN']='%s'+dct['SO'] + all_flags=dct['LDFLAGS']+' '+dct['CFLAGS'] + conf.parse_flags(all_flags,'PYEMBED') + all_flags=dct['LDFLAGS']+' '+dct['LDSHARED']+' '+dct['CFLAGS'] + conf.parse_flags(all_flags,'PYEXT') + result=None + for name in('python'+env['PYTHON_VERSION'],'python'+env['PYTHON_VERSION'].replace('.','')): + if not result and env['LIBPATH_PYEMBED']: + path=env['LIBPATH_PYEMBED'] + conf.to_log("\n\n# Trying default LIBPATH_PYEMBED: %r\n"%path) + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBPATH_PYEMBED'%name) + if not result and dct['LIBDIR']: + path=[dct['LIBDIR']] + conf.to_log("\n\n# try again with -L$python_LIBDIR: %r\n"%path) + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in LIBDIR'%name) + if not result and dct['LIBPL']: + path=[dct['LIBPL']] + conf.to_log("\n\n# try again with -L$python_LIBPL (some systems don't install the python library in $prefix/lib)\n") + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in python_LIBPL'%name) + if not result: + path=[os.path.join(dct['prefix'],"libs")] + conf.to_log("\n\n# try again with -L$prefix/libs, and pythonXY name rather than pythonX.Y (win32)\n") + result=conf.check(lib=name,uselib='PYEMBED',libpath=path,mandatory=False,msg='Checking for library %s in $prefix/libs'%name) + if result: + break + if result: + env['LIBPATH_PYEMBED']=path + env.append_value('LIB_PYEMBED',[name]) + else: + conf.to_log("\n\n### LIB NOT FOUND\n") + if(Utils.is_win32 or sys.platform.startswith('os2')or dct['Py_ENABLE_SHARED']): + env['LIBPATH_PYEXT']=env['LIBPATH_PYEMBED'] + env['LIB_PYEXT']=env['LIB_PYEMBED'] + num='.'.join(env['PYTHON_VERSION'].split('.')[:2]) + conf.find_program(['python%s-config'%num,'python-config-%s'%num,'python%sm-config'%num],var='PYTHON_CONFIG',mandatory=False) + includes=[] + if conf.env.PYTHON_CONFIG: + for incstr in conf.cmd_and_log([conf.env.PYTHON_CONFIG,'--includes']).strip().split(): + if(incstr.startswith('-I')or incstr.startswith('/I')): + incstr=incstr[2:] + if incstr not in includes: + includes.append(incstr) + conf.to_log("Include path for Python extensions (found via python-config --includes): %r\n"%(includes,)) + env['INCLUDES_PYEXT']=includes + env['INCLUDES_PYEMBED']=includes + else: + conf.to_log("Include path for Python extensions ""(found via distutils module): %r\n"%(dct['INCLUDEPY'],)) + env['INCLUDES_PYEXT']=[dct['INCLUDEPY']] + env['INCLUDES_PYEMBED']=[dct['INCLUDEPY']] + if env['CC_NAME']=='gcc': + env.append_value('CFLAGS_PYEMBED',['-fno-strict-aliasing']) + env.append_value('CFLAGS_PYEXT',['-fno-strict-aliasing']) + if env['CXX_NAME']=='gcc': + env.append_value('CXXFLAGS_PYEMBED',['-fno-strict-aliasing']) + env.append_value('CXXFLAGS_PYEXT',['-fno-strict-aliasing']) + if env.CC_NAME=="msvc": + from distutils.msvccompiler import MSVCCompiler + dist_compiler=MSVCCompiler() + dist_compiler.initialize() + env.append_value('CFLAGS_PYEXT',dist_compiler.compile_options) + env.append_value('CXXFLAGS_PYEXT',dist_compiler.compile_options) + env.append_value('LINKFLAGS_PYEXT',dist_compiler.ldflags_shared) + try: + conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',uselib='PYEMBED',fragment=FRAG,errmsg='Could not find the python development headers') + except conf.errors.ConfigurationError: + conf.check_cfg(path=conf.env.PYTHON_CONFIG,package='',uselib_store='PYEMBED',args=['--cflags','--libs']) + conf.check(header_name='Python.h',define_name='HAVE_PYTHON_H',msg='Getting the python flags from python-config',uselib='PYEMBED',fragment=FRAG,errmsg='Could not find the python development headers elsewhere') +def check_python_version(conf,minver=None): + assert minver is None or isinstance(minver,tuple) + pybin=conf.env['PYTHON'] + if not pybin: + conf.fatal('could not find the python executable') + cmd=pybin+['-c','import sys\nfor x in sys.version_info: print(str(x))'] + debug('python: Running python command %r'%cmd) + lines=conf.cmd_and_log(cmd).split() + assert len(lines)==5,"found %i lines, expected 5: %r"%(len(lines),lines) + pyver_tuple=(int(lines[0]),int(lines[1]),int(lines[2]),lines[3],int(lines[4])) + result=(minver is None)or(pyver_tuple>=minver) + if result: + pyver='.'.join([str(x)for x in pyver_tuple[:2]]) + conf.env['PYTHON_VERSION']=pyver + if'PYTHONDIR'in conf.environ: + pydir=conf.environ['PYTHONDIR'] + else: + if Utils.is_win32: + (python_LIBDEST,pydir)=conf.get_python_variables(["get_config_var('LIBDEST') or ''","get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + else: + python_LIBDEST=None + (pydir,)=conf.get_python_variables(["get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + if python_LIBDEST is None: + if conf.env['LIBDIR']: + python_LIBDEST=os.path.join(conf.env['LIBDIR'],"python"+pyver) + else: + python_LIBDEST=os.path.join(conf.env['PREFIX'],"lib","python"+pyver) + if'PYTHONARCHDIR'in conf.environ: + pyarchdir=conf.environ['PYTHONARCHDIR'] + else: + (pyarchdir,)=conf.get_python_variables(["get_python_lib(plat_specific=1, standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']]) + if not pyarchdir: + pyarchdir=pydir + if hasattr(conf,'define'): + conf.define('PYTHONDIR',pydir) + conf.define('PYTHONARCHDIR',pyarchdir) + conf.env['PYTHONDIR']=pydir + conf.env['PYTHONARCHDIR']=pyarchdir + pyver_full='.'.join(map(str,pyver_tuple[:3])) + if minver is None: + conf.msg('Checking for python version',pyver_full) + else: + minver_str='.'.join(map(str,minver)) + conf.msg('Checking for python version',pyver_tuple,">= %s"%(minver_str,)and'GREEN'or'YELLOW') + if not result: + conf.fatal('The python version is too old, expecting %r'%(minver,)) +PYTHON_MODULE_TEMPLATE=''' +import %s +print(1) +''' +def check_python_module(conf,module_name): + conf.start_msg('Python module %s'%module_name) + try: + conf.cmd_and_log(conf.env['PYTHON']+['-c',PYTHON_MODULE_TEMPLATE%module_name]) + except: + conf.end_msg(False) + conf.fatal('Could not find the python module %r'%module_name) + conf.end_msg(True) +def configure(conf): + try: + conf.find_program('python',var='PYTHON') + except conf.errors.ConfigurationError: + warn("could not find a python executable, setting to sys.executable '%s'"%sys.executable) + conf.env.PYTHON=sys.executable + if conf.env.PYTHON!=sys.executable: + warn("python executable '%s' different from sys.executable '%s'"%(conf.env.PYTHON,sys.executable)) + conf.env.PYTHON=conf.cmd_to_list(conf.env.PYTHON) + v=conf.env + v['PYCMD']='"import sys, py_compile;py_compile.compile(sys.argv[1], sys.argv[2])"' + v['PYFLAGS']='' + v['PYFLAGS_OPT']='-O' + v['PYC']=getattr(Options.options,'pyc',1) + v['PYO']=getattr(Options.options,'pyo',1) +def options(opt): + opt.add_option('--nopyc',action='store_false',default=1,help='Do not install bytecode compiled .pyc files (configuration) [Default:install]',dest='pyc') + opt.add_option('--nopyo',action='store_false',default=1,help='Do not install optimised compiled .pyo files (configuration) [Default:install]',dest='pyo') + +extension('.py')(process_py) +feature('py')(feature_py) +feature('pyext')(init_pyext) +before_method('propagate_uselib_vars','apply_link')(init_pyext) +after_method('apply_bundle')(init_pyext) +feature('pyext')(set_bundle) +before_method('apply_link','apply_bundle')(set_bundle) +before_method('propagate_uselib_vars')(init_pyembed) +feature('pyembed')(init_pyembed) +conf(get_python_variables) +conf(check_python_headers) +conf(check_python_version) +conf(check_python_module) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/qt4.py jalv-1.0.0~dfsg0/waflib/Tools/qt4.py --- jalv-0~svn3409/waflib/Tools/qt4.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/qt4.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,425 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import sys +if sys.hexversion < 0x020400f0: from sets import Set as set +try: + from xml.sax import make_parser + from xml.sax.handler import ContentHandler +except ImportError: + has_xml=False + ContentHandler=object +else: + has_xml=True +import os,sys +from waflib.Tools import c_preproc,cxx +from waflib import Task,Utils,Options,Errors +from waflib.TaskGen import feature,after_method,extension +from waflib.Configure import conf +from waflib import Logs +MOC_H=['.h','.hpp','.hxx','.hh'] +EXT_RCC=['.qrc'] +EXT_UI=['.ui'] +EXT_QT4=['.cpp','.cc','.cxx','.C'] +QT4_LIBS="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtXmlPatterns QtWebKit Qt3Support QtHelp QtScript QtDeclarative" +class qxx(cxx.cxx): + def __init__(self,*k,**kw): + Task.Task.__init__(self,*k,**kw) + self.moc_done=0 + def scan(self): + (nodes,names)=c_preproc.scan(self) + for x in nodes: + if x.name.endswith('.moc'): + nodes.remove(x) + names.append(x.path_from(self.inputs[0].parent.get_bld())) + return(nodes,names) + def runnable_status(self): + if self.moc_done: + return Task.Task.runnable_status(self) + else: + for t in self.run_after: + if not t.hasrun: + return Task.ASK_LATER + self.add_moc_tasks() + return Task.Task.runnable_status(self) + def add_moc_tasks(self): + node=self.inputs[0] + bld=self.generator.bld + try: + self.signature() + except KeyError: + pass + else: + delattr(self,'cache_sig') + moctasks=[] + mocfiles=[] + try: + tmp_lst=bld.raw_deps[self.uid()] + bld.raw_deps[self.uid()]=[] + except KeyError: + tmp_lst=[] + for d in tmp_lst: + if not d.endswith('.moc'): + continue + if d in mocfiles: + Logs.error("paranoia owns") + continue + mocfiles.append(d) + h_node=None + try:ext=Options.options.qt_header_ext.split() + except AttributeError:pass + if not ext:ext=MOC_H + base2=d[:-4] + for x in[node.parent]+self.generator.includes_nodes: + for e in ext: + h_node=x.find_node(base2+e) + if h_node: + break + else: + continue + break + else: + raise Errors.WafError('no header found for %r which is a moc file'%d) + m_node=h_node.change_ext('.moc') + bld.node_deps[(self.inputs[0].parent.abspath(),m_node.name)]=h_node + task=Task.classes['moc'](env=self.env,generator=self.generator) + task.set_inputs(h_node) + task.set_outputs(m_node) + gen=bld.producer + gen.outstanding.insert(0,task) + gen.total+=1 + moctasks.append(task) + tmp_lst=bld.raw_deps[self.uid()]=mocfiles + lst=bld.node_deps.get(self.uid(),()) + for d in lst: + name=d.name + if name.endswith('.moc'): + task=Task.classes['moc'](env=self.env,generator=self.generator) + task.set_inputs(bld.node_deps[(self.inputs[0].parent.abspath(),name)]) + task.set_outputs(d) + gen=bld.producer + gen.outstanding.insert(0,task) + gen.total+=1 + moctasks.append(task) + self.run_after.update(set(moctasks)) + self.moc_done=1 + run=Task.classes['cxx'].__dict__['run'] +class trans_update(Task.Task): + run_str='${QT_LUPDATE} ${SRC} -ts ${TGT}' + color='BLUE' +Task.update_outputs(trans_update) +class XMLHandler(ContentHandler): + def __init__(self): + self.buf=[] + self.files=[] + def startElement(self,name,attrs): + if name=='file': + self.buf=[] + def endElement(self,name): + if name=='file': + self.files.append(str(''.join(self.buf))) + def characters(self,cars): + self.buf.append(cars) +def create_rcc_task(self,node): + rcnode=node.change_ext('_rc.cpp') + rcctask=self.create_task('rcc',node,rcnode) + cpptask=self.create_task('cxx',rcnode,rcnode.change_ext('.o')) + try: + self.compiled_tasks.append(cpptask) + except AttributeError: + self.compiled_tasks=[cpptask] + return cpptask +def create_uic_task(self,node): + uictask=self.create_task('ui4',node) + uictask.outputs=[self.path.find_or_declare(self.env['ui_PATTERN']%node.name[:-3])] +def add_lang(self,node): + self.lang=self.to_list(getattr(self,'lang',[]))+[node] +def apply_qt4(self): + if getattr(self,'lang',None): + qmtasks=[] + for x in self.to_list(self.lang): + if isinstance(x,str): + x=self.path.find_resource(x+'.ts') + qmtasks.append(self.create_task('ts2qm',x,x.change_ext('.qm'))) + if getattr(self,'update',None)and Options.options.trans_qt4: + cxxnodes=[a.inputs[0]for a in self.compiled_tasks]+[a.inputs[0]for a in self.tasks if getattr(a,'inputs',None)and a.inputs[0].name.endswith('.ui')] + for x in qmtasks: + self.create_task('trans_update',cxxnodes,x.inputs) + if getattr(self,'langname',None): + qmnodes=[x.outputs[0]for x in qmtasks] + rcnode=self.langname + if isinstance(rcnode,str): + rcnode=self.path.find_or_declare(rcnode+'.qrc') + t=self.create_task('qm2rcc',qmnodes,rcnode) + k=create_rcc_task(self,t.outputs[0]) + self.link_task.inputs.append(k.outputs[0]) + lst=[] + for flag in self.to_list(self.env['CXXFLAGS']): + if len(flag)<2:continue + f=flag[0:2] + if f in['-D','-I','/D','/I']: + if(f[0]=='/'): + lst.append('-'+flag[1:]) + else: + lst.append(flag) + self.env['MOC_FLAGS']=lst +def cxx_hook(self,node): + return self.create_compiled_task('qxx',node) +class rcc(Task.Task): + color='BLUE' + run_str='${QT_RCC} -name ${SRC[0].name} ${SRC[0].abspath()} ${RCC_ST} -o ${TGT}' + ext_out=['.h'] + def scan(self): + node=self.inputs[0] + if not has_xml: + Logs.error('no xml support was found, the rcc dependencies will be incomplete!') + return([],[]) + parser=make_parser() + curHandler=XMLHandler() + parser.setContentHandler(curHandler) + fi=open(self.inputs[0].abspath()) + parser.parse(fi) + fi.close() + nodes=[] + names=[] + root=self.inputs[0].parent + for x in curHandler.files: + nd=root.find_resource(x) + if nd:nodes.append(nd) + else:names.append(x) + return(nodes,names) +class moc(Task.Task): + color='BLUE' + run_str='${QT_MOC} ${MOC_FLAGS} ${MOCCPPPATH_ST:INCPATHS} ${MOCDEFINES_ST:DEFINES} ${SRC} ${MOC_ST} ${TGT}' +class ui4(Task.Task): + color='BLUE' + run_str='${QT_UIC} ${SRC} -o ${TGT}' + ext_out=['.h'] +class ts2qm(Task.Task): + color='BLUE' + run_str='${QT_LRELEASE} ${QT_LRELEASE_FLAGS} ${SRC} -qm ${TGT}' +class qm2rcc(Task.Task): + color='BLUE' + after='ts2qm' + def run(self): + txt='\n'.join(['%s'%k.path_from(self.outputs[0].parent)for k in self.inputs]) + code='\n\n%s\n\n'%txt + self.outputs[0].write(code) +def configure(self): + self.find_qt4_binaries() + self.set_qt4_libs_to_check() + self.find_qt4_libraries() + self.add_qt4_rpath() + self.simplify_qt4_libs() +def find_qt4_binaries(self): + env=self.env + opt=Options.options + qtdir=getattr(opt,'qtdir','') + qtbin=getattr(opt,'qtbin','') + paths=[] + if qtdir: + qtbin=os.path.join(qtdir,'bin') + if not qtdir: + qtdir=self.environ.get('QT4_ROOT','') + qtbin=os.path.join(qtdir,'bin') + if qtbin: + paths=[qtbin] + if not qtdir: + paths=os.environ.get('PATH','').split(os.pathsep) + paths.append('/usr/share/qt4/bin/') + try: + lst=Utils.listdir('/usr/local/Trolltech/') + except OSError: + pass + else: + if lst: + lst.sort() + lst.reverse() + qtdir='/usr/local/Trolltech/%s/'%lst[0] + qtbin=os.path.join(qtdir,'bin') + paths.append(qtbin) + cand=None + prev_ver=['4','0','0'] + for qmk in['qmake-qt4','qmake4','qmake']: + try: + qmake=self.find_program(qmk,path_list=paths) + except self.errors.ConfigurationError: + pass + else: + try: + version=self.cmd_and_log([qmake,'-query','QT_VERSION']).strip() + except self.errors.ConfigurationError: + pass + else: + if version: + new_ver=version.split('.') + if new_ver>prev_ver: + cand=qmake + prev_ver=new_ver + if cand: + self.env.QMAKE=cand + else: + self.fatal('Could not find qmake for qt4') + qtbin=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_BINS']).strip()+os.sep + def find_bin(lst,var): + for f in lst: + try: + ret=self.find_program(f,path_list=paths) + except self.errors.ConfigurationError: + pass + else: + env[var]=ret + break + find_bin(['uic-qt3','uic3'],'QT_UIC3') + find_bin(['uic-qt4','uic'],'QT_UIC') + if not env['QT_UIC']: + self.fatal('cannot find the uic compiler for qt4') + try: + uicver=self.cmd_and_log(env['QT_UIC']+" -version 2>&1").strip() + except self.errors.ConfigurationError: + self.fatal('this uic compiler is for qt3, add uic for qt4 to your path') + uicver=uicver.replace('Qt User Interface Compiler ','').replace('User Interface Compiler for Qt','') + self.msg('Checking for uic version','%s'%uicver) + if uicver.find(' 3.')!=-1: + self.fatal('this uic compiler is for qt3, add uic for qt4 to your path') + find_bin(['moc-qt4','moc'],'QT_MOC') + find_bin(['rcc'],'QT_RCC') + find_bin(['lrelease-qt4','lrelease'],'QT_LRELEASE') + find_bin(['lupdate-qt4','lupdate'],'QT_LUPDATE') + env['UIC3_ST']='%s -o %s' + env['UIC_ST']='%s -o %s' + env['MOC_ST']='-o' + env['ui_PATTERN']='ui_%s.h' + env['QT_LRELEASE_FLAGS']=['-silent'] + env.MOCCPPPATH_ST='-I%s' + env.MOCDEFINES_ST='-D%s' +def find_qt4_libraries(self): + qtlibs=getattr(Options.options,'qtlibs','') + if not qtlibs: + try: + qtlibs=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_LIBS']).strip() + except Errors.WafError: + qtdir=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_PREFIX']).strip()+os.sep + qtlibs=os.path.join(qtdir,'lib') + self.msg('Found the Qt4 libraries in',qtlibs) + qtincludes=self.cmd_and_log([self.env.QMAKE,'-query','QT_INSTALL_HEADERS']).strip() + env=self.env + if not'PKG_CONFIG_PATH'in os.environ: + os.environ['PKG_CONFIG_PATH']='%s:%s/pkgconfig:/usr/lib/qt4/lib/pkgconfig:/opt/qt4/lib/pkgconfig:/usr/lib/qt4/lib:/opt/qt4/lib'%(qtlibs,qtlibs) + try: + self.check_cfg(atleast_pkgconfig_version='0.1') + except self.errors.ConfigurationError: + for i in self.qt4_vars: + uselib=i.upper() + if Utils.unversioned_sys_platform=="darwin": + frameworkName=i+".framework" + qtDynamicLib=os.path.join(qtlibs,frameworkName,i) + if os.path.exists(qtDynamicLib): + env.append_unique('FRAMEWORK_'+uselib,i) + self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('INCLUDES_'+uselib,os.path.join(qtlibs,frameworkName,'Headers')) + elif sys.platform!="win32": + qtDynamicLib=os.path.join(qtlibs,"lib"+i+".so") + qtStaticLib=os.path.join(qtlibs,"lib"+i+".a") + if os.path.exists(qtDynamicLib): + env.append_unique('LIB_'+uselib,i) + self.msg('Checking for %s'%i,qtDynamicLib,'GREEN') + elif os.path.exists(qtStaticLib): + env.append_unique('LIB_'+uselib,i) + self.msg('Checking for %s'%i,qtStaticLib,'GREEN') + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + else: + for k in("lib%s.a","lib%s4.a","%s.lib","%s4.lib"): + lib=os.path.join(qtlibs,k%i) + if os.path.exists(lib): + env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) + self.msg('Checking for %s'%i,lib,'GREEN') + break + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + uselib=i.upper()+"_debug" + for k in("lib%sd.a","lib%sd4.a","%sd.lib","%sd4.lib"): + lib=os.path.join(qtlibs,k%i) + if os.path.exists(lib): + env.append_unique('LIB_'+uselib,i+k[k.find("%s")+2:k.find('.')]) + self.msg('Checking for %s'%i,lib,'GREEN') + break + else: + self.msg('Checking for %s'%i,False,'YELLOW') + env.append_unique('LIBPATH_'+uselib,qtlibs) + env.append_unique('INCLUDES_'+uselib,qtincludes) + env.append_unique('INCLUDES_'+uselib,os.path.join(qtincludes,i)) + else: + for i in self.qt4_vars_debug+self.qt4_vars: + self.check_cfg(package=i,args='--cflags --libs',mandatory=False) +def simplify_qt4_libs(self): + env=self.env + def process_lib(vars_,coreval): + for d in vars_: + var=d.upper() + if var=='QTCORE': + continue + value=env['LIBPATH_'+var] + if value: + core=env[coreval] + accu=[] + for lib in value: + if lib in core: + continue + accu.append(lib) + env['LIBPATH_'+var]=accu + process_lib(self.qt4_vars,'LIBPATH_QTCORE') + process_lib(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') +def add_qt4_rpath(self): + env=self.env + if Options.options.want_rpath: + def process_rpath(vars_,coreval): + for d in vars_: + var=d.upper() + value=env['LIBPATH_'+var] + if value: + core=env[coreval] + accu=[] + for lib in value: + if var!='QTCORE': + if lib in core: + continue + accu.append('-Wl,--rpath='+lib) + env['RPATH_'+var]=accu + process_rpath(self.qt4_vars,'LIBPATH_QTCORE') + process_rpath(self.qt4_vars_debug,'LIBPATH_QTCORE_DEBUG') +def set_qt4_libs_to_check(self): + if not hasattr(self,'qt4_vars'): + self.qt4_vars=QT4_LIBS + self.qt4_vars=Utils.to_list(self.qt4_vars) + if not hasattr(self,'qt4_vars_debug'): + self.qt4_vars_debug=[a+'_debug'for a in self.qt4_vars] + self.qt4_vars_debug=Utils.to_list(self.qt4_vars_debug) +def options(opt): + opt.add_option('--want-rpath',action='store_true',default=False,dest='want_rpath',help='enable the rpath for qt libraries') + opt.add_option('--header-ext',type='string',default='',help='header extension for moc files',dest='qt_header_ext') + for i in'qtdir qtbin qtlibs'.split(): + opt.add_option('--'+i,type='string',default='',dest=i) + opt.add_option('--translate',action="store_true",help="collect translation strings",dest="trans_qt4",default=False) + +extension(*EXT_RCC)(create_rcc_task) +extension(*EXT_UI)(create_uic_task) +extension('.ts')(add_lang) +feature('qt4')(apply_qt4) +after_method('apply_link')(apply_qt4) +extension(*EXT_QT4)(cxx_hook) +conf(find_qt4_binaries) +conf(find_qt4_libraries) +conf(simplify_qt4_libs) +conf(add_qt4_rpath) +conf(set_qt4_libs_to_check) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/ruby.py jalv-1.0.0~dfsg0/waflib/Tools/ruby.py --- jalv-0~svn3409/waflib/Tools/ruby.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/ruby.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,104 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Task,Options,Utils +from waflib.TaskGen import before_method,feature,after_method,Task,extension +from waflib.Configure import conf +def init_rubyext(self): + self.install_path='${ARCHDIR_RUBY}' + self.uselib=self.to_list(getattr(self,'uselib','')) + if not'RUBY'in self.uselib: + self.uselib.append('RUBY') + if not'RUBYEXT'in self.uselib: + self.uselib.append('RUBYEXT') +def apply_ruby_so_name(self): + self.env['cshlib_PATTERN']=self.env['cxxshlib_PATTERN']=self.env['rubyext_PATTERN'] +def check_ruby_version(self,minver=()): + if Options.options.rubybinary: + self.env.RUBY=Options.options.rubybinary + else: + self.find_program('ruby',var='RUBY') + ruby=self.env.RUBY + try: + version=self.cmd_and_log([ruby,'-e','puts defined?(VERSION) ? VERSION : RUBY_VERSION']).strip() + except: + self.fatal('could not determine ruby version') + self.env.RUBY_VERSION=version + try: + ver=tuple(map(int,version.split("."))) + except: + self.fatal('unsupported ruby version %r'%version) + cver='' + if minver: + if ver=(1,9,0): + ruby_hdrdir=read_config('rubyhdrdir') + cpppath+=ruby_hdrdir + cpppath+=[os.path.join(ruby_hdrdir[0],read_config('arch')[0])] + self.check(header_name='ruby.h',includes=cpppath,errmsg='could not find ruby header file') + self.env.LIBPATH_RUBYEXT=read_config('libdir') + self.env.LIBPATH_RUBYEXT+=archdir + self.env.INCLUDES_RUBYEXT=cpppath + self.env.CFLAGS_RUBYEXT=read_config('CCDLFLAGS') + self.env.rubyext_PATTERN='%s.'+read_config('DLEXT')[0] + flags=read_config('LDSHARED') + while flags and flags[0][0]!='-': + flags=flags[1:] + if len(flags)>1 and flags[1]=="ppc": + flags=flags[2:] + self.env.LINKFLAGS_RUBYEXT=flags + self.env.LINKFLAGS_RUBYEXT+=read_config('LIBS') + self.env.LINKFLAGS_RUBYEXT+=read_config('LIBRUBYARG_SHARED') + if Options.options.rubyarchdir: + self.env.ARCHDIR_RUBY=Options.options.rubyarchdir + else: + self.env.ARCHDIR_RUBY=read_config('sitearchdir')[0] + if Options.options.rubylibdir: + self.env.LIBDIR_RUBY=Options.options.rubylibdir + else: + self.env.LIBDIR_RUBY=read_config('sitelibdir')[0] +def check_ruby_module(self,module_name): + self.start_msg('Ruby module %s'%module_name) + try: + self.cmd_and_log([self.env['RUBY'],'-e','require \'%s\';puts 1'%module_name]) + except: + self.end_msg(False) + self.fatal('Could not find the ruby module %r'%module_name) + self.end_msg(True) +def process(self,node): + tsk=self.create_task('run_ruby',node) +class run_ruby(Task.Task): + run_str='${RUBY} ${RBFLAGS} -I ${SRC[0].parent.abspath()} ${SRC}' +def options(opt): + opt.add_option('--with-ruby-archdir',type='string',dest='rubyarchdir',help='Specify directory where to install arch specific files') + opt.add_option('--with-ruby-libdir',type='string',dest='rubylibdir',help='Specify alternate ruby library path') + opt.add_option('--with-ruby-binary',type='string',dest='rubybinary',help='Specify alternate ruby binary') + +feature('rubyext')(init_rubyext) +before_method('apply_incpaths','apply_lib_vars','apply_bundle','apply_link')(init_rubyext) +feature('rubyext')(apply_ruby_so_name) +before_method('apply_link','propagate_uselib')(apply_ruby_so_name) +conf(check_ruby_version) +conf(check_ruby_ext_devel) +conf(check_ruby_module) +extension('.rb')(process) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/suncc.py jalv-1.0.0~dfsg0/waflib/Tools/suncc.py --- jalv-0~svn3409/waflib/Tools/suncc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/suncc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,54 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_scc(conf): + v=conf.env + cc=None + if v['CC']:cc=v['CC'] + elif'CC'in conf.environ:cc=conf.environ['CC'] + if not cc:cc=conf.find_program('cc',var='CC') + if not cc:conf.fatal('Could not find a Sun C compiler') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-flags']) + except: + conf.fatal('%r is not a Sun compiler'%cc) + v['CC']=cc + v['CC_NAME']='sun' +def scc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']='' + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Bdynamic' + v['STLIB_MARKER']='-Bstatic' + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-Kpic','-DPIC'] + v['LINKFLAGS_cshlib']=['-G'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=['-Bstatic'] + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_scc() + conf.find_ar() + conf.scc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() + +conf(find_scc) +conf(scc_common_flags) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/suncxx.py jalv-1.0.0~dfsg0/waflib/Tools/suncxx.py --- jalv-0~svn3409/waflib/Tools/suncxx.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/suncxx.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,55 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os +from waflib import Utils +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_sxx(conf): + v=conf.env + cc=None + if v['CXX']:cc=v['CXX'] + elif'CXX'in conf.environ:cc=conf.environ['CXX'] + if not cc:cc=conf.find_program('CC',var='CXX') + if not cc:cc=conf.find_program('c++',var='CXX') + if not cc:conf.fatal('Could not find a Sun C++ compiler') + cc=conf.cmd_to_list(cc) + try: + conf.cmd_and_log(cc+['-flags']) + except: + conf.fatal('%r is not a Sun compiler'%cc) + v['CXX']=cc + v['CXX_NAME']='sun' +def sxx_common_flags(conf): + v=conf.env + v['CXX_SRC_F']=[] + v['CXX_TGT_F']=['-c','-o'] + if not v['LINK_CXX']:v['LINK_CXX']=v['CXX'] + v['CXXLNK_SRC_F']=[] + v['CXXLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['SONAME_ST']='-Wl,-h,%s' + v['SHLIB_MARKER']='-Bdynamic' + v['STLIB_MARKER']='-Bstatic' + v['cxxprogram_PATTERN']='%s' + v['CXXFLAGS_cxxshlib']=['-Kpic','-DPIC'] + v['LINKFLAGS_cxxshlib']=['-G'] + v['cxxshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cxxstlib']=['-Bstatic'] + v['cxxstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_sxx() + conf.find_ar() + conf.sxx_common_flags() + conf.cxx_load_tools() + conf.cxx_add_flags() + conf.link_add_flags() + +conf(find_sxx) +conf(sxx_common_flags) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/tex.py jalv-1.0.0~dfsg0/waflib/Tools/tex.py --- jalv-0~svn3409/waflib/Tools/tex.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/tex.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,242 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,re +from waflib import Utils,Task,Errors +from waflib.TaskGen import feature,before_method +from waflib.Logs import error,warn,debug +re_bibunit=re.compile(r'\\(?Pputbib)\[(?P[^\[\]]*)\]',re.M) +def bibunitscan(self): + node=self.inputs[0] + nodes=[] + if not node:return nodes + code=Utils.readf(node.abspath()) + for match in re_bibunit.finditer(code): + path=match.group('file') + if path: + for k in['','.bib']: + debug('tex: trying %s%s'%(path,k)) + fi=node.parent.find_resource(path+k) + if fi: + nodes.append(fi) + else: + debug('tex: could not find %s'%path) + debug("tex: found the following bibunit files: %s"%nodes) + return nodes +exts_deps_tex=['','.ltx','.tex','.bib','.pdf','.png','.eps','.ps'] +exts_tex=['.ltx','.tex'] +re_tex=re.compile(r'\\(?Pinclude|bibliography|putbib|includegraphics|input|import|bringin|lstinputlisting)(\[[^\[\]]*\])?{(?P[^{}]*)}',re.M) +g_bibtex_re=re.compile('bibdata',re.M) +class tex(Task.Task): + bibtex_fun,_=Task.compile_fun('${BIBTEX} ${BIBTEXFLAGS} ${SRCFILE}',shell=False) + bibtex_fun.__doc__=""" + Execute the program **bibtex** + """ + makeindex_fun,_=Task.compile_fun('${MAKEINDEX} ${MAKEINDEXFLAGS} ${SRCFILE}',shell=False) + makeindex_fun.__doc__=""" + Execute the program **makeindex** + """ + def scan_aux(self,node): + nodes=[node] + re_aux=re.compile(r'\\@input{(?P[^{}]*)}',re.M) + def parse_node(node): + code=node.read() + for match in re_aux.finditer(code): + path=match.group('file') + found=node.parent.find_or_declare(path) + if found and found not in nodes: + debug('tex: found aux node '+found.abspath()) + nodes.append(found) + parse_node(found) + parse_node(node) + return nodes + def scan(self): + node=self.inputs[0] + nodes=[] + names=[] + seen=[] + if not node:return(nodes,names) + def parse_node(node): + if node in seen: + return + seen.append(node) + code=node.read() + global re_tex + for match in re_tex.finditer(code): + for path in match.group('file').split(','): + if path: + add_name=True + found=None + for k in exts_deps_tex: + debug('tex: trying %s%s'%(path,k)) + found=node.parent.find_resource(path+k) + if found and not found in self.outputs: + nodes.append(found) + add_name=False + for ext in exts_tex: + if found.name.endswith(ext): + parse_node(found) + break + if add_name: + names.append(path) + parse_node(node) + for x in nodes: + x.parent.get_bld().mkdir() + debug("tex: found the following : %s and names %s"%(nodes,names)) + return(nodes,names) + def check_status(self,msg,retcode): + if retcode!=0: + raise Errors.WafError("%r command exit status %r"%(msg,retcode)) + def bibfile(self): + need_bibtex=False + try: + for aux_node in self.aux_nodes: + ct=aux_node.read() + if g_bibtex_re.findall(ct): + need_bibtex=True + break + except(OSError,IOError): + error('error bibtex scan') + else: + if need_bibtex: + warn('calling bibtex') + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=self.aux_nodes[0].name[:-4] + self.check_status('error when calling bibtex',self.bibtex_fun()) + def bibunits(self): + try: + bibunits=bibunitscan(self) + except FSError: + error('error bibunitscan') + else: + if bibunits: + fn=['bu'+str(i)for i in xrange(1,len(bibunits)+1)] + if fn: + warn('calling bibtex on bibunits') + for f in fn: + self.env.env={'BIBINPUTS':self.TEXINPUTS,'BSTINPUTS':self.TEXINPUTS} + self.env.SRCFILE=f + self.check_status('error when calling bibtex',self.bibtex_fun()) + def makeindex(self): + try: + idx_path=self.idx_node.abspath() + os.stat(idx_path) + except OSError: + warn('index file %s absent, not calling makeindex'%idx_path) + else: + warn('calling makeindex') + self.env.SRCFILE=self.idx_node.name + self.env.env={} + self.check_status('error when calling makeindex %s'%idx_path,self.makeindex_fun()) + def run(self): + env=self.env + if not env['PROMPT_LATEX']: + env.append_value('LATEXFLAGS','-interaction=batchmode') + env.append_value('PDFLATEXFLAGS','-interaction=batchmode') + env.append_value('XELATEXFLAGS','-interaction=batchmode') + fun=self.texfun + node=self.inputs[0] + srcfile=node.abspath() + texinputs=self.env.TEXINPUTS or'' + self.TEXINPUTS=node.parent.get_bld().abspath()+os.pathsep+node.parent.get_src().abspath()+os.pathsep+texinputs+os.pathsep + self.aux_node=node.change_ext('.aux') + self.cwd=self.inputs[0].parent.get_bld().abspath() + warn('first pass on %s'%self.__class__.__name__) + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'TEXINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=srcfile + self.check_status('error when calling latex',fun()) + self.aux_nodes=self.scan_aux(node.change_ext('.aux')) + self.idx_node=node.change_ext('.idx') + self.bibfile() + self.bibunits() + self.makeindex() + hash='' + for i in range(10): + prev_hash=hash + try: + hashes=[Utils.h_file(x.abspath())for x in self.aux_nodes] + hash=Utils.h_list(hashes) + except(OSError,IOError): + error('could not read aux.h') + pass + if hash and hash==prev_hash: + break + warn('calling %s'%self.__class__.__name__) + self.env.env={} + self.env.env.update(os.environ) + self.env.env.update({'TEXINPUTS':self.TEXINPUTS}) + self.env.SRCFILE=srcfile + self.check_status('error when calling %s'%self.__class__.__name__,fun()) +class latex(tex): + texfun,vars=Task.compile_fun('${LATEX} ${LATEXFLAGS} ${SRCFILE}',shell=False) +class pdflatex(tex): + texfun,vars=Task.compile_fun('${PDFLATEX} ${PDFLATEXFLAGS} ${SRCFILE}',shell=False) +class xelatex(tex): + texfun,vars=Task.compile_fun('${XELATEX} ${XELATEXFLAGS} ${SRCFILE}',shell=False) +class dvips(Task.Task): + run_str='${DVIPS} ${DVIPSFLAGS} ${SRC} -o ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +class dvipdf(Task.Task): + run_str='${DVIPDF} ${DVIPDFFLAGS} ${SRC} ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +class pdf2ps(Task.Task): + run_str='${PDF2PS} ${PDF2PSFLAGS} ${SRC} ${TGT}' + color='BLUE' + after=['latex','pdflatex','xelatex'] +def apply_tex(self): + if not getattr(self,'type',None)in['latex','pdflatex','xelatex']: + self.type='pdflatex' + tree=self.bld + outs=Utils.to_list(getattr(self,'outs',[])) + self.env['PROMPT_LATEX']=getattr(self,'prompt',1) + deps_lst=[] + if getattr(self,'deps',None): + deps=self.to_list(self.deps) + for filename in deps: + n=self.path.find_resource(filename) + if not n in deps_lst:deps_lst.append(n) + for node in self.to_nodes(self.source): + if self.type=='latex': + task=self.create_task('latex',node,node.change_ext('.dvi')) + elif self.type=='pdflatex': + task=self.create_task('pdflatex',node,node.change_ext('.pdf')) + elif self.type=='xelatex': + task=self.create_task('xelatex',node,node.change_ext('.pdf')) + task.env=self.env + if deps_lst: + try: + lst=tree.node_deps[task.uid()] + for n in deps_lst: + if not n in lst: + lst.append(n) + except KeyError: + tree.node_deps[task.uid()]=deps_lst + if self.type=='latex': + if'ps'in outs: + tsk=self.create_task('dvips',task.outputs,node.change_ext('.ps')) + tsk.env.env={'TEXINPUTS':node.parent.abspath()+os.pathsep+self.path.abspath()+os.pathsep+self.path.get_bld().abspath()} + if'pdf'in outs: + tsk=self.create_task('dvipdf',task.outputs,node.change_ext('.pdf')) + tsk.env.env={'TEXINPUTS':node.parent.abspath()+os.pathsep+self.path.abspath()+os.pathsep+self.path.get_bld().abspath()} + elif self.type=='pdflatex': + if'ps'in outs: + self.create_task('pdf2ps',task.outputs,node.change_ext('.ps')) + self.source=[] +def configure(self): + v=self.env + for p in'tex latex pdflatex xelatex bibtex dvips dvipdf ps2pdf makeindex pdf2ps'.split(): + try: + self.find_program(p,var=p.upper()) + except self.errors.ConfigurationError: + pass + v['DVIPSFLAGS']='-Ppdf' + +feature('tex')(apply_tex) +before_method('process_source')(apply_tex) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/vala.py jalv-1.0.0~dfsg0/waflib/Tools/vala.py --- jalv-0~svn3409/waflib/Tools/vala.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/vala.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,216 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os.path,shutil,re +from waflib import Context,Task,Utils,Logs,Options,Errors +from waflib.TaskGen import extension +from waflib.Configure import conf +class valac(Task.Task): + vars=["VALAC","VALAC_VERSION","VALAFLAGS"] + ext_out=['.h'] + def run(self): + env=self.env + cmd=[env['VALAC'],'-C','--quiet'] + cmd.extend(Utils.to_list(env['VALAFLAGS'])) + if self.threading: + cmd.append('--thread') + if self.profile: + cmd.append('--profile=%s'%self.profile) + if self.target_glib: + cmd.append('--target-glib=%s'%self.target_glib) + if self.is_lib: + cmd.append('--library='+self.target) + for x in self.outputs: + if x.name.endswith('.h'): + cmd.append('--header='+x.name) + if self.gir: + cmd.append('--gir=%s.gir'%self.gir) + for vapi_dir in self.vapi_dirs: + cmd.append('--vapidir=%s'%vapi_dir) + for package in self.packages: + cmd.append('--pkg=%s'%package) + for package in self.packages_private: + cmd.append('--pkg=%s'%package) + for define in self.vala_defines: + cmd.append('--define=%s'%define) + cmd.extend([a.abspath()for a in self.inputs]) + ret=self.exec_command(cmd,cwd=self.outputs[0].parent.abspath()) + if ret: + return ret + for x in self.outputs: + if id(x.parent)!=id(self.outputs[0].parent): + shutil.move(self.outputs[0].parent.abspath()+os.sep+x.name,x.abspath()) + if self.packages and getattr(self,'deps_node',None): + self.deps_node.write('\n'.join(self.packages)) + return ret +def vala_file(self,node): + valatask=getattr(self,"valatask",None) + if not valatask: + def _get_api_version(): + api_version='1.0' + if hasattr(Context.g_module,'API_VERSION'): + version=Context.g_module.API_VERSION.split(".") + if version[0]=="0": + api_version="0."+version[1] + else: + api_version=version[0]+".0" + return api_version + valatask=self.create_task('valac') + self.valatask=valatask + self.includes=Utils.to_list(getattr(self,'includes',[])) + self.uselib=self.to_list(getattr(self,'uselib',[])) + valatask.packages=[] + valatask.packages_private=Utils.to_list(getattr(self,'packages_private',[])) + valatask.vapi_dirs=[] + valatask.target=self.target + valatask.threading=False + valatask.install_path=getattr(self,'install_path','') + valatask.profile=getattr(self,'profile','gobject') + valatask.vala_defines=getattr(self,'vala_defines',[]) + valatask.target_glib=None + valatask.gir=getattr(self,'gir',None) + valatask.gir_path=getattr(self,'gir_path','${DATAROOTDIR}/gir-1.0') + valatask.vapi_path=getattr(self,'vapi_path','${DATAROOTDIR}/vala/vapi') + valatask.pkg_name=getattr(self,'pkg_name',self.env['PACKAGE']) + valatask.header_path=getattr(self,'header_path','${INCLUDEDIR}/%s-%s'%(valatask.pkg_name,_get_api_version())) + valatask.install_binding=getattr(self,'install_binding',True) + valatask.is_lib=False + if not'cprogram'in self.features: + valatask.is_lib=True + packages=Utils.to_list(getattr(self,'packages',[])) + vapi_dirs=Utils.to_list(getattr(self,'vapi_dirs',[])) + includes=[] + if hasattr(self,'use'): + local_packages=Utils.to_list(self.use)[:] + seen=[] + while len(local_packages)>0: + package=local_packages.pop() + if package in seen: + continue + seen.append(package) + try: + package_obj=self.bld.get_tgen_by_name(package) + except Errors.WafError: + continue + package_name=package_obj.target + package_node=package_obj.path + package_dir=package_node.path_from(self.path) + for task in package_obj.tasks: + for output in task.outputs: + if output.name==package_name+".vapi": + valatask.set_run_after(task) + if package_name not in packages: + packages.append(package_name) + if package_dir not in vapi_dirs: + vapi_dirs.append(package_dir) + if package_dir not in includes: + includes.append(package_dir) + if hasattr(package_obj,'use'): + lst=self.to_list(package_obj.use) + lst.reverse() + local_packages=[pkg for pkg in lst if pkg not in seen]+local_packages + valatask.packages=packages + for vapi_dir in vapi_dirs: + try: + valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).abspath()) + valatask.vapi_dirs.append(self.path.find_dir(vapi_dir).get_bld().abspath()) + except AttributeError: + Logs.warn("Unable to locate Vala API directory: '%s'"%vapi_dir) + self.includes.append(self.bld.srcnode.abspath()) + self.includes.append(self.bld.bldnode.abspath()) + for include in includes: + try: + self.includes.append(self.path.find_dir(include).abspath()) + self.includes.append(self.path.find_dir(include).get_bld().abspath()) + except AttributeError: + Logs.warn("Unable to locate include directory: '%s'"%include) + if valatask.profile=='gobject': + if hasattr(self,'target_glib'): + Logs.warn('target_glib on vala tasks is not supported --vala-target-glib=MAJOR.MINOR from the vala tool options') + if getattr(Options.options,'vala_target_glib',None): + valatask.target_glib=Options.options.vala_target_glib + if not'GOBJECT'in self.uselib: + self.uselib.append('GOBJECT') + if hasattr(self,'threading'): + if valatask.profile=='gobject': + valatask.threading=self.threading + if not'GTHREAD'in self.uselib: + self.uselib.append('GTHREAD') + else: + Logs.warn("Profile %s does not have threading support"%valatask.profile) + if valatask.is_lib: + valatask.outputs.append(self.path.find_or_declare('%s.h'%self.target)) + valatask.outputs.append(self.path.find_or_declare('%s.vapi'%self.target)) + if valatask.gir: + valatask.outputs.append(self.path.find_or_declare('%s.gir'%self.gir)) + if valatask.packages: + d=self.path.find_or_declare('%s.deps'%self.target) + valatask.outputs.append(d) + valatask.deps_node=d + valatask.inputs.append(node) + c_node=node.change_ext('.c') + valatask.outputs.append(c_node) + self.source.append(c_node) + if valatask.is_lib and valatask.install_binding: + headers_list=[o for o in valatask.outputs if o.suffix()==".h"] + try: + self.install_vheader.source=headers_list + except AttributeError: + self.install_vheader=self.bld.install_files(valatask.header_path,headers_list,self.env) + vapi_list=[o for o in valatask.outputs if(o.suffix()in(".vapi",".deps"))] + try: + self.install_vapi.source=vapi_list + except AttributeError: + self.install_vapi=self.bld.install_files(valatask.vapi_path,vapi_list,self.env) + gir_list=[o for o in valatask.outputs if o.suffix()==".gir"] + try: + self.install_gir.source=gir_list + except AttributeError: + self.install_gir=self.bld.install_files(valatask.gir_path,gir_list,self.env) +valac=Task.update_outputs(valac) +def find_valac(self,valac_name,min_version): + valac=self.find_program(valac_name,var='VALAC') + try: + output=self.cmd_and_log(valac+' --version') + except Exception: + valac_version=None + else: + ver=re.search(r'\d+.\d+.\d+',output).group(0).split('.') + valac_version=tuple([int(x)for x in ver]) + self.msg('Checking for %s version >= %r'%(valac_name,min_version),valac_version,valac_version and valac_version>=min_version) + if valac and valac_version= %r"%(valac_name,valac_version,min_version)) + self.env['VALAC_VERSION']=valac_version + return valac +def check_vala(self,min_version=(0,8,0),branch=None): + if not branch: + branch=min_version[:2] + try: + find_valac(self,'valac-%d.%d'%(branch[0],branch[1]),min_version) + except self.errors.ConfigurationError: + find_valac(self,'valac',min_version) +def check_vala_deps(self): + if not self.env['HAVE_GOBJECT']: + pkg_args={'package':'gobject-2.0','uselib_store':'GOBJECT','args':'--cflags --libs'} + if getattr(Options.options,'vala_target_glib',None): + pkg_args['atleast_version']=Options.options.vala_target_glib + self.check_cfg(**pkg_args) + if not self.env['HAVE_GTHREAD']: + pkg_args={'package':'gthread-2.0','uselib_store':'GTHREAD','args':'--cflags --libs'} + if getattr(Options.options,'vala_target_glib',None): + pkg_args['atleast_version']=Options.options.vala_target_glib + self.check_cfg(**pkg_args) +def configure(self): + self.load('gnu_dirs') + self.check_vala_deps() + self.check_vala() +def options(opt): + opt.load('gnu_dirs') + valaopts=opt.add_option_group('Vala Compiler Options') + valaopts.add_option('--vala-target-glib',default=None,dest='vala_target_glib',metavar='MAJOR.MINOR',help='Target version of glib for Vala GObject code generation') + +extension('.vala','.gs')(vala_file) +conf(find_valac) +conf(check_vala) +conf(check_vala_deps) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/waf_unit_test.py jalv-1.0.0~dfsg0/waflib/Tools/waf_unit_test.py --- jalv-0~svn3409/waflib/Tools/waf_unit_test.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/waf_unit_test.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,79 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys +from waflib.TaskGen import feature,after_method +from waflib import Utils,Task,Logs,Options +testlock=Utils.threading.Lock() +def make_test(self): + if getattr(self,'link_task',None): + self.create_task('utest',self.link_task.outputs) +class utest(Task.Task): + color='PINK' + after=['vnum','inst'] + vars=[] + def runnable_status(self): + ret=super(utest,self).runnable_status() + if ret==Task.SKIP_ME: + if getattr(Options.options,'all_tests',False): + return Task.RUN_ME + return ret + def run(self): + filename=self.inputs[0].abspath() + self.ut_exec=getattr(self,'ut_exec',[filename]) + if getattr(self.generator,'ut_fun',None): + self.generator.ut_fun(self) + try: + fu=getattr(self.generator.bld,'all_test_paths') + except AttributeError: + fu=os.environ.copy() + self.generator.bld.all_test_paths=fu + lst=[] + for g in self.generator.bld.groups: + for tg in g: + if getattr(tg,'link_task',None): + lst.append(tg.link_task.outputs[0].parent.abspath()) + def add_path(dct,path,var): + dct[var]=os.pathsep.join(Utils.to_list(path)+[os.environ.get(var,'')]) + if Utils.is_win32: + add_path(fu,lst,'PATH') + elif Utils.unversioned_sys_platform()=='darwin': + add_path(fu,lst,'DYLD_LIBRARY_PATH') + add_path(fu,lst,'LD_LIBRARY_PATH') + else: + add_path(fu,lst,'LD_LIBRARY_PATH') + cwd=getattr(self.generator,'ut_cwd','')or self.inputs[0].parent.abspath() + proc=Utils.subprocess.Popen(self.ut_exec,cwd=cwd,env=fu,stderr=Utils.subprocess.PIPE,stdout=Utils.subprocess.PIPE) + (stdout,stderr)=proc.communicate() + tup=(filename,proc.returncode,stdout,stderr) + self.generator.utest_result=tup + testlock.acquire() + try: + bld=self.generator.bld + Logs.debug("ut: %r",tup) + try: + bld.utest_results.append(tup) + except AttributeError: + bld.utest_results=[tup] + finally: + testlock.release() +def summary(bld): + lst=getattr(bld,'utest_results',[]) + if lst: + Logs.pprint('CYAN','execution summary') + total=len(lst) + tfail=len([x for x in lst if x[1]]) + Logs.pprint('CYAN',' tests that pass %d/%d'%(total-tfail,total)) + for(f,code,out,err)in lst: + if not code: + Logs.pprint('CYAN',' %s'%f) + Logs.pprint('CYAN',' tests that fail %d/%d'%(tfail,total)) + for(f,code,out,err)in lst: + if code: + Logs.pprint('CYAN',' %s'%f) +def options(opt): + opt.add_option('--alltests',action='store_true',default=False,help='Exec all unit tests',dest='all_tests') + +feature('test')(make_test) +after_method('apply_link')(make_test) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/winres.py jalv-1.0.0~dfsg0/waflib/Tools/winres.py --- jalv-0~svn3409/waflib/Tools/winres.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/winres.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,34 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib import Task +from waflib.TaskGen import extension +def rc_file(self,node): + obj_ext='.rc.o' + if self.env['WINRC_TGT_F']=='/fo': + obj_ext='.res' + rctask=self.create_task('winrc',node,node.change_ext(obj_ext)) + try: + self.compiled_tasks.append(rctask) + except AttributeError: + self.compiled_tasks=[rctask] +class winrc(Task.Task): + run_str='${WINRC} ${WINRCFLAGS} ${CPPPATH_ST:INCPATHS} ${DEFINES_ST:DEFINES} ${WINRC_TGT_F} ${TGT} ${WINRC_SRC_F} ${SRC}' + color='BLUE' +def configure(conf): + v=conf.env + v['WINRC_TGT_F']='-o' + v['WINRC_SRC_F']='-i' + if not conf.env.WINRC: + if v.CC_NAME=='msvc': + conf.find_program('RC',var='WINRC',path_list=v['PATH']) + v['WINRC_TGT_F']='/fo' + v['WINRC_SRC_F']='' + else: + conf.find_program('windres',var='WINRC',path_list=v['PATH']) + if not conf.env.WINRC: + conf.fatal('winrc was not found!') + v['WINRCFLAGS']=[] + +extension('.rc')(rc_file) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/xlc.py jalv-1.0.0~dfsg0/waflib/Tools/xlc.py --- jalv-0~svn3409/waflib/Tools/xlc.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/xlc.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,46 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_xlc(conf): + cc=conf.find_program(['xlc_r','xlc'],var='CC') + cc=conf.cmd_to_list(cc) + conf.get_xlc_version(cc) + conf.env.CC_NAME='xlc' + conf.env.CC=cc +def xlc_common_flags(conf): + v=conf.env + v['CC_SRC_F']=[] + v['CC_TGT_F']=['-c','-o'] + if not v['LINK_CC']:v['LINK_CC']=v['CC'] + v['CCLNK_SRC_F']=[] + v['CCLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['LINKFLAGS_cprogram']=['-Wl,-brtl'] + v['cprogram_PATTERN']='%s' + v['CFLAGS_cshlib']=['-fPIC'] + v['LINKFLAGS_cshlib']=['-G','-Wl,-brtl,-bexpfull'] + v['cshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cstlib']=[] + v['cstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_xlc() + conf.find_ar() + conf.xlc_common_flags() + conf.cc_load_tools() + conf.cc_add_flags() + conf.link_add_flags() + +conf(find_xlc) +conf(xlc_common_flags) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Tools/xlcxx.py jalv-1.0.0~dfsg0/waflib/Tools/xlcxx.py --- jalv-0~svn3409/waflib/Tools/xlcxx.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Tools/xlcxx.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,46 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +from waflib.Tools import ccroot,ar +from waflib.Configure import conf +def find_xlcxx(conf): + cxx=conf.find_program(['xlc++_r','xlc++'],var='CXX') + cxx=conf.cmd_to_list(cxx) + conf.get_xlc_version(cxx) + conf.env.CXX_NAME='xlc++' + conf.env.CXX=cxx +def xlcxx_common_flags(conf): + v=conf.env + v['CXX_SRC_F']=[] + v['CXX_TGT_F']=['-c','-o'] + if not v['LINK_CXX']:v['LINK_CXX']=v['CXX'] + v['CXXLNK_SRC_F']=[] + v['CXXLNK_TGT_F']=['-o'] + v['CPPPATH_ST']='-I%s' + v['DEFINES_ST']='-D%s' + v['LIB_ST']='-l%s' + v['LIBPATH_ST']='-L%s' + v['STLIB_ST']='-l%s' + v['STLIBPATH_ST']='-L%s' + v['RPATH_ST']='-Wl,-rpath,%s' + v['SONAME_ST']=[] + v['SHLIB_MARKER']=[] + v['STLIB_MARKER']=[] + v['LINKFLAGS_cxxprogram']=['-Wl,-brtl'] + v['cxxprogram_PATTERN']='%s' + v['CXXFLAGS_cxxshlib']=['-fPIC'] + v['LINKFLAGS_cxxshlib']=['-G','-Wl,-brtl,-bexpfull'] + v['cxxshlib_PATTERN']='lib%s.so' + v['LINKFLAGS_cxxstlib']=[] + v['cxxstlib_PATTERN']='lib%s.a' +def configure(conf): + conf.find_xlcxx() + conf.find_ar() + conf.xlcxx_common_flags() + conf.cxx_load_tools() + conf.cxx_add_flags() + conf.link_add_flags() + +conf(find_xlcxx) +conf(xlcxx_common_flags) \ No newline at end of file diff -Nru jalv-0~svn3409/waflib/Utils.py jalv-1.0.0~dfsg0/waflib/Utils.py --- jalv-0~svn3409/waflib/Utils.py 1970-01-01 00:00:00.000000000 +0000 +++ jalv-1.0.0~dfsg0/waflib/Utils.py 2012-05-05 00:38:21.000000000 +0000 @@ -0,0 +1,336 @@ +#! /usr/bin/env python +# encoding: utf-8 +# WARNING! Do not edit! http://waf.googlecode.com/git/docs/wafbook/single.html#_obtaining_the_waf_file + +import os,sys,errno,traceback,inspect,re,shutil,datetime,gc +try: + import subprocess +except: + try: + import waflib.extras.subprocess as subprocess + except: + print("The subprocess module is missing (python2.3?):\n try calling 'waf update --files=subprocess'\n or add a copy of subprocess.py to the python libraries") +try: + from collections import deque +except ImportError: + class deque(list): + def popleft(self): + return self.pop(0) +try: + import _winreg as winreg +except: + try: + import winreg + except: + winreg=None +from waflib import Errors +try: + from collections import UserDict +except: + from UserDict import UserDict +try: + from hashlib import md5 +except: + try: + from md5 import md5 + except: + pass +try: + import threading +except: + class threading(object): + pass + class Lock(object): + def acquire(self): + pass + def release(self): + pass + threading.Lock=threading.Thread=Lock +else: + run_old=threading.Thread.run + def run(*args,**kwargs): + try: + run_old(*args,**kwargs) + except(KeyboardInterrupt,SystemExit): + raise + except: + sys.excepthook(*sys.exc_info()) + threading.Thread.run=run +SIG_NIL='iluvcuteoverload' +O644=420 +O755=493 +rot_chr=['\\','|','/','-'] +rot_idx=0 +try: + from collections import defaultdict +except ImportError: + class defaultdict(dict): + def __init__(self,default_factory): + super(defaultdict,self).__init__() + self.default_factory=default_factory + def __getitem__(self,key): + try: + return super(defaultdict,self).__getitem__(key) + except KeyError: + value=self.default_factory() + self[key]=value + return value +is_win32=sys.platform in('win32','cli') +indicator='\x1b[K%s%s%s\r' +if is_win32 and'NOCOLOR'in os.environ: + indicator='%s%s%s\r' +def readf(fname,m='r'): + f=open(fname,m) + try: + txt=f.read() + finally: + f.close() + return txt +def h_file(filename): + f=open(filename,'rb') + m=md5() + try: + while filename: + filename=f.read(100000) + m.update(filename) + finally: + f.close() + return m.digest() +try: + x=''.encode('hex') +except: + import binascii + def to_hex(s): + ret=binascii.hexlify(s) + if not isinstance(ret,str): + ret=ret.decode('utf-8') + return ret +else: + def to_hex(s): + return s.encode('hex') +to_hex.__doc__=""" +Return the hexadecimal representation of a string + +:param s: string to convert +:type s: string +""" +listdir=os.listdir +if is_win32: + def listdir_win32(s): + if not s: + try: + import ctypes + except: + return[x+':\\'for x in list('ABCDEFGHIJKLMNOPQRSTUVWXYZ')] + else: + dlen=4 + maxdrives=26 + buf=ctypes.create_string_buffer(maxdrives*dlen) + ndrives=ctypes.windll.kernel32.GetLogicalDriveStringsA(maxdrives,ctypes.byref(buf)) + return[buf.raw[4*i:4*i+3].decode('ascii')for i in range(int(ndrives/dlen))] + if len(s)==2 and s[1]==":": + s+=os.sep + if not os.path.isdir(s): + e=OSError() + e.errno=errno.ENOENT + raise e + return os.listdir(s) + listdir=listdir_win32 +def num2ver(ver): + if isinstance(ver,str): + ver=tuple(ver.split('.')) + if isinstance(ver,tuple): + ret=0 + for i in range(4): + if i