[hamradio-commits] [lysdr] 01/02: Imported Upstream version 1.0~git20141012+dfsg1
Iain Learmonth
irl-guest at moszumanska.debian.org
Sun Oct 12 17:43:43 UTC 2014
This is an automated email from the git hooks/post-receive script.
irl-guest pushed a commit to branch master
in repository lysdr.
commit 91e191ffb95d704087a2a617e76f59ceabb7a062
Author: Iain R. Learmonth <irl at fsfe.org>
Date: Sun Oct 12 16:40:28 2014 +0100
Imported Upstream version 1.0~git20141012+dfsg1
---
ChangeLog | 5 +
LICENSE | 674 +++++++++++++++++++++++++++++++++++++
README | 67 ++++
audio_jack.c | 171 ++++++++++
audio_jack.h | 32 ++
colourmap.h | 39 +++
filter.c | 195 +++++++++++
filter.h | 58 ++++
gui.c | 261 +++++++++++++++
hilbert.h | 31 ++
lysdr.c | 152 +++++++++
lysdr.h | 35 ++
notes | 4 +
package_info/archlinux/PKGBUILD | 46 +++
sdr.c | 163 +++++++++
sdr.h | 84 +++++
smeter.c | 96 ++++++
smeter.h | 62 ++++
waf | 162 +++++++++
waflib/Build.py | 720 ++++++++++++++++++++++++++++++++++++++++
waflib/ConfigSet.py | 145 ++++++++
waflib/Configure.py | 314 ++++++++++++++++++
waflib/Context.py | 302 +++++++++++++++++
waflib/Errors.py | 37 +++
waflib/Logs.py | 147 ++++++++
waflib/Node.py | 492 +++++++++++++++++++++++++++
waflib/Options.py | 127 +++++++
waflib/Runner.py | 192 +++++++++++
waflib/Scripting.py | 355 ++++++++++++++++++++
waflib/Task.py | 650 ++++++++++++++++++++++++++++++++++++
waflib/TaskGen.py | 332 ++++++++++++++++++
waflib/Tools/__init__.py | 4 +
waflib/Tools/ar.py | 13 +
waflib/Tools/asm.py | 25 ++
waflib/Tools/bison.py | 29 ++
waflib/Tools/c.py | 26 ++
waflib/Tools/c_aliases.py | 56 ++++
waflib/Tools/c_config.py | 688 ++++++++++++++++++++++++++++++++++++++
waflib/Tools/c_osx.py | 116 +++++++
waflib/Tools/c_preproc.py | 606 +++++++++++++++++++++++++++++++++
waflib/Tools/c_tests.py | 108 ++++++
waflib/Tools/ccroot.py | 298 +++++++++++++++++
waflib/Tools/compiler_c.py | 39 +++
waflib/Tools/compiler_cxx.py | 39 +++
waflib/Tools/compiler_d.py | 30 ++
waflib/Tools/compiler_fc.py | 45 +++
waflib/Tools/cs.py | 98 ++++++
waflib/Tools/cxx.py | 26 ++
waflib/Tools/d.py | 51 +++
waflib/Tools/d_config.py | 47 +++
waflib/Tools/d_scan.py | 133 ++++++++
waflib/Tools/dbus.py | 30 ++
waflib/Tools/dmd.py | 43 +++
waflib/Tools/errcheck.py | 131 ++++++++
waflib/Tools/fc.py | 123 +++++++
waflib/Tools/fc_config.py | 273 +++++++++++++++
waflib/Tools/fc_scan.py | 68 ++++
waflib/Tools/flex.py | 27 ++
waflib/Tools/g95.py | 55 +++
waflib/Tools/gas.py | 10 +
waflib/Tools/gcc.py | 98 ++++++
waflib/Tools/gdc.py | 34 ++
waflib/Tools/gfortran.py | 69 ++++
waflib/Tools/glib2.py | 174 ++++++++++
waflib/Tools/gnu_dirs.py | 64 ++++
waflib/Tools/gxx.py | 98 ++++++
waflib/Tools/icc.py | 31 ++
waflib/Tools/icpc.py | 30 ++
waflib/Tools/ifort.py | 42 +++
waflib/Tools/intltool.py | 78 +++++
waflib/Tools/irixcc.py | 49 +++
waflib/Tools/javaw.py | 263 +++++++++++++++
waflib/Tools/kde4.py | 49 +++
waflib/Tools/lua.py | 19 ++
waflib/Tools/msvc.py | 608 +++++++++++++++++++++++++++++++++
waflib/Tools/nasm.py | 13 +
waflib/Tools/perl.py | 79 +++++
waflib/Tools/python.py | 282 ++++++++++++++++
waflib/Tools/qt4.py | 348 +++++++++++++++++++
waflib/Tools/ruby.py | 88 +++++
waflib/Tools/suncc.py | 54 +++
waflib/Tools/suncxx.py | 55 +++
waflib/Tools/tex.py | 221 ++++++++++++
waflib/Tools/vala.py | 216 ++++++++++++
waflib/Tools/waf_unit_test.py | 80 +++++
waflib/Tools/winres.py | 35 ++
waflib/Tools/xlc.py | 46 +++
waflib/Tools/xlcxx.py | 46 +++
waflib/Utils.py | 328 ++++++++++++++++++
waflib/__init__.py | 4 +
waflib/ansiterm.py | 174 ++++++++++
waflib/extras/__init__.py | 4 +
waflib/extras/boost.py | 185 +++++++++++
waflib/extras/compat15.py | 223 +++++++++++++
waflib/extras/cython.py | 77 +++++
waflib/extras/erlang.py | 9 +
waflib/extras/go.py | 181 ++++++++++
waflib/extras/ocaml.py | 242 ++++++++++++++
waflib/extras/pep8.py | 73 ++++
waflib/extras/scala.py | 93 ++++++
waflib/fixpy2.py | 50 +++
waterfall.c | 612 ++++++++++++++++++++++++++++++++++
waterfall.h | 117 +++++++
wscript | 38 +++
104 files changed, 15066 insertions(+)
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..315afe6
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,5 @@
+Fri Jan 21 23:33:34 GMT 2011
+Added 'package_info' directory, for packaging scripts
+
+Tue Feb 15 20:12:57 GMT 2011
+Bugfix as pointed out by Diane VA3DB
diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..94a9ed0
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,674 @@
+ GNU GENERAL PUBLIC LICENSE
+ Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+ Preamble
+
+ The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+ The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works. By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users. We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors. You can apply it to
+your programs, too.
+
+ When we speak of free software, we are referring to freedom, not
+price. Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+ To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights. Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+ For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received. You must make sure that they, too, receive
+or can get the source code. And you must show them these terms so they
+know their rights.
+
+ Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+ For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software. For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+ Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so. This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software. The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable. Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products. If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+ Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary. To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+ The precise terms and conditions for copying, distribution and
+modification follow.
+
+ TERMS AND CONDITIONS
+
+ 0. Definitions.
+
+ "This License" refers to version 3 of the GNU General Public License.
+
+ "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+ "The Program" refers to any copyrightable work licensed under this
+License. Each licensee is addressed as "you". "Licensees" and
+"recipients" may be individuals or organizations.
+
+ To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy. The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+ A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+ To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy. Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+ To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies. Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+ An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License. If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+ 1. Source Code.
+
+ The "source code" for a work means the preferred form of the work
+for making modifications to it. "Object code" means any non-source
+form of a work.
+
+ A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+ The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form. A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+ The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities. However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work. For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+ The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+ The Corresponding Source for a work in source code form is that
+same work.
+
+ 2. Basic Permissions.
+
+ All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met. This License explicitly affirms your unlimited
+permission to run the unmodified Program. The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work. This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+ You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force. You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright. Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+ Conveying under any other circumstances is permitted solely under
+the conditions stated below. Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+ No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+ When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+ 4. Conveying Verbatim Copies.
+
+ You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+ You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+ 5. Conveying Modified Source Versions.
+
+ You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+ a) The work must carry prominent notices stating that you modified
+ it, and giving a relevant date.
+
+ b) The work must carry prominent notices stating that it is
+ released under this License and any conditions added under section
+ 7. This requirement modifies the requirement in section 4 to
+ "keep intact all notices".
+
+ c) You must license the entire work, as a whole, under this
+ License to anyone who comes into possession of a copy. This
+ License will therefore apply, along with any applicable section 7
+ additional terms, to the whole of the work, and all its parts,
+ regardless of how they are packaged. This License gives no
+ permission to license the work in any other way, but it does not
+ invalidate such permission if you have separately received it.
+
+ d) If the work has interactive user interfaces, each must display
+ Appropriate Legal Notices; however, if the Program has interactive
+ interfaces that do not display Appropriate Legal Notices, your
+ work need not make them do so.
+
+ A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit. Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+ 6. Conveying Non-Source Forms.
+
+ You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+ a) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by the
+ Corresponding Source fixed on a durable physical medium
+ customarily used for software interchange.
+
+ b) Convey the object code in, or embodied in, a physical product
+ (including a physical distribution medium), accompanied by a
+ written offer, valid for at least three years and valid for as
+ long as you offer spare parts or customer support for that product
+ model, to give anyone who possesses the object code either (1) a
+ copy of the Corresponding Source for all the software in the
+ product that is covered by this License, on a durable physical
+ medium customarily used for software interchange, for a price no
+ more than your reasonable cost of physically performing this
+ conveying of source, or (2) access to copy the
+ Corresponding Source from a network server at no charge.
+
+ c) Convey individual copies of the object code with a copy of the
+ written offer to provide the Corresponding Source. This
+ alternative is allowed only occasionally and noncommercially, and
+ only if you received the object code with such an offer, in accord
+ with subsection 6b.
+
+ d) Convey the object code by offering access from a designated
+ place (gratis or for a charge), and offer equivalent access to the
+ Corresponding Source in the same way through the same place at no
+ further charge. You need not require recipients to copy the
+ Corresponding Source along with the object code. If the place to
+ copy the object code is a network server, the Corresponding Source
+ may be on a different server (operated by you or a third party)
+ that supports equivalent copying facilities, provided you maintain
+ clear directions next to the object code saying where to find the
+ Corresponding Source. Regardless of what server hosts the
+ Corresponding Source, you remain obligated to ensure that it is
+ available for as long as needed to satisfy these requirements.
+
+ e) Convey the object code using peer-to-peer transmission, provided
+ you inform other peers where the object code and Corresponding
+ Source of the work are being offered to the general public at no
+ charge under subsection 6d.
+
+ A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+ A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling. In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage. For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product. A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+ "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source. The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+ If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information. But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+ The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed. Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+ Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+ 7. Additional Terms.
+
+ "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law. If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+ When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it. (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.) You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+ Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+ a) Disclaiming warranty or limiting liability differently from the
+ terms of sections 15 and 16 of this License; or
+
+ b) Requiring preservation of specified reasonable legal notices or
+ author attributions in that material or in the Appropriate Legal
+ Notices displayed by works containing it; or
+
+ c) Prohibiting misrepresentation of the origin of that material, or
+ requiring that modified versions of such material be marked in
+ reasonable ways as different from the original version; or
+
+ d) Limiting the use for publicity purposes of names of licensors or
+ authors of the material; or
+
+ e) Declining to grant rights under trademark law for use of some
+ trade names, trademarks, or service marks; or
+
+ f) Requiring indemnification of licensors and authors of that
+ material by anyone who conveys the material (or modified versions of
+ it) with contractual assumptions of liability to the recipient, for
+ any liability that these contractual assumptions directly impose on
+ those licensors and authors.
+
+ All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10. If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term. If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+ If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+ Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+ 8. Termination.
+
+ You may not propagate or modify a covered work except as expressly
+provided under this License. Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+ However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+ Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+ Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License. If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+ 9. Acceptance Not Required for Having Copies.
+
+ You are not required to accept this License in order to receive or
+run a copy of the Program. Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance. However,
+nothing other than this License grants you permission to propagate or
+modify any covered work. These actions infringe copyright if you do
+not accept this License. Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+ 10. Automatic Licensing of Downstream Recipients.
+
+ Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License. You are not responsible
+for enforcing compliance by third parties with this License.
+
+ An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations. If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+ You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License. For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+ 11. Patents.
+
+ A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based. The
+work thus licensed is called the contributor's "contributor version".
+
+ A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version. For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+ In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement). To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+ If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients. "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+ If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+ A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License. You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+ Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+ 12. No Surrender of Others' Freedom.
+
+ If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License. If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all. For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+ 13. Use with the GNU Affero General Public License.
+
+ Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work. The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+ 14. Revised Versions of this License.
+
+ The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time. Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+ Each version is given a distinguishing version number. If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation. If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+ If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+ Later license versions may give you additional or different
+permissions. However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+ 15. Disclaimer of Warranty.
+
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+ 16. Limitation of Liability.
+
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+ 17. Interpretation of Sections 15 and 16.
+
+ If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+ END OF TERMS AND CONDITIONS
+
+ How to Apply These Terms to Your New Programs
+
+ If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+ To do so, attach the following notices to the program. It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+ <one line to give the program's name and a brief idea of what it does.>
+ Copyright (C) <year> <name of author>
+
+ This program is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+ If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+ <program> Copyright (C) <year> <name of author>
+ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+ This is free software, and you are welcome to redistribute it
+ under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License. Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+ You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+ The GNU General Public License does not permit incorporating your program
+into proprietary programs. If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library. If this is what you want to do, use the GNU Lesser General
+Public License instead of this License. But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
diff --git a/README b/README
new file mode 100644
index 0000000..b7e9c4a
--- /dev/null
+++ b/README
@@ -0,0 +1,67 @@
+lysdr - simple software-defined radio
+
+Requirements: gtk, fftw3 and jack, waf to build
+
+1. Configure with "./waf configure"
+2. Build with "./waf build"
+3. Run with "./build/lysdr"
+
+On startup, lysdr will connect its output to the first two jack physical
+output ports if you pass "--co"
+You will need to connect some sort of IQ source to the inputs - this can
+be either a real live soundcard with some SDR hardware, or a prerecorded
+IQ file. To automatically connect the first two physical input ports on
+startup, pass "--ci" on the command line.
+
+Set the displayed centre frequency with --freq <frequency>
+For the Kanga Finningley with the stock local oscillator crystal, the
+standard centre frequency is:
+80m = 3750000
+
+For the Softrock v6.2 Lite boards, the standard centre frequencies are:
+160m = 1844250
+80m = 3528000
+40m = 7056000
+30m = 10125000
+20m = 14075000
+15m = 21045000
+
+These options may change in a future build.
+
+Example:
+## don't connect anything
+$ ./build/lysdr
+
+## connect both input and output to lysdr
+$ ./build/lysdr --ci --co
+
+When using lysdr along with an digimodes program such as fldigi, it's
+useful for both programs to know what frequency lysdr is tuned to.
+To automate this, you can specify a tuning hook script with the
+--tuning-hook option. When lysdr is tuned to a new frequency, it runs
+the hook script with the following environment variables set:
+
+ LYSDR_FREQ The frequency lysdr is tuned to, in integer Hz
+ LYSDR_MODE "LSB" or "USB"
+ LYSDR_CENTRE The SDR centre frequency, in integer Hz
+ LYSDR_OFFSET lysdr's local oscillator frequency, in integer Hz
+
+This hook script will update fldigi's idea of the frequency when lysdr
+is retuned:
+
+ #!/bin/sh
+ xmlrpc localhost:7362 rig.set_frequency d/$LYSDR_FREQ >/dev/null 2>&1
+
+
+Drag the slider to tune the radio. The number below the slider is the
+frequency offset in Hz from the SDR centre (local oscillator) frequency.
+Right-drag for bandspread tuning (1Hz steps).
+
+Drag the sides of the yellow filter bar to adjust the bandpass filter upper and
+lower edges.
+
+There are dropdowns to select locked, fast and slow AGC, wide and narrow filtering
+and USB/LSB demodulation. There's also a not-very-good S meter.
+
+Please report bugs on the github page at https://github.com/gordonjcp/lysdr
+
diff --git a/audio_jack.c b/audio_jack.c
new file mode 100644
index 0000000..eb20841
--- /dev/null
+++ b/audio_jack.c
@@ -0,0 +1,171 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ audio_jack.c
+ handle setting up and tearing down jack connections
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <jack/jack.h>
+#include <errno.h>
+#include "sdr.h"
+#include "audio_jack.h"
+
+static jack_port_t *I_in;
+static jack_port_t *Q_in;
+static jack_port_t *L_out;
+static jack_port_t *R_out;
+static jack_client_t *client;
+static jack_status_t status;
+static const char *client_name = "lysdr";
+
+static int audio_process(jack_nframes_t nframes, void *psdr) {
+ // actually kick off processing the samples
+ jack_default_audio_sample_t *ii, *qq, *L, *R;
+ int i, n;
+
+ sdr_data_t *sdr;
+ sdr = (sdr_data_t *) psdr; // void* cast back to sdr_data_t*
+
+ // get all four buffers
+ ii = jack_port_get_buffer (I_in, nframes);
+ qq = jack_port_get_buffer (Q_in, nframes);
+ L = jack_port_get_buffer (L_out, nframes);
+ R = jack_port_get_buffer (R_out, nframes);
+
+ // the SDR expects a bunch of complex samples
+
+ for(i = 0; i < nframes; i++) {
+ // uncomment whichever is appropriate
+ sdr->iqSample[i] = ii[i] + I * qq[i]; // I on left
+ // sdr->iqSample[i] = qq[i] + I * ii[i]; // I on right
+ }
+
+ // actually run the SDR for a frame
+
+ sdr_process(sdr);
+
+ // copy the frames to the output
+ for(i = 0; i < nframes; i++) {
+ L[i]=sdr->output[i];
+ R[i]=sdr->output[i];
+ }
+
+ // we're happy, return okay
+ return 0;
+}
+
+int audio_start(sdr_data_t *sdr) {
+ // open a client connection to the JACK server
+ client = jack_client_open (client_name, JackNullOption, &status, NULL);
+ if (client == NULL) {
+
+ fprintf (stderr, "jack_client_open() failed - check jack installation (status %x)\n", status);
+ if (status & JackServerFailed) {
+ fprintf (stderr, "Unable to connect to JACK server\n");
+ }
+ exit (1);
+ }
+ if (status & JackServerStarted) {
+ fprintf (stderr, "JACK server started\n");
+ }
+ if (status & JackNameNotUnique) {
+ client_name = jack_get_client_name(client);
+ fprintf (stderr, "unique name `%s' assigned\n", client_name);
+ }
+
+ // save some info in the SDR
+ sdr->size = jack_get_buffer_size(client);
+ sdr->sample_rate = jack_get_sample_rate(client);
+ sdr->iqSample = g_new0(double complex, sdr->size);
+ sdr->output = g_new0(double, sdr->size);
+ return 0;
+}
+
+int audio_stop(sdr_data_t *sdr) {
+ // remove the connection to the jack server
+ // we may also want to clean up any audio buffers
+ jack_client_close (client);
+ if (sdr->iqSample) g_free(sdr->iqSample);
+ if (sdr->output) g_free(sdr->output);
+
+ return 0;
+}
+
+int audio_connect(sdr_data_t *sdr, gboolean ci, gboolean co) {
+
+ const char **ports;
+ // start processing audio
+ jack_set_process_callback (client, audio_process, sdr);
+ //jack_on_shutdown (client, jack_shutdown, 0);
+
+ I_in = jack_port_register (client, "I input",
+ JACK_DEFAULT_AUDIO_TYPE,
+ JackPortIsInput, 0);
+ Q_in = jack_port_register (client, "Q input",
+ JACK_DEFAULT_AUDIO_TYPE,
+ JackPortIsInput, 0);
+ L_out = jack_port_register (client, "L output",
+ JACK_DEFAULT_AUDIO_TYPE,
+ JackPortIsOutput, 0);
+ R_out = jack_port_register (client, "R output",
+ JACK_DEFAULT_AUDIO_TYPE,
+ JackPortIsOutput, 0);
+ if (jack_activate (client)) {
+ fprintf (stderr, "cannot activate client");
+ exit (1);
+ }
+
+ if (co) {
+ ports = jack_get_ports (client, NULL, NULL,
+ JackPortIsPhysical|JackPortIsInput);
+ if (ports == NULL) {
+ fprintf(stderr, "no physical playback ports\n");
+ exit (1);
+ }
+
+ if (jack_connect (client, jack_port_name (L_out), ports[0])) {
+ fprintf (stderr, "cannot connect output ports\n");
+ }
+ if (jack_connect (client, jack_port_name (R_out), ports[1])) {
+ fprintf (stderr, "cannot connect output ports\n");
+ }
+ free(ports);
+ }
+
+ if (ci) {
+ ports = jack_get_ports (client, NULL, NULL,
+ JackPortIsPhysical|JackPortIsOutput);
+ if (ports == NULL) {
+ fprintf(stderr, "no physical capture ports\n");
+ exit (1);
+ }
+
+ if (jack_connect (client, ports[0], jack_port_name (I_in))) {
+ fprintf (stderr, "cannot connect capture ports\n");
+ }
+ if (jack_connect (client, ports[1], jack_port_name (Q_in))) {
+ fprintf (stderr, "cannot connect capture ports\n");
+ }
+ free(ports);
+ }
+ return 0;
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/audio_jack.h b/audio_jack.h
new file mode 100644
index 0000000..0ea9f25
--- /dev/null
+++ b/audio_jack.h
@@ -0,0 +1,32 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ audio_jack.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __AUDIO_JACK_H
+#define __AUDIO_JACK_H
+#include "sdr.h"
+
+extern int audio_connect(sdr_data_t *sdr, gboolean ci, gboolean co);
+extern int audio_start(sdr_data_t *sdr);
+extern int audio_stop(sdr_data_t *sdr);
+
+#endif
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/colourmap.h b/colourmap.h
new file mode 100644
index 0000000..7887126
--- /dev/null
+++ b/colourmap.h
@@ -0,0 +1,39 @@
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4:
+
+ lysdr Software Defined Radio
+
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ colourmap.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifdef COLOUR_REDHOT
+
+// red hot
+gint32 colourmap[] = {
+0x00000000, 0x00000000, 0x00000000, 0x02000000, 0x03000000, 0x03000000, 0x04000000, 0x05000000, 0x06000000, 0x07000000, 0x07000000, 0x09000000, 0x09000000, 0x0b000000, 0x0b000000, 0x0c000000, 0x0d000000, 0x0e000000, 0x0f000000, 0x0f000000, 0x11000000, 0x11000000, 0x12000000, 0x13000000, 0x13000000, 0x15000000, 0x15000000, 0x16000000, 0x17000000, 0x18000000, 0x18000000, 0x1a000000, 0x1b000000, 0x1b000000, 0x1c000000, 0x1d000000, 0x1e000000, 0x1e000000, 0x1f000000, 0x20000000, 0x21000000, [...]
+};
+
+#else
+
+gint32 colourmap[] = {
+0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x08052800, 0x0b073800, 0x0e084400, 0x0f0a4f00, 0x110a5700, 0x120b5e00, 0x140c6500, 0x150d6a00, 0x150d6f00, 0x170d7400, 0x170e7800, 0x180e7b00, 0x190e7d00, 0x180f7f00, 0x190f7e00, 0x190f7f00, 0x180f8000, 0x190f8000, 0x190f8000, 0x190f8100, 0x19108200, 0x190f8200, 0x19108200, 0x19108400, 0x19108300, 0x1a0f8400, 0x1a0f8400, 0x1a108500, 0x1a108500, [...]
+};
+
+#endif
diff --git a/filter.c b/filter.c
new file mode 100644
index 0000000..dafb402
--- /dev/null
+++ b/filter.c
@@ -0,0 +1,195 @@
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4:
+ lysdr Software Defined Radio
+
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+ Hilbert transform code from Steve Harris' swh-plugins
+
+ filter.c
+ contains all filter creation and processing code
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <stdlib.h>
+#include <complex.h>
+#include <math.h>
+#include "filter.h"
+#include "sdr.h"
+#include "hilbert.h"
+
+#define IS_ALMOST_DENORMAL(f) (fabs(f) < 3.e-34)
+
+static double complex delay[D_SIZE];
+
+static void make_impulse(double complex fir_imp[], float sample_rate, int taps, float bw, float centre) {
+
+ float K = bw * taps / sample_rate;
+ float w;
+ double complex z;
+ int k, i=0;
+
+ float tune = 2.0 * M_PI * centre / sample_rate;
+
+ for (k=-taps/2; k<taps/2; k++) {
+ if (k==0) z=(float)K/taps;
+ else z=1.0/taps*sin(M_PI*k*K/taps)/sin(M_PI*k/taps);
+ // apply a windowing function. I can't hear any difference...
+ //w = 0.5 + 0.5 * cos(2.0 * M_PI * k / taps); // Hanning window
+ w = 0.42 + 0.5 * cos(2.0f * M_PI * k / taps) + 0.08 * cos(4.0f * M_PI * k / taps); // Blackman window
+ //w=1; // No window
+ z *= w;
+ z *= 2*cexp(-1*I * tune * k);
+ if (IS_ALMOST_DENORMAL(creal(z))) { z = I * cimag(z); }
+ if (IS_ALMOST_DENORMAL(cimag(z))) { z = creal(z); }
+ fir_imp[i] = z;
+ i++;
+ }
+}
+
+
+filter_fir_t *filter_fir_new(int taps, int size) {
+ // create the structure for a new FIR filter
+ filter_fir_t *filter = malloc(sizeof(filter_fir_t));
+ filter->taps = taps;
+ filter->size = size;
+ filter->impulse = malloc(sizeof(double complex)*taps);
+ filter->imp_I = malloc(sizeof(double)*taps);
+ filter->imp_Q = malloc(sizeof(double)*taps);
+ filter->buf_I = malloc(sizeof(double)*taps);
+ filter->buf_Q = malloc(sizeof(double)*taps);
+ filter->index = 0;
+ return filter;
+}
+
+void filter_fir_destroy(filter_fir_t *filter) {
+ // destroy the FIR filter
+ if (filter) {
+ if (filter->impulse) free(filter->impulse);
+ if (filter->imp_I) free(filter->imp_I);
+ if (filter->imp_Q) free(filter->imp_Q);
+ if (filter->buf_I) free(filter->buf_I);
+ if (filter->buf_Q) free(filter->buf_Q);
+ free(filter);
+ }
+}
+
+void filter_fir_set_response(filter_fir_t *filter, int sample_rate, float bw, float centre) {
+ // plop an impulse into the appropriate array
+ int i;
+ make_impulse(filter->impulse, sample_rate, filter->taps, bw, centre);
+
+ for (i=0; i<filter->taps; i++) {
+ filter->imp_I[i] = creal(filter->impulse[i]);
+ filter->imp_Q[i] = cimag(filter->impulse[i]);
+ }
+}
+
+void filter_iir_set_response(filter_iir_t *filter, int sample_rate, float cutoff, float q) {
+ // create the coefficients for an IIR filter
+ gfloat w0, alpha;
+ // lowpass
+ w0 = 2 * M_PI * cutoff/sample_rate;
+ alpha = sin(w0)/(2*q);
+ filter->b0 = (1-cos(w0))/2;
+ filter->b1 = 1-cos(w0);
+ filter->b2 = (1-cos(w0))/2;
+ filter->a0 = 1 + alpha;
+ filter->a1 = -2*cos(w0);
+ filter->a2 = 1 - alpha;
+ /*
+ // highpass
+ filter->b0 = (1 + cos(w0))/2
+ filter->b1 = -(1 + cos(w0))
+ filter->b2 = (1 + cos(w0))/2
+ filter->a0 = 1 + alpha
+ filter->a1 = -2*cos(w0)
+ filter->a2 = 1 - alpha
+ */
+}
+
+
+
+
+void filter_fir_process(filter_fir_t *filter, double complex *samples) {
+ // Perform an FIR filter on the data "in place"
+ // this routine is slow and has a horrible hack to avoid denormals
+ int i, j, k;
+ double complex c;
+ double accI, accQ;
+ double *buf_I = filter->buf_I;
+ double *buf_Q = filter->buf_Q;
+ double *imp_I = filter->imp_I;
+ double *imp_Q = filter->imp_Q;
+ int index = filter->index;
+ int taps = filter->taps;
+
+ for (i = 0; i < filter->size; i++) {
+ c = samples[i];
+ buf_I[index] = creal(c);
+ buf_Q[index] = cimag(c);
+ // flush denormals
+ if (IS_ALMOST_DENORMAL(buf_I[index])) { buf_I[index]=0; }
+ if (IS_ALMOST_DENORMAL(buf_Q[index])) { buf_Q[index]=0; }
+
+
+
+ accI = accQ = 0;
+ j = index;
+ for (k = 0; k < taps; k++) {
+ accI += buf_I[j] * imp_I[k];
+ accQ += buf_Q[j] * imp_Q[k];
+ if (++j >= taps) j = 0;
+ }
+ samples[i] = accI + I * accQ;
+ index++;
+ if (index >= taps) index = 0;
+ }
+ filter->index = index;
+
+}
+
+void filter_hilbert(gint phase, double complex *samples, gint taps) {
+ // Hilbert transform, shamelessly nicked from swh-plugins
+ // taps needs to be a multiple of D_SIZE
+ // returns I and Q, with Q rotated through 90 degrees
+ // 100 samples delay
+ gint i, j, dptr = 0;
+ gfloat hilb;
+ for (i = 0; i < taps; i++) {
+ delay[dptr] = samples[i];
+ hilb = 0.0f;
+ for (j = 0; j < NZEROS/2; j++) {
+ hilb += (phase*xcoeffs[j] * cimag(delay[(dptr - j*2) & (D_SIZE - 1)]));
+ }
+ samples[i] = creal(delay[(dptr-99)& (D_SIZE-1)]) + I * hilb;
+ dptr = (dptr + 1) & (D_SIZE - 1);
+ }
+
+}
+
+void filter_iir_process(filter_iir_t *filter, gfloat *samples) {
+ // run a simple biquad IIR filter
+ int i;
+ gfloat y, x;
+
+ for (i = 0; i < filter->size; i++) {
+ x = samples[i];
+ y = (filter->b0/filter->a0)*x + (filter->b1/filter->a0)*filter->x1 + (filter->b2/filter->a0)*filter->x2 - (filter->a1/filter->a0)*filter->y1 - (filter->a2/filter->a0)*filter->y2;
+ filter->y2 = filter->y1; filter->y1 = y;
+ filter->x2 = filter->x1; filter->x1 = x;
+ }
+}
+
diff --git a/filter.h b/filter.h
new file mode 100644
index 0000000..e796061
--- /dev/null
+++ b/filter.h
@@ -0,0 +1,58 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ filter.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <math.h>
+#include <complex.h>
+#include "sdr.h"
+
+#ifndef __FILTER_H
+#define __FILTER_H
+
+// IIR filter defs
+typedef struct {
+ // coefficients
+ gfloat alpha, w0, b0, b1, b2, a0, a1, a2;
+ // taps
+ gfloat x1, x2, y1, y2;
+ gint size;
+} filter_iir_t;
+
+
+// FIR filter defs
+typedef struct {
+ double complex *impulse;
+ double *buf_I;
+ double *buf_Q;
+ double *imp_I;
+ double *imp_Q;
+ int index;
+ int size;
+ int taps;
+} filter_fir_t;
+
+filter_fir_t *filter_fir_new(int taps, int size);
+void filter_fir_destroy(filter_fir_t *filter);
+void filter_fir_set_response(filter_fir_t *filter, int sample_rate, float bw, float centre);
+void filter_fir_process(filter_fir_t *filter, double complex *samples);
+void filter_hilbert(gint phase, double complex *samples, gint taps);
+#endif
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/gui.c b/gui.c
new file mode 100644
index 0000000..9a40b63
--- /dev/null
+++ b/gui.c
@@ -0,0 +1,261 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ gui.c
+ set up and draw the GUI elements
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <math.h>
+#include <complex.h>
+#include <gtk/gtk.h>
+#include <string.h>
+#include "sdr.h"
+#include "waterfall.h"
+#include "smeter.h"
+#include "colourmap.h"
+
+extern sdr_data_t *sdr;
+
+// these are global so that the gui_update routine can fiddle with them
+static GtkWidget *label;
+static SDRWaterfall *wfdisplay;
+static GtkWidget *meter;
+
+static gboolean gui_update_waterfall(GtkWidget *widget) {
+
+ int i, j, p, hi;
+ gdouble y;
+
+ gdouble wi, wq;
+
+ fftw_complex z;
+ guchar data[sdr->fft_size*4];
+ static gfloat oldy[8192];
+ gfloat filt = 0.5;
+ gint32 colour;
+ fft_data_t *fft= sdr->fft;
+
+ // copy the block of samples to a buffer
+ // we can then apply a window function to it
+ memmove(fft->windowed, fft->samples, sizeof(double complex)*(sdr->fft_size));
+
+ // window it
+ for (i=0; i<sdr->fft_size; i++) {
+ // Hamming function
+ wi = 0.54 - 0.46 * cos(2.0 * M_PI * i/sdr->fft_size);
+ // Blackman function, better strong-signal performance but more computationally expensive
+ //wi = 0.42 - 0.5 * cos(2.0f * M_PI * i / sdr->fft_size) + 0.08 * cos(4.0f * M_PI * i / sdr->fft_size);
+ fft->windowed[i] *= wi + I * wi;
+ }
+
+ fftw_execute(fft->plan);
+ fft->status=EMPTY;
+ fft->index=0;
+
+ hi = sdr->fft_size/2;
+ j=0;
+
+ for(i=0; i<sdr->fft_size; i++) {
+ p=i;
+ if (p<hi) p=p+hi; else p=p-hi;
+ z = fft->out[p]; // contains the FFT data
+ y=10*cabs(z);
+ y = (y*filt) + (oldy[i]*(1-filt));
+ oldy[i]=y;
+ y = CLAMP(y , 0, 1.0);
+ colour = colourmap[(int)(255*y)];
+ data[j++] = (colour>>8)&0xff;
+ data[j++] = (colour>>16)&0xff;
+ data[j++] = colour>>24;
+ data[j++] = 255;
+ }
+
+
+
+ sdr_waterfall_update(widget, data);
+
+ y = (2000-sdr->agc_gain)/2000;
+ if (y<0) y = 0;
+ if (y>1) y = 1;
+ y=y*y;
+ sdr_smeter_set_level(SDR_SMETER(meter), y);
+ return TRUE;
+}
+
+static void tuning_changed(GtkWidget *widget, gpointer psdr) {
+ sdr_data_t *sdr;
+ char l[256];
+ sdr = (sdr_data_t *) psdr;
+ float tune = gtk_adjustment_get_value(GTK_ADJUSTMENT(widget));
+
+ sdr->loPhase = cexp((I * -2.0 * 3.14159 * tune) / sdr->sample_rate);
+ sprintf(l, "<span size=\"large\">%4.5f</span>",(sdr->centre_freq/1000000.0f)+(tune/1000000));
+ gtk_label_set_markup(GTK_LABEL(label), l);
+}
+
+static void filter_clicked(GtkWidget *widget, gpointer psdr) {
+ sdr_data_t *sdr = (sdr_data_t *) psdr;
+ gint state = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
+ switch (state) {
+ case 0:
+ sdr_waterfall_set_lowpass(wfdisplay, 3400.0f);
+ sdr_waterfall_set_highpass(wfdisplay, 300.0f);
+ break;
+ case 1:
+ sdr_waterfall_set_lowpass(wfdisplay, 1500.0f);
+ sdr_waterfall_set_highpass(wfdisplay, 500.0f);
+ break;
+ }
+}
+
+static void filter_changed(GtkWidget *widget, gpointer psdr) {
+ sdr_data_t *sdr = (sdr_data_t *) psdr;
+ gdouble lowpass = gtk_adjustment_get_value(GTK_ADJUSTMENT(sdr->lp_tune));
+ gdouble highpass = gtk_adjustment_get_value(GTK_ADJUSTMENT(sdr->hp_tune));
+ filter_fir_set_response(sdr->filter, sdr->sample_rate, highpass-lowpass, lowpass+(highpass-lowpass)/2);
+}
+
+static void mode_changed(GtkWidget *widget, gpointer psdr) {
+ sdr_data_t *sdr = (sdr_data_t *) psdr;
+ gint state = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
+ switch(state) {
+ case SDR_LSB:
+ sdr->mode = SDR_LSB;
+ SDR_WATERFALL(wfdisplay)->mode = SDR_LSB;
+ break;
+ case SDR_USB:
+ sdr->mode = SDR_USB;
+ SDR_WATERFALL(wfdisplay)->mode = SDR_USB;
+ break;
+ }
+ sdr_waterfall_filter_cursors(SDR_WATERFALL(wfdisplay)); // hacky
+}
+
+static void agc_changed(GtkWidget *widget, gpointer psdr) {
+ sdr_data_t *sdr = (sdr_data_t *) psdr;
+
+ gint state = gtk_combo_box_get_active(GTK_COMBO_BOX(widget));
+ switch (state) {
+ case 0:
+ sdr->agc_speed = 0.005;
+ break;
+ case 1:
+ sdr->agc_speed = 0.001;
+ break;
+ case 2:
+ sdr->agc_speed = -1.0;
+ break;
+ }
+}
+
+void gui_display(sdr_data_t *sdr, gboolean horizontal)
+{
+ GtkWidget *mainWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ GtkWidget *waterfall;
+ GtkWidget *vbox;
+ GtkWidget *tuneslider;
+ GtkWidget *hbox;
+ GtkWidget *lpslider;
+ GtkWidget *hpslider;
+ GtkWidget *filter_combo;
+ GtkWidget *mode_combo;
+ GtkWidget *agc_combo;
+
+ float tune_max;
+
+ gtk_window_set_title(GTK_WINDOW(mainWindow), "lysdr");
+ gtk_signal_connect(GTK_OBJECT(mainWindow), "destroy", G_CALLBACK(gtk_main_quit), NULL);
+
+ vbox = gtk_vbox_new(FALSE,1);
+ gtk_container_add(GTK_CONTAINER(mainWindow), vbox);
+
+ // tuning scale
+ tune_max = (float)sdr->sample_rate;
+ sdr->tuning = gtk_adjustment_new(-1, -tune_max/2, tune_max/2, 10, 100, 0);
+
+
+ sdr->lp_tune = gtk_adjustment_new(3400, 300, 9000, 10, 100, 0); // pretty arbitrary limits
+ sdr->hp_tune = gtk_adjustment_new(300, 25, 3400, 10, 100, 0); // pretty arbitrary limits
+
+ // buttons etc
+ hbox = gtk_hbox_new(FALSE,1);
+ // S meter
+ meter = sdr_smeter_new(NULL);
+ gtk_box_pack_start(GTK_BOX(hbox), meter, FALSE, TRUE, 0);
+
+ agc_combo = gtk_combo_box_new_text();
+ gtk_combo_box_append_text(GTK_COMBO_BOX(agc_combo), "Fast");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(agc_combo), "Slow");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(agc_combo), "Lock");
+ gtk_combo_box_set_active(GTK_COMBO_BOX(agc_combo), 0);
+ gtk_box_pack_start(GTK_BOX(hbox), agc_combo, TRUE, TRUE, 0);
+
+ // VFO readout
+ label = gtk_label_new (NULL);
+ gtk_box_pack_start(GTK_BOX(hbox), label, TRUE, TRUE, 0);
+ gtk_label_set_markup(GTK_LABEL(label), "<tt>VFO</tt>");
+
+ filter_combo = gtk_combo_box_new_text();
+ gtk_combo_box_append_text(GTK_COMBO_BOX(filter_combo), "Wide");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(filter_combo), "Narrow");
+ gtk_combo_box_set_active(GTK_COMBO_BOX(filter_combo), 0);
+ gtk_box_pack_start(GTK_BOX(hbox), filter_combo, TRUE, TRUE, 0);
+
+ mode_combo = gtk_combo_box_new_text();
+ gtk_combo_box_append_text(GTK_COMBO_BOX(mode_combo), "LSB");
+ gtk_combo_box_append_text(GTK_COMBO_BOX(mode_combo), "USB");
+ gtk_combo_box_set_active(GTK_COMBO_BOX(mode_combo), 0);
+ gtk_box_pack_start(GTK_BOX(hbox), mode_combo, TRUE, TRUE, 0);
+
+ wfdisplay = sdr_waterfall_new(GTK_ADJUSTMENT(sdr->tuning), GTK_ADJUSTMENT(sdr->lp_tune), GTK_ADJUSTMENT(sdr->hp_tune), sdr->sample_rate, sdr->fft_size);
+ // common softrock frequencies
+ // 160m = 1844250
+ // 80m = 3528000
+ // 40m = 7056000
+ // 30m = 10125000
+ // 20m = 14075000
+ // 15m = 21045000
+ if (horizontal)
+ SDR_WATERFALL(wfdisplay)->orientation = WF_O_HORIZONTAL;
+ SDR_WATERFALL(wfdisplay)->centre_freq = sdr->centre_freq;
+ switch (SDR_WATERFALL(wfdisplay)->orientation) {
+ case WF_O_VERTICAL:
+ gtk_widget_set_size_request(GTK_WIDGET(wfdisplay), sdr->fft_size, 250);
+ break;
+ case WF_O_HORIZONTAL:
+ gtk_widget_set_size_request(GTK_WIDGET(wfdisplay), 960, sdr->fft_size);
+ break;
+ }
+ gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(wfdisplay), TRUE, TRUE, 0);
+ gtk_box_pack_start(GTK_BOX(vbox), hbox, TRUE, TRUE, 0);
+
+ gtk_widget_show_all(mainWindow);
+
+ // connect handlers
+ // FIXME - determine minimum update rate from jack latency
+ g_timeout_add(25, (GSourceFunc)gui_update_waterfall, (gpointer)wfdisplay);
+ gtk_signal_connect(GTK_OBJECT(sdr->tuning), "value-changed", G_CALLBACK(tuning_changed), sdr);
+ gtk_signal_connect(GTK_OBJECT(sdr->lp_tune), "value-changed", G_CALLBACK(filter_changed), sdr);
+ gtk_signal_connect(GTK_OBJECT(sdr->hp_tune), "value-changed", G_CALLBACK(filter_changed), sdr);
+ gtk_signal_connect(GTK_OBJECT(filter_combo), "changed", G_CALLBACK(filter_clicked), sdr);
+ gtk_signal_connect(GTK_OBJECT(mode_combo), "changed", G_CALLBACK(mode_changed), sdr);
+ gtk_signal_connect(GTK_OBJECT(agc_combo), "changed", G_CALLBACK(agc_changed), sdr);
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
+
diff --git a/hilbert.h b/hilbert.h
new file mode 100644
index 0000000..5a6dac6
--- /dev/null
+++ b/hilbert.h
@@ -0,0 +1,31 @@
+#define D_SIZE 256
+#define NZEROS 200
+
+/* The non-zero taps of the Hilbert transformer */
+static float xcoeffs[] = {
+ +0.0008103736f, +0.0008457886f, +0.0009017196f, +0.0009793364f,
+ +0.0010798341f, +0.0012044365f, +0.0013544008f, +0.0015310235f,
+ +0.0017356466f, +0.0019696659f, +0.0022345404f, +0.0025318040f,
+ +0.0028630784f, +0.0032300896f, +0.0036346867f, +0.0040788644f,
+ +0.0045647903f, +0.0050948365f, +0.0056716186f, +0.0062980419f,
+ +0.0069773575f, +0.0077132300f, +0.0085098208f, +0.0093718901f,
+ +0.0103049226f, +0.0113152847f, +0.0124104218f, +0.0135991079f,
+ +0.0148917649f, +0.0163008758f, +0.0178415242f, +0.0195321089f,
+ +0.0213953037f, +0.0234593652f, +0.0257599469f, +0.0283426636f,
+ +0.0312667947f, +0.0346107648f, +0.0384804823f, +0.0430224431f,
+ +0.0484451086f, +0.0550553725f, +0.0633242001f, +0.0740128560f,
+ +0.0884368322f, +0.1090816773f, +0.1412745301f, +0.1988673273f,
+ +0.3326528346f, +0.9997730178f, -0.9997730178f, -0.3326528346f,
+ -0.1988673273f, -0.1412745301f, -0.1090816773f, -0.0884368322f,
+ -0.0740128560f, -0.0633242001f, -0.0550553725f, -0.0484451086f,
+ -0.0430224431f, -0.0384804823f, -0.0346107648f, -0.0312667947f,
+ -0.0283426636f, -0.0257599469f, -0.0234593652f, -0.0213953037f,
+ -0.0195321089f, -0.0178415242f, -0.0163008758f, -0.0148917649f,
+ -0.0135991079f, -0.0124104218f, -0.0113152847f, -0.0103049226f,
+ -0.0093718901f, -0.0085098208f, -0.0077132300f, -0.0069773575f,
+ -0.0062980419f, -0.0056716186f, -0.0050948365f, -0.0045647903f,
+ -0.0040788644f, -0.0036346867f, -0.0032300896f, -0.0028630784f,
+ -0.0025318040f, -0.0022345404f, -0.0019696659f, -0.0017356466f,
+ -0.0015310235f, -0.0013544008f, -0.0012044365f, -0.0010798341f,
+ -0.0009793364f, -0.0009017196f, -0.0008457886f, -0.0008103736f,
+};
diff --git a/lysdr.c b/lysdr.c
new file mode 100644
index 0000000..c5603c3
--- /dev/null
+++ b/lysdr.c
@@ -0,0 +1,152 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ lysdr.c
+ A simple software-defined radio for Linux
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <gtk/gtk.h>
+#include <stdlib.h>
+
+#include "sdr.h"
+#include "audio_jack.h"
+#include "filter.h"
+
+extern void gui_display(sdr_data_t *sdr, gboolean horizontal); // ugh, there should be a header file for the GUI
+sdr_data_t *sdr;
+
+static gboolean connect_input = FALSE;
+static gboolean connect_output = FALSE;
+static gboolean horizontal = FALSE;
+static gint centre_freq = 0;
+static gint fft_size = 1024;
+static gchar *tuning_hook = NULL;
+
+static GOptionEntry opts[] =
+{
+ { "horizontal", 'H', 0, G_OPTION_ARG_NONE, &horizontal, "Horizontal waterfall", NULL },
+ { "ci", 0, 0, G_OPTION_ARG_NONE, &connect_input, "Autoconnect input to first two jack capture ports", NULL },
+ { "co", 0, 0, G_OPTION_ARG_NONE, &connect_output, "Autoconnect output to first two jack playback ports", NULL },
+ { "freq", 'f', 0, G_OPTION_ARG_INT, ¢re_freq, "Set the centre frequency in Hz", "FREQUENCY" },
+ { "fft-size", 'F', 0, G_OPTION_ARG_INT, &fft_size, "Set the FFT size (default=1024)", "FFT_SIZE" },
+ { "tuning-hook", 0, 0, G_OPTION_ARG_STRING, &tuning_hook, "Program to run when tuned frequency changes", "PROGRAM" },
+ { NULL }
+};
+
+static void hook_setup(gpointer data) {
+ GString *s = g_string_new("");
+ gint tuning = (gint)gtk_adjustment_get_value(GTK_ADJUSTMENT(sdr->tuning));
+
+ g_string_printf(s, "%d", sdr->centre_freq);
+ g_setenv("LYSDR_CENTRE", s->str, TRUE);
+
+ g_string_printf(s, "%d", tuning);
+ g_setenv("LYSDR_OFFSET", s->str, TRUE);
+
+ g_string_printf(s, "%d", sdr->centre_freq + tuning);
+ g_setenv("LYSDR_FREQ", s->str, TRUE);
+
+ switch (sdr->mode) {
+ case SDR_LSB:
+ g_string_printf(s, "LSB");
+ break;
+ case SDR_USB:
+ g_string_printf(s, "USB");
+ break;
+ }
+ g_setenv("LYSDR_MODE", s->str, TRUE);
+
+ g_string_free(s, TRUE);
+}
+
+static gboolean run_hook(gpointer data) {
+ gchar *hook = (gchar *)data;
+
+ if (hook != NULL) {
+ GPid pid;
+ gchar *argv[] = { hook, NULL };
+
+ g_spawn_async(NULL, argv, NULL, 0, hook_setup, NULL, &pid, NULL);
+ g_spawn_close_pid(pid);
+ }
+
+ return FALSE;
+}
+
+static guint tuning_hook_timeout = 0;
+
+static void tuning_changed(GtkAdjustment *adjustment, gpointer data) {
+ if (tuning_hook_timeout) {
+ // Cancel if already scheduled: we want to only run the hook once
+ // the value's settled.
+ g_source_remove(tuning_hook_timeout);
+ }
+
+ tuning_hook_timeout = g_timeout_add(100, run_hook, (gpointer)tuning_hook);
+}
+
+int main(int argc, char *argv[]) {
+ GError *error = NULL;
+ GOptionContext *context;
+
+
+ printf("lysdr starting\n");
+
+ gdk_threads_init();
+ gdk_threads_enter();
+
+ gtk_init(&argc, &argv);
+
+ context = g_option_context_new ("-");
+ g_option_context_add_main_entries (context, opts, NULL);
+ g_option_context_add_group (context, gtk_get_option_group (TRUE));
+ if (!g_option_context_parse (context, &argc, &argv, &error)) {
+ g_print ("option parsing failed: %s\n", error->message);
+ exit (1);
+ }
+
+ // create a new SDR, and set up the jack client
+ sdr = sdr_new(fft_size);
+ audio_start(sdr);
+
+ // define a filter and configure a default shape
+ sdr->filter = filter_fir_new(64, sdr->size);
+ filter_fir_set_response(sdr->filter, sdr->sample_rate, 3100, 1850);
+
+ // hook up the jack ports and start the client
+ fft_setup(sdr);
+ audio_connect(sdr, connect_input, connect_output);
+
+ sdr->centre_freq = centre_freq;
+
+ gui_display(sdr, horizontal);
+
+ gtk_signal_connect(GTK_OBJECT(sdr->tuning), "value-changed", G_CALLBACK(tuning_changed), NULL);
+
+ gtk_adjustment_set_value(GTK_ADJUSTMENT(sdr->tuning), 0);
+
+ gtk_main();
+ audio_stop(sdr);
+ filter_fir_destroy(sdr->filter);
+ fft_teardown(sdr);
+
+ sdr_destroy(sdr);
+ gdk_threads_leave();
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/lysdr.h b/lysdr.h
new file mode 100644
index 0000000..60d2c85
--- /dev/null
+++ b/lysdr.h
@@ -0,0 +1,35 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ lysdr.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+typedef enum {
+ MODE_LSB,
+ MODE_USB,
+ MODE_CW,
+ MODE_AM
+} demod_t;
+
+typedef struct {
+ // SDR parameters
+ gint centre_freq; // local oscillator freq used for VFO and display
+ demod_t mode; // what mode we're currently listening to
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/notes b/notes
new file mode 100644
index 0000000..8d6d2c0
--- /dev/null
+++ b/notes
@@ -0,0 +1,4 @@
+Filter state should be wide, narrow or "free" if the sliders have been changed
+Possibly filter button shouldn't be a toggle button, but two non-latching for wide and narrow?
+Remove filter buttons altogether?
+
diff --git a/package_info/archlinux/PKGBUILD b/package_info/archlinux/PKGBUILD
new file mode 100644
index 0000000..7ea0d27
--- /dev/null
+++ b/package_info/archlinux/PKGBUILD
@@ -0,0 +1,46 @@
+# lysdr-git
+# software-defined radio, using Gtk+ GUI and jack audio IO
+# Maintainer: Gordonjcp <gordon at gjcp.net>
+pkgname=lysdr-git
+pkgver=0.0.6
+pkgrel=2
+pkgdesc="Software-defined Radio receiver"
+arch=(i686)
+url="http://lovesthepython.org/git/?p=lysdr.git"
+license=('GPL')
+depends=(fftw gtk2 jack)
+makedepends=('python' 'git')
+
+_gitroot="git://lovesthepython.org/lysdr.git"
+_gitname="lysdr"
+
+build() {
+ cd "$srcdir"
+ msg "Connecting to GIT server...."
+
+ if [ -d $_gitname ] ; then
+ cd $_gitname && git pull origin
+ msg "The local files are updated."
+ else
+ git clone $_gitroot $_gitname
+ fi
+
+ msg "GIT checkout done or server timeout"
+ msg "Building with waf"
+
+ rm -rf "$srcdir/$_gitname-build"
+ git clone "$srcdir/$_gitname" "$srcdir/$_gitname-build"
+ cd "$srcdir/$_gitname-build"
+
+ #
+ # BUILD HERE
+ #
+
+ ./waf configure --prefix=/usr
+ ./waf build
+}
+
+package() {
+ cd "$srcdir/$_gitname-build"
+ DESTDIR="$pkgdir/" ./waf install
+}
diff --git a/sdr.c b/sdr.c
new file mode 100644
index 0000000..dfa8eab
--- /dev/null
+++ b/sdr.c
@@ -0,0 +1,163 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ sdr.c
+ handle the actual audio processing, and creation and destruction of
+ the SDR environment
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <stdlib.h>
+#include <math.h>
+#include <complex.h>
+#include <fftw3.h>
+#include <string.h>
+
+#include "filter.h"
+#include "sdr.h"
+
+static gint blk_pos=0;
+static int n;
+
+sdr_data_t *sdr_new(gint fft_size) {
+ // create an SDR, and initialise it
+ sdr_data_t *sdr;
+
+ sdr = malloc(sizeof(sdr_data_t));
+ sdr->loVector = 1; // start the local oscillator
+ //sdr->loPhase = 1; // this value is bogus but we're going to set the frequency anyway
+
+
+ sdr->loPhase = cexp(I);
+ sdr->agc_gain = 0; // start off as quiet as possible
+ sdr->mode = SDR_LSB;
+ sdr->agc_speed = 0.005;
+ sdr->fft_size = fft_size;
+
+ return sdr;
+}
+
+void sdr_destroy(sdr_data_t *sdr) {
+ if (sdr) {
+ free(sdr);
+ }
+}
+
+int sdr_process(sdr_data_t *sdr) {
+ // actually do the SDR bit
+ int i, j, k;
+ double y, accI, accQ;
+ double complex c;
+ fft_data_t *fft = sdr->fft;
+ int size = sdr->size;
+ int block_size = MIN(size, sdr->fft_size); // ensure we don't try to copy a block larger than FFT_SIZE
+
+ float agc_gain = sdr->agc_gain;
+ float agc_peak = 0;
+
+ // remove DC with a highpass filter
+ for (i = 0; i < size; i++) { // DC removal; R.G. Lyons page 553
+ c = sdr->iqSample[i] + sdr->dc_remove * 0.95;
+ sdr->iqSample[i] = c - sdr->dc_remove;
+ sdr->dc_remove = c;
+ }
+
+ // copy this period to FFT buffer, or as much as will fit
+ // note that if the jack periodsize is greater than FFT_LEN, it will only copy FFT_LEN samples
+ memmove(fft->samples, fft->samples+block_size, sizeof(double complex)*(sdr->fft_size-block_size)); // move the last lot up
+ memmove(fft->samples+sdr->fft_size-block_size, sdr->iqSample, sizeof(double complex)*block_size); // copy the current block
+
+
+
+ // shift frequency
+ for (i = 0; i < size; i++) {
+ sdr->iqSample[i] *= sdr->loVector;
+ sdr->loVector *= sdr->loPhase;
+ }
+
+ // demodulate by performing a Hilbert transform and then summing real and imaginary
+ switch(sdr->mode) {
+ case SDR_LSB:
+ filter_hilbert(-1, sdr->iqSample, size);
+ break;
+ case SDR_USB:
+ filter_hilbert(1, sdr->iqSample, size);
+ break;
+ }
+ for (i=0; i < size; i++) {
+ y = creal(sdr->iqSample[i])+cimag(sdr->iqSample[i]);
+ sdr->output[i] = y;
+ }
+
+ //filter_iir_process(sdr->filter, sdr->output);
+
+ // apply some AGC here
+ for (i = 0; i < size; i++) {
+ y = sdr->output[i];
+ if (agc_peak < y) agc_peak = y;
+
+ }
+
+
+ if (agc_peak == 0) agc_peak = 0.00001; // don't be zero, in case we have digital silence
+ y = agc_peak * agc_gain; // y is the peak level scaled by the current gain
+
+ if (sdr->agc_speed < 0) {
+ // AGC locked; don't change
+ } else if (y <= 1) { // Current level is below the soundcard max, increase gain
+ agc_gain += (1/ agc_peak - agc_gain) * sdr->agc_speed;
+ } else { // decrease gain
+ agc_gain += (1 / agc_peak - agc_gain);
+ }
+ y = agc_gain * 0.5; // change volume
+ for (i = 0; i < sdr->size; i++){
+ sdr->output[i] *= y;
+ }
+
+ sdr->agc_gain = agc_gain;
+
+ return 0;
+}
+
+void fft_setup(sdr_data_t *sdr) {
+ sdr->fft = (fft_data_t *)malloc(sizeof(fft_data_t));
+ fft_data_t *fft = sdr->fft;
+
+ fft->filter = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * sdr->fft_size);
+
+ fft->windowed = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * sdr->fft_size);
+ fft->samples = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * sdr->fft_size);
+ fft->out = (fftw_complex*) fftw_malloc(sizeof(fftw_complex) * sdr->fft_size);
+ fft->plan = fftw_plan_dft_1d(sdr->fft_size, fft->windowed, fft->out, FFTW_FORWARD, FFTW_ESTIMATE);
+ fft->htplan = fftw_plan_dft_1d(sdr->fft_size, sdr->iqSample, fft->filter, FFTW_FORWARD, FFTW_ESTIMATE);
+ fft->htbplan = fftw_plan_dft_1d(sdr->fft_size, fft->filter, sdr->iqSample, FFTW_BACKWARD, FFTW_ESTIMATE);
+ fft->status = EMPTY;
+ fft->index = 0;
+}
+
+void fft_teardown(sdr_data_t *sdr) {
+ fft_data_t *fft = sdr->fft;
+ fftw_destroy_plan(fft->plan);
+ fftw_destroy_plan(fft->htplan);
+ fftw_destroy_plan(fft->htbplan);
+ fftw_free(fft->filter);
+ fftw_free(fft->windowed);
+ fftw_free(fft->samples);
+ fftw_free(fft->out);
+ free(sdr->fft);
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/sdr.h b/sdr.h
new file mode 100644
index 0000000..06739ad
--- /dev/null
+++ b/sdr.h
@@ -0,0 +1,84 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ sdr.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __SDR_H
+#define __SDR_H
+
+#include <complex.h>
+#include <gtk/gtk.h>
+#include <fftw3.h>
+#include "filter.h"
+
+#define FIR_SIZE 1024
+#define MAX_FIR_LEN 8*4096
+
+enum fft_status {EMPTY, // fft_data is currently unused
+ FILLING, // now writing samples to this fft
+ READY}; // ready to perform fft
+
+enum rx_mode { SDR_LSB, SDR_USB };
+
+typedef struct {
+ fftw_complex *windowed;
+ fftw_complex *samples; // complex data for fft
+ fftw_complex *out;
+ fftw_complex *filter;
+ fftw_plan plan; // fft plan for fftw
+ fftw_plan htplan; // fft plan for fftw
+ fftw_plan htbplan; // fft plan for fftw
+ int index; // position of next fft sample
+ enum fft_status status; // whether the fft is busy
+} fft_data_t;
+
+typedef struct {
+ double complex *iqSample; // the array of incoming samples
+ double complex loVector; // local oscillator vector
+ double complex loPhase; // local oscillator phase angle (sets tuning)
+ gdouble *output; // pointer to output samples
+
+ GtkObject *tuning; // adjustment for tuning
+ GtkObject *lp_tune; // adjustment for filter lowpass
+ GtkObject *hp_tune; // adjustment for filter highpass
+ gint mode; // demodulator mode
+ gint centre_freq;
+
+ fft_data_t *fft;
+ gint fft_size;
+
+ filter_fir_t *filter;
+
+ // things to keep track of between callbacks
+ double complex dc_remove;
+ gfloat agc_gain;
+ gfloat agc_speed;
+ // jack parameters
+ guint size; // periodsize
+ guint sample_rate; // samplerate
+} sdr_data_t;
+
+sdr_data_t *sdr_new(gint fft_size);
+int sdr_process(sdr_data_t *sdr);
+void sdr_destroy(sdr_data_t *sdr);
+void fft_setup(sdr_data_t *sdr);
+void fft_teardown(sdr_data_t *sdr);
+#endif
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/smeter.c b/smeter.c
new file mode 100644
index 0000000..ff96bc0
--- /dev/null
+++ b/smeter.c
@@ -0,0 +1,96 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ smeter.c
+ draw a simple signal strength meter
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+#include <gtk/gtk.h>
+#include "smeter.h"
+
+static GtkWidgetClass *parent_class = NULL;
+G_DEFINE_TYPE (SDRSMeter, sdr_smeter, GTK_TYPE_DRAWING_AREA);
+
+static gboolean sdr_smeter_expose(GtkWidget *widget, GdkEventExpose *event);
+static void sdr_smeter_size_request(GtkWidget *widget, GtkRequisition *requisition);
+
+static void sdr_smeter_class_init (SDRSMeterClass *class) {
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(class);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+ parent_class = gtk_type_class(GTK_TYPE_DRAWING_AREA);
+
+ widget_class->expose_event = sdr_smeter_expose;
+ widget_class->size_request = sdr_smeter_size_request;
+}
+
+static void sdr_smeter_init(SDRSMeter *sm) {
+
+}
+
+static void sdr_smeter_size_request(GtkWidget *widget, GtkRequisition *requisition) {
+ // width doesn't seem to be obeyed.
+ requisition->width = 265;
+ requisition->height = 20;
+}
+
+GtkWidget *sdr_smeter_new() {
+ SDRSMeter *sm;
+ sm = g_object_new(SDR_TYPE_SMETER, NULL);
+ return GTK_WIDGET(sm);
+}
+
+static gboolean sdr_smeter_expose(GtkWidget *widget, GdkEventExpose *event) {
+ cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
+
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ cairo_paint(cr);
+
+ gint pos = SDR_SMETER(widget)->level*255;
+
+ cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
+ cairo_set_source_rgb(cr, 0.93, 1, 0.93);
+ cairo_move_to(cr, 5, 15);
+ cairo_line_to(cr, 5, 10);
+ cairo_line_to(cr, 200, 10);
+ cairo_line_to(cr, 200, 15);
+ cairo_stroke(cr);
+
+ cairo_set_source_rgb(cr, 1, 0.63, 0.63);
+ cairo_move_to(cr, 203, 15);
+ cairo_line_to(cr, 203, 10);
+ cairo_line_to(cr, 258, 10);
+ cairo_line_to(cr, 258, 15);
+ cairo_stroke(cr);
+
+ // draw bargraph
+ cairo_set_source_rgb(cr, 0.2, 0.4, 0);
+ cairo_rectangle(cr, 4, 4, 255, 4);
+ cairo_fill(cr);
+ cairo_set_source_rgb(cr, 0.6, 1.0, 0);
+ cairo_rectangle(cr, 4, 4, pos, 4);
+ cairo_fill(cr);
+
+ cairo_destroy(cr);
+ return TRUE;
+}
+
+void sdr_smeter_set_level(SDRSMeter *sm, gdouble level) {
+ sm->level = level;
+ gtk_widget_queue_draw(GTK_WIDGET(sm));
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/smeter.h b/smeter.h
new file mode 100644
index 0000000..1b147da
--- /dev/null
+++ b/smeter.h
@@ -0,0 +1,62 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ smeter.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+#ifndef __SMETER_H
+#define __SMETER_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef struct _SDRSMeter SDRSMeter;
+typedef struct _SDRSMeterClass SDRSMeterClass;
+typedef struct _SDRSMeterPrivate SDRSMeterPrivate;
+
+struct _SDRSMeter {
+ GtkDrawingArea parent;
+ gdouble level;
+};
+
+struct _SDRSMeterClass {
+ GtkDrawingAreaClass parent_class;
+};
+
+struct _SDRSMeterPrivate {
+};
+
+#define SDR_TYPE_SMETER (sdr_smeter_get_type ())
+#define SDR_SMETER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SDR_TYPE_SMETER, SDRSMeter))
+#define SDR_SMETER_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), SDR_SMETER, SDRSMeterClass))
+#define SDR_IS_SMETER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SDR_TYPE_SMETER))
+#define SDR_IS_SMETER_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), SDR_TYPE_SMETER))
+#define SDR_SMETER_GET_CLASS (G_TYPE_INSTANCE_GET_CLASS ((obj), SDR_TYPE_SMETER, SDRSMeterClass))
+#define SDR_SMETER_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), SDR_TYPE_SMETER, SDRSMeterPrivate))
+
+G_END_DECLS
+
+GtkWidget *sdr_smeter_new();
+void sdr_smeter_set_level(SDRSMeter *sm, gdouble value);
+GType sdr_smeter_get_type(void);
+
+#endif /* __SMETER_H */
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/waf b/waf
new file mode 100755
index 0000000..f3a59ec
--- /dev/null
+++ b/waf
@@ -0,0 +1,162 @@
+#!/usr/bin/env python
+# encoding: ISO8859-1
+# Thomas Nagy, 2005-2010
+
+"""
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+1. Redistributions of source code must retain the above copyright
+ notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright
+ notice, this list of conditions and the following disclaimer in the
+ documentation and/or other materials provided with the distribution.
+
+3. The name of the author may not be used to endorse or promote products
+ derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE AUTHOR "AS IS" AND ANY EXPRESS OR
+IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
+HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
+STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+"""
+
+import os, sys
+
+VERSION="1.6.4"
+REVISION="4913990afc8fed85c536a94360eda2ab"
+INSTALL=''
+C1='#1'
+C2='#.'
+cwd = os.getcwd()
+join = os.path.join
+
+
+WAF='waf'
+def b(x):
+ return x
+if sys.hexversion>0x300000f:
+ WAF='waf3'
+ def b(x):
+ return x.encode()
+
+def err(m):
+ print(('\033[91mError: %s\033[0m' % m))
+ sys.exit(1)
+
+def unpack_wafdir(dir):
+ f = open(sys.argv[0],'rb')
+ c = 'corrupt archive (%d)'
+ while 1:
+ line = f.readline()
+ if not line: err('run waf-light from a folder containing waflib')
+ if line == b('#==>\n'):
+ txt = f.readline()
+ if not txt: err(c % 1)
+ if f.readline() != b('#<==\n'): err(c % 2)
+ break
+ if not txt: err(c % 3)
+ txt = txt[1:-1].replace(b(C1), b('\n')).replace(b(C2), b('\r'))
+
+ import shutil, tarfile
+ try: shutil.rmtree(dir)
+ except OSError: pass
+ try:
+ for x in ['Tools', 'extras']:
+ os.makedirs(join(dir, 'waflib', x))
+ except OSError:
+ err("Cannot unpack waf lib into %s\nMove waf into a writeable directory" % dir)
+
+ os.chdir(dir)
+ tmp = 't.bz2'
+ t = open(tmp,'wb')
+ t.write(txt)
+ t.close()
+
+ try:
+ t = tarfile.open(tmp)
+ except:
+ try:
+ os.system('bunzip2 t.bz2')
+ t = tarfile.open('t')
+ tmp = 't'
+ except:
+ os.chdir(cwd)
+ try: shutil.rmtree(dir)
+ except OSError: pass
+ err("Waf cannot be unpacked, check that bzip2 support is present")
+
+ for x in t: t.extract(x)
+ t.close()
+
+ for x in ['Tools', 'extras']:
+ os.chmod(join('waflib',x), 493)
+
+ if sys.hexversion<0x300000f:
+ sys.path = [join(dir, 'waflib')] + sys.path
+ import fixpy2
+ fixpy2.fixdir(dir)
+
+ os.unlink(tmp)
+ os.chdir(cwd)
+
+ try: dir = unicode(dir, 'mbcs')
+ except: pass
+ try:
+ from ctypes import windll
+ windll.kernel32.SetFileAttributesW(dir, 2)
+ except:
+ pass
+
+def test(dir):
+ try:
+ os.stat(join(dir, 'waflib'))
+ return os.path.abspath(dir)
+ except OSError:
+ pass
+
+def find_lib():
+ name = sys.argv[0]
+ base = os.path.dirname(os.path.abspath(name))
+
+ #devs use $WAFDIR
+ w=test(os.environ.get('WAFDIR', ''))
+ if w: return w
+
+ #waf-light
+ if name.endswith('waf-light'):
+ w = test(base)
+ if w: return w
+ err('waf-light requires waflib -> export WAFDIR=/folder')
+
+ dirname = '%s-%s-%s' % (WAF, VERSION, REVISION)
+ for i in [INSTALL,'/usr','/usr/local','/opt']:
+ w = test(i + '/lib/' + dirname)
+ if w: return w
+
+ #waf-local
+ dir = join(base, (sys.platform != 'win32' and '.' or '') + dirname)
+ w = test(dir)
+ if w: return w
+
+ #unpack
+ unpack_wafdir(dir)
+ return dir
+
+wafdir = find_lib()
+sys.path.insert(0, wafdir)
+
+if __name__ == '__main__':
+ import waflib.extras.compat15
+ from waflib import Scripting
+ Scripting.waf_entry_point(cwd, VERSION, wafdir)
+
diff --git a/waflib/Build.py b/waflib/Build.py
new file mode 100644
index 0000000..9c7378e
--- /dev/null
+++ b/waflib/Build.py
@@ -0,0 +1,720 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys,errno,re,datetime,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):
+ try:
+ lst=Utils.listdir(self.cache_dir)
+ except OSError ,e:
+ if e.errno==errno.ENOENT:
+ raise Errors.WafError('The project was not configured: run "waf configure" first!')
+ else:
+ raise
+ if not lst:
+ raise Errors.WafError('The cache directory is empty: reconfigure the project')
+ for fname in lst:
+ if fname.endswith(CACHE_SUFFIX):
+ env=ConfigSet.ConfigSet(os.path.join(self.cache_dir,fname))
+ name=fname[:-len(CACHE_SUFFIX)]
+ 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']<Context.HEXVERSION:
+ raise Errors.WafError('Version mismatch! reconfigure the project')
+ for t in env['tools']:
+ self.setup(**t)
+ f=None
+ try:
+ try:
+ f=open(os.path.join(self.variant_dir,Context.DBFILE),'rb')
+ except(IOError,EOFError):
+ Logs.debug('build: could not load the build cache (missing)')
+ else:
+ try:
+ waflib.Node.pickle_lock.acquire()
+ waflib.Node.Nod3=self.node_class
+ try:
+ data=cPickle.load(f)
+ except Exception ,e:
+ Logs.debug('build: could not load the build cache %r'%e)
+ else:
+ for x in SAVED_ATTRS:
+ setattr(self,x,data[x])
+ finally:
+ waflib.Node.pickle_lock.release()
+ finally:
+ if f:
+ f.close()
+ self.init_dirs()
+ def store(self):
+ data={}
+ for x in SAVED_ATTRS:
+ data[x]=getattr(self,x)
+ db=os.path.join(self.variant_dir,Context.DBFILE)
+ try:
+ waflib.Node.pickle_lock.acquire()
+ waflib.Node.Nod3=self.node_class
+ f=None
+ try:
+ f=open(db+'.tmp','wb')
+ cPickle.dump(data,f)
+ finally:
+ if f:
+ f.close()
+ finally:
+ waflib.Node.pickle_lock.release()
+ try:
+ st=os.stat(db)
+ os.unlink(db)
+ if sys.platform!='win32':
+ os.chown(db+'.tmp',st.st_uid,st.st_gid)
+ except(AttributeError,OSError):
+ pass
+ os.rename(db+'.tmp',db)
+ def compile(self):
+ Logs.debug('build: compile()')
+ self.producer=Runner.Parallel(self,self.jobs)
+ self.producer.biter=self.get_build_iterator()
+ self.returned_tasks=[]
+ try:
+ self.producer.start()
+ except KeyboardInterrupt:
+ self.store()
+ raise
+ else:
+ if self.producer.dirty:
+ self.store()
+ if self.producer.error:
+ raise Errors.BuildError(self.producer.error)
+ def setup(self,tool,tooldir=None,funs=None):
+ if isinstance(tool,list):
+ for i in tool:self.setup(i,tooldir)
+ return
+ module=Context.load_tool(tool,tooldir)
+ if hasattr(module,"setup"):module.setup(self)
+ def get_env(self):
+ try:
+ return self.all_envs[self.variant]
+ except KeyError:
+ return self.all_envs['']
+ def set_env(self,val):
+ self.all_envs[self.variant]=val
+ env=property(get_env,set_env)
+ def add_manual_dependency(self,path,value):
+ if isinstance(path,waflib.Node.Node):
+ node=path
+ elif os.path.isabs(path):
+ node=self.root.find_resource(path)
+ else:
+ node=self.path.find_resource(path)
+ self.deps_man[id(node)].append(value)
+ def launch_node(self):
+ try:
+ return self.p_ln
+ except AttributeError:
+ self.p_ln=self.root.find_dir(self.launch_dir)
+ return self.p_ln
+ def hash_env_vars(self,env,vars_lst):
+ if not env.table:
+ env=env.parent
+ if not env:
+ return Utils.SIG_NIL
+ idx=str(id(env))+str(vars_lst)
+ try:
+ cache=self.cache_env
+ except AttributeError:
+ cache=self.cache_env={}
+ else:
+ try:
+ return self.cache_env[idx]
+ except KeyError:
+ pass
+ lst=[env[a]for a in vars_lst]
+ ret=Utils.h_list(lst)
+ Logs.debug('envhash: %r %r',ret,lst)
+ cache[idx]=ret
+ return ret
+ def get_tgen_by_name(self,name):
+ cache=self.task_gen_cache_names
+ if not cache:
+ for g in self.groups:
+ for tg in g:
+ try:
+ cache[tg.name]=tg
+ except AttributeError:
+ pass
+ try:
+ return cache[name]
+ except KeyError:
+ raise Errors.WafError('Could not find a task generator for the name %r'%name)
+ def progress_line(self,state,total,col1,col2):
+ n=len(str(total))
+ Utils.rot_idx+=1
+ ind=Utils.rot_chr[Utils.rot_idx%4]
+ pc=(100.*state)/total
+ eta=str(self.timer)
+ fs="[%%%dd/%%%dd][%%s%%2d%%%%%%s][%s]["%(n,n,ind)
+ left=fs%(state,total,col1,pc,col2)
+ right='][%s%s%s]'%(col1,eta,col2)
+ cols=Logs.get_term_cols()-len(left)-len(right)+2*len(col1)+2*len(col2)
+ if cols<7:cols=7
+ ratio=((cols*state)//total)-1
+ bar=('='*ratio+'>').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<self._min_grp:
+ for tg in self.groups[self.cur]:
+ try:
+ f=tg.post
+ except AttributeError:
+ pass
+ else:
+ f()
+ else:
+ for tg in self._exact_tg:
+ tg.post()
+ else:
+ ln=self.launch_node()
+ for tg in self.groups[self.cur]:
+ try:
+ f=tg.post
+ except AttributeError:
+ pass
+ else:
+ if tg.path.is_child_of(ln):
+ f()
+ def get_tasks_group(self,idx):
+ tasks=[]
+ for tg in self.groups[idx]:
+ if isinstance(tg,Task.TaskBase):
+ tasks.append(tg)
+ else:
+ tasks.extend(tg.tasks)
+ return tasks
+ def get_build_iterator(self):
+ self.cur=0
+ if self.targets and self.targets!='*':
+ (self._min_grp,self._exact_tg)=self.get_targets()
+ global lazy_post
+ if self.post_mode!=POST_LAZY:
+ while self.cur<len(self.groups):
+ self.post_group()
+ self.cur+=1
+ self.cur=0
+ while self.cur<len(self.groups):
+ if self.post_mode!=POST_AT_ONCE:
+ self.post_group()
+ tasks=self.get_tasks_group(self.cur)
+ Task.set_file_constraints(tasks)
+ Task.set_precedence_constraints(tasks)
+ self.cur_tasks=tasks
+ self.cur+=1
+ if not tasks:
+ continue
+ yield tasks
+ while 1:
+ yield[]
+class inst(Task.Task):
+ color='CYAN'
+ def post(self):
+ buf=[]
+ for x in self.source:
+ if isinstance(x,waflib.Node.Node):
+ y=x
+ else:
+ y=self.path.find_resource(x)
+ if not y:
+ idx=self.generator.bld.get_group_idx(self)
+ for tg in self.generator.bld.groups[idx]:
+ if not isinstance(tg,inst)and id(tg)!=id(self):
+ tg.post()
+ y=self.path.find_resource(x)
+ if y:
+ break
+ else:
+ raise Errors.WafError('could not find %r in %r'%(x,self.path))
+ buf.append(y)
+ self.inputs=buf
+ def runnable_status(self):
+ ret=super(inst,self).runnable_status()
+ if ret==Task.SKIP_ME:
+ return Task.RUN_ME
+ return ret
+ def __str__(self):
+ return''
+ def run(self):
+ return self.generator.exec_task()
+ def get_install_path(self):
+ dest=self.dest.replace('/',os.sep)
+ dest=Utils.subst_vars(self.dest,self.env)
+ if Options.options.destdir:
+ dest=os.path.join(Options.options.destdir,os.path.splitdrive(dest)[1].lstrip(os.sep))
+ return dest
+ def exec_install_files(self):
+ destpath=self.get_install_path()
+ if not destpath:
+ raise Errors.WafError('unknown installation path %r'%self.generator)
+ for x,y in zip(self.source,self.inputs):
+ if self.relative_trick:
+ destfile=os.path.join(destpath,y.path_from(self.path))
+ Utils.check_dir(os.path.dirname(destfile))
+ else:
+ destfile=os.path.join(destpath,y.name)
+ self.generator.bld.do_install(y.abspath(),destfile,self.chmod)
+ def exec_install_as(self):
+ destfile=self.get_install_path()
+ self.generator.bld.do_install(self.inputs[0].abspath(),destfile,self.chmod)
+ def exec_symlink_as(self):
+ destfile=self.get_install_path()
+ self.generator.bld.do_link(self.link,destfile)
+class InstallContext(BuildContext):
+ '''installs the targets on the system'''
+ cmd='install'
+ def __init__(self,**kw):
+ super(InstallContext,self).__init__(**kw)
+ self.uninstall=[]
+ self.is_install=INSTALL
+ def do_install(self,src,tgt,chmod=Utils.O644):
+ d,_=os.path.split(tgt)
+ if not d:
+ raise Errors.WafError('Invalid installation given %r->%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>=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 sys.platform=='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/*'):
+ 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(','):
+ inn=True
+ out=True
+ if pat.startswith('in:'):
+ out=False
+ pat=pat.replace('in:','')
+ elif pat.startswith('out:'):
+ inn=False
+ pat=pat.replace('out:','')
+ if not pat.startswith('^'):
+ pat='^.+?%s'%pat
+ if not pat.endswith('$'):
+ pat='%s$'%pat
+ pat=re.compile(pat)
+ for g in self.groups:
+ for tg in g:
+ if isinstance(tg,Task.TaskBase):
+ lst=[tg]
+ else:
+ lst=tg.tasks
+ for tsk in lst:
+ do_exec=False
+ if inn:
+ for node in getattr(tsk,'inputs',[]):
+ if pat.match(node.abspath()):
+ do_exec=True
+ break
+ if out and not do_exec:
+ for node in getattr(tsk,'outputs',[]):
+ if pat.match(node.abspath()):
+ do_exec=True
+ break
+ if do_exec:
+ ret=tsk.run()
+ Logs.info('%s -> %r'%(str(tsk),ret))
+BuildContext.store=Utils.nogc(BuildContext.store)
+BuildContext.restore=Utils.nogc(BuildContext.restore)
diff --git a/waflib/ConfigSet.py b/waflib/ConfigSet.py
new file mode 100644
index 0000000..6d7f291
--- /dev/null
+++ b/waflib/ConfigSet.py
@@ -0,0 +1,145 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import os,copy,re
+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 __str__(self):
+ keys=set()
+ cur=self
+ while cur:
+ keys.update(cur.table.keys())
+ cur=getattr(cur,'parent',None)
+ keys=list(keys)
+ keys.sort()
+ return"\n".join(["%r %r"%(x,self.__getitem__(x))for x in 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,value):
+ del self.table[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):
+ 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 --git a/waflib/Configure.py b/waflib/Configure.py
new file mode 100644
index 0000000..4ff3758
--- /dev/null
+++ b/waflib/Configure.py
@@ -0,0 +1,314 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 ,e:
+ 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 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','')
+ 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)<ver:
+ self.fatal('waf version should be at most %r (%r found)'%(Utils.num2ver(maxi),ver))
+ self.end_msg('ok')
+def find_file(self,filename,path_list=[]):
+ for n in Utils.to_list(filename):
+ for d in Utils.to_list(path_list):
+ p=os.path.join(d,n)
+ if os.path.exists(p):
+ return p
+ self.fatal('Could not find %r'%filename)
+def find_program(self,filename,**kw):
+ exts=kw.get('exts',Options.platform=='win32'and'.exe,.com,.bat,.cmd'or',.sh,.pl,.py')
+ environ=kw.get('environ',os.environ)
+ ret=''
+ filename=Utils.to_list(filename)
+ var=kw.get('var','')
+ if not var:
+ var=filename[0].upper()
+ if self.env[var]:
+ ret=self.env[var]
+ elif var in environ:
+ ret=environ[var]
+ path_list=kw.get('path_list','')
+ if not ret:
+ if path_list:
+ path_list=Utils.to_list(path_list)
+ else:
+ path_list=environ.get('PATH','').split(os.pathsep)
+ if not isinstance(filename,list):
+ filename=[filename]
+ for a in exts.split(','):
+ if ret:
+ break
+ for b in filename:
+ if ret:
+ break
+ for c in path_list:
+ if ret:
+ break
+ x=os.path.expanduser(os.path.join(c,b+a))
+ if os.path.isfile(x):
+ ret=x
+ if not ret and Utils.winreg:
+ ret=Utils.get_registry_app_path(Utils.winreg.HKEY_CURRENT_USER,filename)
+ if not ret and Utils.winreg:
+ ret=Utils.get_registry_app_path(Utils.winreg.HKEY_LOCAL_MACHINE,filename)
+ self.msg('Checking for program '+','.join(filename),ret or False)
+ self.to_log('find program=%r paths=%r var=%r -> %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:
+ perl=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 --git a/waflib/Context.py b/waflib/Context.py
new file mode 100644
index 0000000..8745fa9
--- /dev/null
+++ b/waflib/Context.py
@@ -0,0 +1,302 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import traceback,os,imp,sys
+from waflib import Utils,Errors,Logs
+import waflib.Node
+HEXVERSION=0x1060400
+WAFVERSION="1.6.4"
+WAFREVISION="11188"
+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/svn/'
+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)
+ if node and(not once or node not in cache):
+ cache[node]=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)
+ if err:
+ self.logger.error('err: %s'%err)
+ 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:
+ try:
+ self.to_log(str(err))
+ except:
+ pass
+ raise Errors.WafError('Execution failure',ex=e)
+ if not isinstance(out,str):
+ out=out
+ if not isinstance(err,str):
+ err=err
+ 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 --git a/waflib/Errors.py b/waflib/Errors.py
new file mode 100644
index 0000000..711f030
--- /dev/null
+++ b/waflib/Errors.py
@@ -0,0 +1,37 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import traceback,os,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 --git a/waflib/Logs.py b/waflib/Logs.py
new file mode 100644
index 0000000..a56b8a4
--- /dev/null
+++ b/waflib/Logs.py
@@ -0,0 +1,147 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,re,logging,traceback,sys
+try:
+ if'NOCOLOR'not in os.environ:
+ import waflib.ansiterm
+except:
+ pass
+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 or'NOCOLOR'in os.environ:
+ 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
+ zone=''
+ m=re_log.match(rec.msg)
+ if m:
+ zone=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:
+ return'%s%s%s'%(rec.c1,rec.msg.decode('utf-8'),rec.c2)
+ except:
+ return rec.c1+rec.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 --git a/waflib/Node.py b/waflib/Node.py
new file mode 100644
index 0000000..7bc3b89
--- /dev/null
+++ b/waflib/Node.py
@@ -0,0 +1,492 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 sys.platform=='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 ,e:
+ 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:
+ 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 not self.parent:
+ val=os.sep=='/'and os.sep or''
+ elif not self.parent.name:
+ val=(os.sep=='/'and os.sep or'')+self.name
+ else:
+ val=self.parent.abspath()+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):
+ 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
+ return self
+ 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.search(lst)
+ if not node:
+ 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.ctx.path()
+ 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 --git a/waflib/Options.py b/waflib/Options.py
new file mode 100644
index 0000000..785ff35
--- /dev/null
+++ b/waflib/Options.py
@@ -0,0 +1,127 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,types,tempfile,optparse,sys
+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-wafbuild')
+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=False,action='store_true',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:
+ 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=''
+ fun='options'
+ def __init__(self,**kw):
+ super(self.__class__,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 sys.platform=='win32':
+ 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'))
+ elif os.name!='java':
+ tmp=self.cmd_and_log(['sysctl','-n','hw.ncpu'])
+ 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:
+ return self.parser.get_option_group(opt_str)
+ 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 --git a/waflib/Runner.py b/waflib/Runner.py
new file mode 100644
index 0000000..efbec0f
--- /dev/null
+++ b/waflib/Runner.py
@@ -0,0 +1,192 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys,random,atexit
+try:
+ from queue import Queue
+except:
+ from Queue import Queue
+from waflib import Utils,Logs,Task,Errors
+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:
+ pool=self.pool
+ except AttributeError:
+ pool=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
+ try:
+ st=tsk.runnable_status()
+ except Exception ,e:
+ self.processed+=1
+ if self.stop and not self.bld.keep:
+ tsk.hasrun=Task.SKIPPED
+ continue
+ tsk.err_msg=Utils.ex_stack()
+ tsk.hasrun=Task.EXCEPTION
+ self.error_handler(tsk)
+ continue
+ if st==Task.ASK_LATER:
+ self.postpone(tsk)
+ if self.outstanding:
+ for x in tsk.run_after:
+ if x in self.outstanding:
+ self.outstanding.remove(x)
+ self.outstanding.insert(0,x)
+ 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 --git a/waflib/Scripting.py b/waflib/Scripting.py
new file mode 100644
index 0000000..6caa9cf
--- /dev/null
+++ b/waflib/Scripting.py
@@ -0,0 +1,355 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,shutil,traceback,datetime,inspect,errno,sys,stat
+from waflib import Utils,Configure,Logs,Options,ConfigSet,Context,Errors,Build,Node
+build_dir_override=None
+no_climb_commands=['configure']
+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,WAFVERSION,wafdir))
+ sys.exit(1)
+ if'--version'in sys.argv:
+ opt_obj=Options.OptionsContext()
+ opt_obj.curdir=current_directory
+ opt_obj.parse_args()
+ sys.exit(0)
+ Context.waf_dir=wafdir
+ Context.launch_dir=current_directory
+ 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 sys.platform=='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
+ for k in no_climb_commands:
+ if k in sys.argv:
+ break
+ else:
+ continue
+ 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')
+ opt_obj=Options.OptionsContext()
+ opt_obj.curdir=current_directory
+ opt_obj.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)
+ parse_options()
+ 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():
+ opt=Options.OptionsContext().execute()
+ if not Options.commands:
+ Options.commands=['build']
+ 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():
+ 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[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:
+ tinfo=tar.gettarinfo(name=x.abspath(),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(x.abspath(),'rb')
+ tar.addfile(tinfo,fileobj=fu)
+ finally:
+ fu.close()
+ 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_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 ,e:
+ 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 --git a/waflib/Task.py b/waflib/Task.py
new file mode 100644
index 0000000..4e11630
--- /dev/null
+++ b/waflib/Task.py
@@ -0,0 +1,650 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import os,shutil,re,tempfile
+from waflib import Utils,Logs,Errors
+NOT_RUN=0
+MISSING=1
+CRASHED=2
+EXCEPTION=3
+SKIPPED=8
+SUCCESS=9
+ASK_LATER=-1
+SKIP_ME=-2
+RUN_ME=-3
+COMPILE_TEMPLATE_SHELL='''
+def f(tsk):
+ env = tsk.env
+ gen = tsk.generator
+ bld = gen.bld
+ wd = getattr(tsk, 'cwd', None)
+ p = env.get_flat
+ tsk.last_cmd = cmd = \'\'\' %s \'\'\' % s
+ return tsk.exec_command(cmd, cwd=wd, env=env.env or None)
+'''
+COMPILE_TEMPLATE_NOSHELL='''
+def f(tsk):
+ env = tsk.env
+ gen = tsk.generator
+ bld = gen.bld
+ wd = getattr(tsk, 'cwd', None)
+ def to_list(xx):
+ if isinstance(xx, str): return [xx]
+ return xx
+ tsk.last_cmd = lst = []
+ %s
+ lst = [x for x in lst if x]
+ return tsk.exec_command(lst, cwd=wd, env=env.env or None)
+'''
+def cache_outputs(cls):
+ m1=cls.run
+ def run(self):
+ bld=self.generator.bld
+ if bld.cache_global and not bld.nocache:
+ if self.can_retrieve_cache():
+ return 0
+ return m1(self)
+ cls.run=run
+ m2=cls.post_run
+ def post_run(self):
+ bld=self.generator.bld
+ ret=m2(self)
+ if bld.cache_global and not bld.nocache:
+ self.put_files_cache()
+ return ret
+ cls.post_run=post_run
+ return cls
+classes={}
+class store_task_type(type):
+ def __init__(cls,name,bases,dict):
+ super(store_task_type,cls).__init__(name,bases,dict)
+ name=cls.__name__
+ if name.endswith('_task'):
+ name=name.replace('_task','')
+ if name!='evil'and name!='TaskBase':
+ global classes
+ if getattr(cls,'run_str',None):
+ (f,dvars)=compile_fun(cls.run_str,cls.shell)
+ cls.hcode=cls.run_str
+ cls.run_str=None
+ cls.run=f
+ cls.vars=[]
+ cls.vars.extend(dvars)
+ elif getattr(cls,'run',None)and not'hcode'in cls.__dict__:
+ cls.hcode=Utils.h_fun(cls.run)
+ if not getattr(cls,'nocache',None):
+ cls=cache_outputs(cls)
+ classes[name]=cls
+evil=store_task_type('evil',(object,),{})
+class TaskBase(evil):
+ color='GREEN'
+ ext_in=[]
+ ext_out=[]
+ before=[]
+ after=[]
+ hcode=''
+ def __init__(self,*k,**kw):
+ self.hasrun=NOT_RUN
+ try:
+ self.generator=kw['generator']
+ except KeyError:
+ self.generator=self
+ def __repr__(self):
+ return'\n\t{task %r: %s %s}'%(self.__class__.__name__,id(self),str(getattr(self,'fun','')))
+ def __str__(self):
+ if hasattr(self,'fun'):
+ return'executing: %s\n'%self.fun.__name__
+ return self.__class__.__name__+'\n'
+ def __hash__(self):
+ return id(self)
+ def exec_command(self,cmd,**kw):
+ bld=self.generator.bld
+ try:
+ if not kw.get('cwd',None):
+ kw['cwd']=bld.cwd
+ except AttributeError:
+ bld.cwd=kw['cwd']=bld.variant_dir
+ return bld.exec_command(cmd,**kw)
+ def runnable_status(self):
+ return RUN_ME
+ def process(self):
+ m=self.master
+ if m.stop:
+ m.out.put(self)
+ return
+ try:
+ del self.generator.bld.task_sigs[self.uid()]
+ except:
+ pass
+ try:
+ self.generator.bld.returned_tasks.append(self)
+ self.log_display(self.generator.bld)
+ ret=self.run()
+ except Exception ,e:
+ self.err_msg=Utils.ex_stack()
+ self.hasrun=EXCEPTION
+ m.error_handler(self)
+ m.out.put(self)
+ return
+ if ret:
+ self.err_code=ret
+ self.hasrun=CRASHED
+ else:
+ try:
+ self.post_run()
+ except Errors.WafError:
+ pass
+ except Exception:
+ self.err_msg=Utils.ex_stack()
+ self.hasrun=EXCEPTION
+ else:
+ self.hasrun=SUCCESS
+ if self.hasrun!=SUCCESS:
+ m.error_handler(self)
+ m.out.put(self)
+ def run(self):
+ if hasattr(self,'fun'):
+ return self.fun(self)
+ return 0
+ def post_run(self):
+ pass
+ def log_display(self,bld):
+ bld.to_log(self.display())
+ def display(self):
+ col1=Logs.colors(self.color)
+ col2=Logs.colors.NORMAL
+ if self.generator.bld.progress_bar==1:
+ return self.generator.bld.progress_line(self.generator.bld.producer.processed-1,self.position[1],col1,col2)
+ if self.generator.bld.progress_bar==2:
+ ela=str(self.generator.bld.timer)
+ try:
+ ins=','.join([n.name for n in self.inputs])
+ except AttributeError:
+ ins=''
+ try:
+ outs=','.join([n.name for n in self.outputs])
+ except AttributeError:
+ outs=''
+ return'|Total %s|Current %s|Inputs %s|Outputs %s|Time %s|\n'%(self.position[1],self.generator.bld.producer.processed-1,ins,outs,ela)
+ s=str(self)
+ if not s:
+ return None
+ total=self.position[1]
+ n=len(str(total))
+ fs='[%%%dd/%%%dd] %%s%%s%%s'%(n,n)
+ return fs%(self.generator.bld.producer.processed-1,self.position[1],col1,s,col2)
+ def attr(self,att,default=None):
+ ret=getattr(self,att,self)
+ if ret is self:return getattr(self.__class__,att,default)
+ return ret
+ def hash_constraints(self):
+ cls=self.__class__
+ tup=(str(cls.before),str(cls.after),str(cls.ext_in),str(cls.ext_out),cls.__name__,cls.hcode)
+ h=hash(tup)
+ return h
+ def format_error(self):
+ msg=getattr(self,'last_cmd','')
+ if getattr(self,"err_msg",None):
+ return self.err_msg
+ elif self.hasrun==CRASHED:
+ try:
+ return' -> 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'?'
+ 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:
+ imp_sig=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
+ env=self.env
+ 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
+ env=self.env
+ 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 IOError:
+ 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()
+ bld.task_sigs[(key,'imp')]=sig=self.compute_sig_implicit_deps()
+ return sig
+ def compute_sig_implicit_deps(self):
+ upd=self.m.update
+ bld=self.generator.bld
+ env=self.env
+ self.are_implicit_nodes_ready()
+ try:
+ for k in bld.node_deps.get(self.uid(),[]):
+ upd(k.get_bld_sig())
+ except:
+ if Logs.verbose:
+ Logs.warn('Missing signature for node %r (may cause rebuilds)'%k)
+ 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
+ env=self.env
+ sig=self.signature()
+ ssig=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
+ sig=self.signature()
+ ssig=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<backslash>\\)|(?P<dollar>\$\$)|(?P<subst>\$\{(?P<var>\w+)(?P<code>.*?)\})",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())
+ 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
+ new_sig=self.signature()
+ prev_sig=bld.task_sigs[self.uid()]
+ if prev_sig==new_sig:
+ for x in self.outputs:
+ if not x.sig:
+ return RUN_ME
+ return SKIP_ME
+ except KeyError:
+ pass
+ except IndexError:
+ pass
+ return RUN_ME
+ cls.runnable_status=runnable_status
+ return cls
diff --git a/waflib/TaskGen.py b/waflib/TaskGen.py
new file mode 100644
index 0000000..be6cccf
--- /dev/null
+++ b/waflib/TaskGen.py
@@ -0,0 +1,332 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import copy,re
+from waflib import Task,Utils,Logs,Errors
+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)]=0
+ for key,val in kw.items():
+ setattr(self,key,val)
+ def __str__(self):
+ return"<task_gen %r declared in %s>"%(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(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=True,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]
+ out_source=[node.change_ext(x,ext_in=_ext_in)for x in ext]
+ if reentrant:
+ for i in range(reentrant):
+ self.source.append(out_source[i])
+ tsk=self.create_task(name,node,out_source)
+ if install_path:
+ self.bld.install_files(install_path,out_source)
+ return tsk
+ for x in cls.ext_in:
+ task_gen.mappings[x]=x_file
+ return x_file
+def taskgen_method(func):
+ setattr(task_gen,func.__name__,func)
+ return func
+def feature(*k):
+ def deco(func):
+ setattr(task_gen,func.__name__,func)
+ for name in k:
+ feats[name].update([func.__name__])
+ return func
+ return deco
+def before_method(*k):
+ def deco(func):
+ setattr(task_gen,func.__name__,func)
+ for fun_name in k:
+ if not func.__name__ in task_gen.prec[fun_name]:
+ task_gen.prec[fun_name].append(func.__name__)
+ return func
+ return deco
+before=before_method
+def after_method(*k):
+ def deco(func):
+ setattr(task_gen,func.__name__,func)
+ for fun_name in k:
+ if not fun_name in task_gen.prec[func.__name__]:
+ task_gen.prec[func.__name__].append(fun_name)
+ return func
+ return deco
+after=after_method
+def extension(*k):
+ def deco(func):
+ setattr(task_gen,func.__name__,func)
+ for x in k:
+ task_gen.mappings[x]=func
+ return func
+ return deco
+def to_nodes(self,lst,path=None):
+ tmp=[]
+ path=path or self.path
+ find=path.find_resource
+ if isinstance(lst,self.path.__class__):
+ lst=[lst]
+ for x in Utils.to_list(lst):
+ if isinstance(x,str):
+ node=find(x)
+ if not node:
+ raise Errors.WafError("source not found: %r in %r"%(x,self))
+ else:
+ node=x
+ tmp.append(node)
+ return tmp
+def process_source(self):
+ self.source=self.to_nodes(getattr(self,'source',[]))
+ for node in self.source:
+ self.get_hook(node)(self,node)
+def process_rule(self):
+ if not getattr(self,'rule',None):
+ return
+ name=str(getattr(self,'name',None)or self.target or self.rule)
+ cls=Task.task_factory(name,self.rule,getattr(self,'vars',[]),shell=getattr(self,'shell',True),color=getattr(self,'color','BLUE'))
+ tsk=self.create_task(name)
+ if getattr(self,'target',None):
+ if isinstance(self.target,str):
+ self.target=self.target.split()
+ if not isinstance(self.target,list):
+ self.target=[self.target]
+ for x in self.target:
+ if isinstance(x,str):
+ tsk.outputs.append(self.path.find_or_declare(x))
+ else:
+ x.parent.mkdir()
+ tsk.outputs.append(x)
+ if getattr(self,'install_path',None):
+ self.bld.install_files(self.install_path,tsk.outputs)
+ if getattr(self,'source',None):
+ tsk.inputs=self.to_nodes(self.source)
+ self.source=[]
+ if getattr(self,'scan',None):
+ cls.scan=self.scan
+ if getattr(self,'cwd',None):
+ tsk.cwd=self.cwd
+ if getattr(self,'update_outputs',None)or getattr(self,'on_results',None):
+ Task.update_outputs(cls)
+ if getattr(self,'always',None):
+ Task.always_run(cls)
+ for x in['after','before','ext_in','ext_out']:
+ setattr(cls,x,getattr(self,x,[]))
+def sequence_order(self):
+ if self.meths and self.meths[-1]!='sequence_order':
+ self.meths.append('sequence_order')
+ return
+ if getattr(self,'seq_start',None):
+ return
+ if getattr(self.bld,'prev',None):
+ self.bld.prev.post()
+ for x in self.bld.prev.tasks:
+ for y in self.tasks:
+ y.set_run_after(x)
+ self.bld.prev=self
+re_m4=re.compile('@(\w+)@',re.M)
+class subst_pc(Task.Task):
+ def run(self):
+ code=self.inputs[0].read()
+ code=code.replace('%','%%')
+ lst=[]
+ def repl(match):
+ g=match.group
+ if g(1):
+ lst.append(g(1))
+ return"%%(%s)s"%g(1)
+ return''
+ code=re_m4.sub(repl,code)
+ try:
+ d=self.generator.dct
+ except AttributeError:
+ d={}
+ for x in lst:
+ d[x]=getattr(self.generator,x,'')or self.env.get_flat(x)or self.env.get_flat(x.upper())
+ if not d[x]and not getattr(self.generator,'quiet',False):
+ raise ValueError('variable %r has no value for %r'%(x,self.outputs))
+ self.outputs[0].write(code%d)
+ self.generator.bld.raw_deps[self.uid()]=self.dep_vars=lst
+ try:delattr(self,'cache_sig')
+ except AttributeError:pass
+ def sig_vars(self):
+ bld=self.generator.bld
+ env=self.env
+ upd=self.m.update
+ vars=self.generator.bld.raw_deps.get(self.uid(),[])
+ act_sig=bld.hash_env_vars(env,vars)
+ upd(act_sig)
+ lst=[getattr(self.generator,x,'')for x in vars]
+ upd(Utils.h_list(lst))
+ return self.m.digest()
+def add_pcfile(self,node):
+ tsk=self.create_task('subst_pc',node,node.change_ext('.pc','.pc.in'))
+ self.bld.install_files(getattr(self,'install_path','${LIBDIR}/pkgconfig/'),tsk.outputs)
+class subst(subst_pc):
+ pass
+def process_subst(self):
+ src=self.to_nodes(getattr(self,'source',[]))
+ tgt=getattr(self,'target',[])
+ if isinstance(tgt,self.path.__class__):
+ tgt=[tgt]
+ tgt=[isinstance(x,self.path.__class__)and x or self.path.find_or_declare(x)for x in Utils.to_list(tgt)]
+ if len(src)!=len(tgt):
+ raise Errors.WafError('invalid source or target for %r'%self)
+ for x,y in zip(src,tgt):
+ if not(x and y):
+ raise Errors.WafError('invalid source or target for %r'%self)
+ tsk=self.create_task('subst',x,y)
+ for a in('after','before','ext_in','ext_out'):
+ val=getattr(self,a,None)
+ if val:
+ setattr(tsk,a,val)
+ inst_to=getattr(self,'install_path',None)
+ if inst_to:
+ self.bld.install_files(inst_to,tgt,chmod=getattr(self,'chmod',Utils.O644))
+ self.source=[]
+
+taskgen_method(to_nodes)
+feature('*')(process_source)
+feature('*')(process_rule)
+before_method('process_source')(process_rule)
+feature('seq')(sequence_order)
+extension('.pc.in')(add_pcfile)
+feature('subst')(process_subst)
+before_method('process_source','process_rule')(process_subst)
\ No newline at end of file
diff --git a/waflib/Tools/__init__.py b/waflib/Tools/__init__.py
new file mode 100644
index 0000000..95a3b6a
--- /dev/null
+++ b/waflib/Tools/__init__.py
@@ -0,0 +1,4 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
diff --git a/waflib/Tools/ar.py b/waflib/Tools/ar.py
new file mode 100644
index 0000000..abbc52a
--- /dev/null
+++ b/waflib/Tools/ar.py
@@ -0,0 +1,13 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os
+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 --git a/waflib/Tools/asm.py b/waflib/Tools/asm.py
new file mode 100644
index 0000000..b863aea
--- /dev/null
+++ b/waflib/Tools/asm.py
@@ -0,0 +1,25 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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} ${AS_TGT_F}${TGT} ${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 --git a/waflib/Tools/bison.py b/waflib/Tools/bison.py
new file mode 100644
index 0000000..20c5ac8
--- /dev/null
+++ b/waflib/Tools/bison.py
@@ -0,0 +1,29 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/c.py b/waflib/Tools/c.py
new file mode 100644
index 0000000..72c530d
--- /dev/null
+++ b/waflib/Tools/c.py
@@ -0,0 +1,26 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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} ${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} ${LINKFLAGS}'
+ ext_out=['.bin']
+ 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 --git a/waflib/Tools/c_aliases.py b/waflib/Tools/c_aliases.py
new file mode 100644
index 0000000..64a681c
--- /dev/null
+++ b/waflib/Tools/c_aliases.py
@@ -0,0 +1,56 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/c_config.py b/waflib/Tools/c_config.py
new file mode 100644
index 0000000..e07a7ee
--- /dev/null
+++ b/waflib/Tools/c_config.py
@@ -0,0 +1,688 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import os,imp,sys,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','__POWERPC__':'powerpc','__QNX__':'qnx'}
+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):
+ 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)
+ appu('LIB_'+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('-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
+ if'args'in kw:
+ lst+=Utils.to_list(kw['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))
+ 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={}
+ env.update(dict(os.environ))
+ env['LD_LIBRARY_PATH']=self.inputs[0].parent.abspath()
+ 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+(sys.platform!='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
+ 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 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(add_as_needed)
+conf(multicheck)
\ No newline at end of file
diff --git a/waflib/Tools/c_osx.py b/waflib/Tools/c_osx.py
new file mode 100644
index 0000000..da0a3ff
--- /dev/null
+++ b/waflib/Tools/c_osx.py
@@ -0,0 +1,116 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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='''
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist SYSTEM "file://localhost/System/Library/DTDs/PropertyList.dtd">
+<plist version="0.9">
+<dict>
+ <key>CFBundlePackageType</key>
+ <string>APPL</string>
+ <key>CFBundleGetInfoString</key>
+ <string>Created by Waf</string>
+ <key>CFBundleSignature</key>
+ <string>????</string>
+ <key>NOTE</key>
+ <string>THIS IS A GENERATED FILE, DO NOT MODIFY</string>
+ <key>CFBundleExecutable</key>
+ <string>%s</string>
+</dict>
+</plist>
+'''
+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 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_resource(x)
+ if node:
+ rel=node.path_from(self.path)
+ tsk=self.create_task('macapp',node,res_dir.make_node(rel))
+ self.bld.install_as(inst_to+'/%s'%rel,node)
+ else:
+ raise Errors.WafError('Missing mac_resource %r in %r'%(x,self))
+ 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=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 --git a/waflib/Tools/c_preproc.py b/waflib/Tools/c_preproc.py
new file mode 100644
index 0000000..00d46a1
--- /dev/null
+++ b/waflib/Tools/c_preproc.py
@@ -0,0 +1,606 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 sys.platform=="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<hex>[a-fA-F0-9]+)(?P<qual1>[uUlL]*)|L*?'(?P<char>(\\.|[^\\'])+)'|(?P<n1>\d+)[Ee](?P<exp0>[+-]*?\d+)(?P<float0>[fFlL]*)|(?P<n2>\d*\.\d+)([Ee](?P<exp1>[+-]*?\d+))?(?P<float1>[fFlL]*)|(?P<n4>\d+\.\d*)([Ee](?P<exp2>[+-]*?\d+))?(?P<float2>[fFlL]*)|(?P<oct>0*)(?P<n0>\d+)(?P<qual2>[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<b)
+ elif d=='>':c=int(a>b)
+ elif d=='>=':c=int(a>=b)
+ elif d=='^':c=int(a^b)
+ elif d=='<<':c=a<<b
+ elif d=='>>':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<len(lst):
+ (p,v)=lst[i]
+ if p==OP:
+ if v==')':
+ count_par-=1
+ if count_par==0:
+ break
+ elif v=='(':
+ count_par+=1
+ i+=1
+ else:
+ raise PreprocError("rparen expected %r"%lst)
+ (num,_)=get_term(lst[1:i])
+ return(num,lst[i+1:])
+ elif v=='+':
+ return get_num(lst[1:])
+ elif v=='-':
+ num,lst=get_num(lst[1:])
+ return(reduce_nums('-1',num,'*'),lst)
+ elif v=='!':
+ num,lst=get_num(lst[1:])
+ return(int(not int(num)),lst)
+ elif v=='~':
+ return(~int(num),lst)
+ else:
+ raise PreprocError("Invalid op token %r for get_num"%lst)
+ elif p==NUM:
+ return v,lst[1:]
+ elif p==IDENT:
+ return 0,lst[1:]
+ else:
+ raise PreprocError("Invalid token %r for get_num"%lst)
+def get_term(lst):
+ if not lst:raise PreprocError("empty list for get_term")
+ num,lst=get_num(lst)
+ if not lst:
+ return(num,[])
+ (p,v)=lst[0]
+ if p==OP:
+ if v=='&&'and not num:
+ return(num,[])
+ elif v=='||'and num:
+ return(num,[])
+ elif v==',':
+ return get_term(lst[1:])
+ elif v=='?':
+ count_par=0
+ i=1
+ while i<len(lst):
+ (p,v)=lst[i]
+ if p==OP:
+ if v==')':
+ count_par-=1
+ elif v=='(':
+ count_par+=1
+ elif v==':':
+ if count_par==0:
+ break
+ i+=1
+ else:
+ raise PreprocError("rparen expected %r"%lst)
+ if int(num):
+ return get_term(lst[1:i])
+ else:
+ return get_term(lst[i+1:])
+ else:
+ num2,lst=get_num(lst[1:])
+ if not lst:
+ num2=reduce_nums(num,num2,v)
+ return get_term([(NUM,num2)]+lst)
+ p2,v2=lst[0]
+ if p2!=OP:
+ raise PreprocError("op expected %r"%lst)
+ if prec[v2]>=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):
+ (p,v)=lst[i]
+ if p==IDENT and v=="defined":
+ del lst[i]
+ if i<len(lst):
+ (p2,v2)=lst[i]
+ if p2==IDENT:
+ if v2 in defs:
+ lst[i]=(NUM,1)
+ else:
+ lst[i]=(NUM,0)
+ elif p2==OP and v2=='(':
+ del lst[i]
+ (p2,v2)=lst[i]
+ del lst[i]
+ if v2 in defs:
+ lst[i]=(NUM,1)
+ else:
+ lst[i]=(NUM,0)
+ else:
+ raise PreprocError("Invalid define expression %r"%lst)
+ elif p==IDENT and v in defs:
+ if isinstance(defs[v],str):
+ a,b=extract_macro(defs[v])
+ defs[v]=b
+ macro_def=defs[v]
+ to_add=macro_def[1]
+ if isinstance(macro_def[0],list):
+ del lst[i]
+ for x in range(len(to_add)):
+ lst.insert(i,to_add[x])
+ i+=1
+ else:
+ args=[]
+ del lst[i]
+ if 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 i<len(lst):
+ p2,v2=lst[i]
+ del lst[i]
+ if p2==OP and count_paren==0:
+ if v2=='(':
+ one_param.append((p2,v2))
+ count_paren+=1
+ elif v2==')':
+ if one_param:args.append(one_param)
+ break
+ elif v2==',':
+ if not one_param:raise PreprocError("empty param in funcall %s"%p)
+ args.append(one_param)
+ one_param=[]
+ else:
+ one_param.append((p2,v2))
+ else:
+ one_param.append((p2,v2))
+ if v2=='(':count_paren+=1
+ elif v2==')':count_paren-=1
+ else:
+ raise PreprocError('malformed macro')
+ accu=[]
+ arg_table=macro_def[0]
+ j=0
+ while j<len(to_add):
+ (p2,v2)=to_add[j]
+ if p2==OP and v2=='#':
+ if j+1<len(to_add)and to_add[j+1][0]==IDENT and to_add[j+1][1]in arg_table:
+ toks=args[arg_table[to_add[j+1][1]]]
+ accu.append((STR,stringize(toks)))
+ j+=1
+ else:
+ accu.append((p2,v2))
+ elif p2==OP and v2=='##':
+ if accu and j+1<len(to_add):
+ t1=accu[-1]
+ if to_add[j+1][0]==IDENT and to_add[j+1][1]in arg_table:
+ toks=args[arg_table[to_add[j+1][1]]]
+ if toks:
+ accu[-1]=paste_tokens(t1,toks[0])
+ accu.extend(toks[1:])
+ else:
+ accu.append((p2,v2))
+ accu.extend(toks)
+ elif to_add[j+1][0]==IDENT and to_add[j+1][1]=='__VA_ARGS__':
+ va_toks=[]
+ st=len(macro_def[0])
+ pt=len(args)
+ for x in args[pt-st+1:]:
+ va_toks.extend(x)
+ va_toks.append((OP,','))
+ if va_toks:va_toks.pop()
+ if len(accu)>1:
+ (p3,v3)=accu[-1]
+ (p4,v4)=accu[-2]
+ if v3=='##':
+ accu.pop()
+ if v4==','and pt<st:
+ accu.pop()
+ accu+=va_toks
+ else:
+ accu[-1]=paste_tokens(t1,to_add[j+1])
+ j+=1
+ else:
+ accu.append((p2,v2))
+ elif p2==IDENT and v2 in arg_table:
+ toks=args[arg_table[v2]]
+ reduce_tokens(toks,defs,ban+[v])
+ accu.extend(toks)
+ else:
+ accu.append((p2,v2))
+ j+=1
+ reduce_tokens(accu,defs,ban+[v])
+ for x in range(len(accu)-1,-1,-1):
+ lst.insert(i,accu[x])
+ i+=1
+def eval_macro(lst,defs):
+ reduce_tokens(lst,defs,[])
+ if not lst:raise PreprocError("missing tokens to evaluate")
+ (p,v)=reduce_eval(lst)
+ return int(v)!=0
+def extract_macro(txt):
+ t=tokenize(txt)
+ if re_fun.search(txt):
+ p,name=t[0]
+ p,v=t[1]
+ if p!=OP:raise PreprocError("expected open parenthesis")
+ i=1
+ pindex=0
+ params={}
+ prev='('
+ while 1:
+ i+=1
+ p,v=t[i]
+ if prev=='(':
+ if p==IDENT:
+ params[v]=pindex
+ pindex+=1
+ prev=p
+ elif p==OP and v==')':
+ break
+ else:
+ raise PreprocError("unexpected token (3)")
+ elif prev==IDENT:
+ if p==OP and v==',':
+ prev=v
+ elif p==OP and v==')':
+ break
+ else:
+ raise PreprocError("comma or ... expected")
+ elif prev==',':
+ if p==IDENT:
+ params[v]=pindex
+ pindex+=1
+ prev=p
+ elif p==OP and v=='...':
+ raise PreprocError("not implemented (1)")
+ else:
+ raise PreprocError("comma or ... expected (2)")
+ elif prev=='...':
+ raise PreprocError("not implemented (2)")
+ else:
+ raise PreprocError("unexpected else")
+ return(name,[params,t[i+1:]])
+ else:
+ (p,v)=t[0]
+ return(v,[[],t[1:]])
+re_include=re.compile('^\s*(<(?P<a>.*)>|"(?P<b>.*)")')
+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
+ 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 --git a/waflib/Tools/c_tests.py b/waflib/Tools/c_tests.py
new file mode 100644
index 0000000..ae03a2a
--- /dev/null
+++ b/waflib/Tools/c_tests.py
@@ -0,0 +1,108 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+from waflib.Configure import conf
+from waflib.TaskGen import feature,before_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)
+ 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=m+'shlib',source='test.'+mode,target='test')
+ bld(features=m+'program test_exec',source='main.c',target='app',use='test',rpath=rpath)
+def check_library(self,mode=None):
+ 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)
+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 <unistd.h>\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'
+ try:
+ if self.env.DEST_BINFMT!='pe':
+ self.check(**kw)
+ except self.errors.ConfigurationError:
+ pass
+ else:
+ return True
+ kw['msg']='Checking for -D_FILE_OFFSET_BITS=64'
+ kw['defines']=['_FILE_OFFSET_BITS=64']
+ try:
+ self.check(**kw)
+ except self.errors.ConfigurationError:
+ pass
+ else:
+ self.define('_FILE_OFFSET_BITS',64)
+ return True
+ self.fatal('There is no support for large files')
+
+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)
\ No newline at end of file
diff --git a/waflib/Tools/ccroot.py b/waflib/Tools/ccroot.py
new file mode 100644
index 0000000..9603599
--- /dev/null
+++ b/waflib/Tools/ccroot.py
@@ -0,0 +1,298 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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
+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:
+ 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]=='#':
+ lst.append(self.bld.bldnode.make_node(x[1:]))
+ lst.append(self.bld.srcnode.make_node(x[1:]))
+ else:
+ lst.append(self.path.get_bld().make_node(x))
+ lst.append(self.path.make_node(x))
+ 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)
+ if getattr(self.bld,'is_install',None):
+ 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.seen_libs:
+ return
+ else:
+ self.seen_libs.add(name)
+ objects=kw.get('objects',True)
+ stlib=kw.get('stlib',True)
+ get=self.bld.get_tgen_by_name
+ try:
+ y=get(name)
+ except Errors.WafError:
+ self.uselib.append(name)
+ return
+ y.post()
+ has_link=getattr(y,'link_task',None)
+ is_static=has_link and isinstance(y.link_task,stlink_task)
+ if getattr(self,'link_task',None):
+ if has_link:
+ if(not is_static)or(is_static and stlib):
+ var=isinstance(y.link_task,stlink_task)and'STLIB'or'LIB'
+ self.env.append_value(var,[y.target[y.target.rfind(os.sep)+1:]])
+ self.link_task.set_run_after(y.link_task)
+ self.link_task.dep_nodes.extend(y.link_task.outputs)
+ tmp_path=y.link_task.outputs[0].parent.path_from(self.bld.bldnode)
+ if not tmp_path in self.env[var+'PATH']:
+ self.env.prepend_value(var+'PATH',[tmp_path])
+ elif objects:
+ for t in getattr(y,'compiled_tasks',[]):
+ self.link_task.inputs.extend(t.outputs)
+ for x in self.to_list(getattr(y,'use',[])):
+ self.use_rec(x,objects=objects and not has_link,stlib=stlib and(is_static or not has_link))
+ for v in self.to_list(getattr(y,'uselib',[])):
+ if not self.env['STLIB_'+v]:
+ if not v in self.uselib:
+ self.uselib.insert(0,v)
+ if getattr(y,'export_includes',None):
+ self.includes.extend(y.to_incnodes(y.export_includes))
+def process_use(self):
+ self.uselib=self.to_list(getattr(self,'uselib',[]))
+ self.includes=self.to_list(getattr(self,'includes',[]))
+ names=self.to_list(getattr(self,'use',[]))
+ self.seen_libs=set([])
+ for x in names:
+ self.use_rec(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)
+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
+
+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(get_uselib_vars)
+feature('c','cxx','d','fc','javac','cs','uselib')(propagate_uselib_vars)
+after_method('process_use')(propagate_uselib_vars)
+feature('cshlib','cxxshlib')(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)
\ No newline at end of file
diff --git a/waflib/Tools/compiler_c.py b/waflib/Tools/compiler_c.py
new file mode 100644
index 0000000..84a5dd6
--- /dev/null
+++ b/waflib/Tools/compiler_c.py
@@ -0,0 +1,39 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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(True)
+ 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 --git a/waflib/Tools/compiler_cxx.py b/waflib/Tools/compiler_cxx.py
new file mode 100644
index 0000000..67ff5fe
--- /dev/null
+++ b/waflib/Tools/compiler_cxx.py
@@ -0,0 +1,39 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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(True)
+ 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 --git a/waflib/Tools/compiler_d.py b/waflib/Tools/compiler_d.py
new file mode 100644
index 0000000..b781d8a
--- /dev/null
+++ b/waflib/Tools/compiler_d.py
@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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(True)
+ 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 --git a/waflib/Tools/compiler_fc.py b/waflib/Tools/compiler_fc.py
new file mode 100644
index 0000000..579a054
--- /dev/null
+++ b/waflib/Tools/compiler_fc.py
@@ -0,0 +1,45 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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(True)
+ 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 --git a/waflib/Tools/cs.py b/waflib/Tools/cs.py
new file mode 100644
index 0000000..0d3581c
--- /dev/null
+++ b/waflib/Tools/cs.py
@@ -0,0 +1,98 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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','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 --git a/waflib/Tools/cxx.py b/waflib/Tools/cxx.py
new file mode 100644
index 0000000..fa0b9f5
--- /dev/null
+++ b/waflib/Tools/cxx.py
@@ -0,0 +1,26 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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} ${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} ${LINKFLAGS}'
+ ext_out=['.bin']
+ inst_to='${BINDIR}'
+ chmod=Utils.O755
+class cxxshlib(cxxprogram):
+ inst_to='${LIBDIR}'
+class cxxstlib(stlink_task):
+ pass
diff --git a/waflib/Tools/d.py b/waflib/Tools/d.py
new file mode 100644
index 0000000..5d5680b
--- /dev/null
+++ b/waflib/Tools/d.py
@@ -0,0 +1,51 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+from waflib import Utils,Task,Errors
+from waflib.TaskGen import taskgen_method,feature,after_method,before_method,extension
+from waflib.Configure import conf
+from waflib.Tools.ccroot import link_task
+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} ${DLNK_SRC_F}${SRC} ${DLNK_TGT_F:TGT} ${RPATH_ST:RPATH} ${DSTLIB_MARKER} ${DSTLIBPATH_ST:STLIBPATH} ${DSTLIB_ST:STLIB} ${DSHLIB_MARKER} ${LIBPATH_ST:LIBPATH} ${DSHLIB_ST:LIB} ${LINKFLAGS}'
+ 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 --git a/waflib/Tools/d_config.py b/waflib/Tools/d_config.py
new file mode 100644
index 0000000..5905301
--- /dev/null
+++ b/waflib/Tools/d_config.py
@@ -0,0 +1,47 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/d_scan.py b/waflib/Tools/d_scan.py
new file mode 100644
index 0000000..d051c5b
--- /dev/null
+++ b/waflib/Tools/d_scan.py
@@ -0,0 +1,133 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import re
+from waflib import Utils,Logs
+def filter_comments(filename):
+ txt=Utils.readf(filename)
+ i=0
+ buf=[]
+ max=len(txt)
+ begin=0
+ while i<max:
+ c=txt[i]
+ if c=='"'or c=="'":
+ buf.append(txt[begin:i])
+ delim=c
+ i+=1
+ while i<max:
+ c=txt[i]
+ if c==delim:break
+ elif c=='\\':
+ i+=1
+ i+=1
+ i+=1
+ begin=i
+ elif c=='/':
+ buf.append(txt[begin:i])
+ i+=1
+ if i==max:break
+ c=txt[i]
+ if c=='+':
+ i+=1
+ nesting=1
+ c=None
+ while i<max:
+ prev=c
+ c=txt[i]
+ if prev=='/'and c=='+':
+ nesting+=1
+ c=None
+ elif prev=='+'and c=='/':
+ nesting-=1
+ if nesting==0:break
+ c=None
+ i+=1
+ elif c=='*':
+ i+=1
+ c=None
+ while i<max:
+ prev=c
+ c=txt[i]
+ if prev=='*'and c=='/':break
+ i+=1
+ elif c=='/':
+ i+=1
+ while i<max and txt[i]!='\n':
+ i+=1
+ else:
+ begin=i-1
+ continue
+ i+=1
+ begin=i
+ buf.append(' ')
+ else:
+ i+=1
+ buf.append(txt[begin:])
+ return buf
+class d_parser(object):
+ def __init__(self,env,incpaths):
+ self.allnames=[]
+ self.re_module=re.compile("module\s+([^;]+)")
+ self.re_import=re.compile("import\s+([^;]+)")
+ self.re_import_bindings=re.compile("([^:]+):(.*)")
+ self.re_import_alias=re.compile("[^=]+=(.+)")
+ self.env=env
+ self.nodes=[]
+ self.names=[]
+ self.incpaths=incpaths
+ def tryfind(self,filename):
+ found=0
+ for n in self.incpaths:
+ found=n.find_resource(filename.replace('.','/')+'.d')
+ if found:
+ self.nodes.append(found)
+ self.waiting.append(found)
+ break
+ if not found:
+ if not filename in self.names:
+ self.names.append(filename)
+ def get_strings(self,code):
+ self.module=''
+ lst=[]
+ mod_name=self.re_module.search(code)
+ if mod_name:
+ self.module=re.sub('\s+','',mod_name.group(1))
+ import_iterator=self.re_import.finditer(code)
+ if import_iterator:
+ for import_match in import_iterator:
+ import_match_str=re.sub('\s+','',import_match.group(1))
+ bindings_match=self.re_import_bindings.match(import_match_str)
+ if bindings_match:
+ import_match_str=bindings_match.group(1)
+ matches=import_match_str.split(',')
+ for match in matches:
+ alias_match=self.re_import_alias.match(match)
+ if alias_match:
+ match=alias_match.group(1)
+ lst.append(match)
+ return lst
+ 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()
+ code="".join(filter_comments(path))
+ names=self.get_strings(code)
+ for x in names:
+ if x in self.allnames:continue
+ self.allnames.append(x)
+ self.tryfind(x)
+def scan(self):
+ env=self.env
+ gruik=d_parser(env,self.generator.includes_nodes)
+ node=self.inputs[0]
+ gruik.start(node)
+ nodes=gruik.nodes
+ names=gruik.names
+ if Logs.verbose:
+ Logs.debug('deps: deps for %s: %r; unresolved %r'%(str(node),nodes,names))
+ return(nodes,names)
diff --git a/waflib/Tools/dbus.py b/waflib/Tools/dbus.py
new file mode 100644
index 0000000..05e7490
--- /dev/null
+++ b/waflib/Tools/dbus.py
@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/dmd.py b/waflib/Tools/dmd.py
new file mode 100644
index 0000000..f9113a5
--- /dev/null
+++ b/waflib/Tools/dmd.py
@@ -0,0 +1,43 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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']=['-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()
+ 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 --git a/waflib/Tools/errcheck.py b/waflib/Tools/errcheck.py
new file mode 100644
index 0000000..cac1edd
--- /dev/null
+++ b/waflib/Tools/errcheck.py
@@ -0,0 +1,131 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+typos={'feature':'features','sources':'source','targets':'target','include':'includes','export_include':'export_includes','define':'defines','importpath':'includes','installpath':'install_path',}
+meths_typos=['__call__','program','shlib','stlib','objects']
+from waflib import Logs,Build,Node,Task,TaskGen,ConfigSet,Errors,Utils
+import waflib.Tools.ccroot
+def check_same_targets(self):
+ mp=Utils.defaultdict(list)
+ uids={}
+ def check_task(tsk):
+ if not isinstance(tsk,Task.Task):
+ return
+ for node in tsk.outputs:
+ mp[node].append(tsk)
+ try:
+ uids[tsk.uid()].append(tsk)
+ except:
+ uids[tsk.uid()]=[tsk]
+ for g in self.groups:
+ for tg in g:
+ try:
+ for tsk in tg.tasks:
+ check_task(tsk)
+ except AttributeError:
+ check_task(tg)
+ dupe=False
+ for(k,v)in mp.items():
+ if len(v)>1:
+ dupe=True
+ Logs.error('* Node %r is created by more than one task. The task generators are:'%k)
+ for x in v:
+ Logs.error(' %d. %r'%(1+v.index(x),x.generator))
+ 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/svn/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__))
+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)
+ old_ant_glob=Node.Node.ant_glob
+ 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])
+ return old_ant_glob(self,*k,**kw)
+ 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)
+ old_compile=Build.BuildContext.compile
+ def check_compile(self):
+ check_invalid_constraints(self)
+ try:
+ ret=old_compile(self)
+ finally:
+ check_same_targets(self)
+ return ret
+ Build.BuildContext.compile=check_compile
+ 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 --git a/waflib/Tools/fc.py b/waflib/Tools/fc.py
new file mode 100644
index 0000000..9efdd2c
--- /dev/null
+++ b/waflib/Tools/fc.py
@@ -0,0 +1,123 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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} ${FCLNK_SRC_F}${SRC} ${FCLNK_TGT_F}${TGT} ${FCSTLIB_MARKER} ${FCSTLIBPATH_ST:STLIBPATH} ${FCSTLIB_ST:STLIB} ${FCSHLIB_MARKER} ${FCLIBPATH_ST:LIBPATH} ${FCLIB_ST:LIB} ${LINKFLAGS}'
+ 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 --git a/waflib/Tools/fc_config.py b/waflib/Tools/fc_config.py
new file mode 100644
index 0000000..9d7b586
--- /dev/null
+++ b/waflib/Tools/fc_config.py
@@ -0,0 +1,273 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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']='%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):
+ if sys.platform=='win32':
+ raise NotImplementedError("FIXME: not implemented on win32")
+ 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
+ if not isinstance(stderr,str):
+ stderr=stderr
+ 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']
+
+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)
\ No newline at end of file
diff --git a/waflib/Tools/fc_scan.py b/waflib/Tools/fc_scan.py
new file mode 100644
index 0000000..898d29e
--- /dev/null
+++ b/waflib/Tools/fc_scan.py
@@ -0,0 +1,68 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/flex.py b/waflib/Tools/flex.py
new file mode 100644
index 0000000..e651bc2
--- /dev/null
+++ b/waflib/Tools/flex.py
@@ -0,0 +1,27 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/g95.py b/waflib/Tools/g95.py
new file mode 100644
index 0000000..2ce7a88
--- /dev/null
+++ b/waflib/Tools/g95.py
@@ -0,0 +1,55 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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<major>\d*)\.(?P<minor>\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 --git a/waflib/Tools/gas.py b/waflib/Tools/gas.py
new file mode 100644
index 0000000..5e64de2
--- /dev/null
+++ b/waflib/Tools/gas.py
@@ -0,0 +1,10 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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.find_ar()
diff --git a/waflib/Tools/gcc.py b/waflib/Tools/gcc.py
new file mode 100644
index 0000000..be82b8c
--- /dev/null
+++ b/waflib/Tools/gcc.py
@@ -0,0 +1,98 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/gdc.py b/waflib/Tools/gdc.py
new file mode 100644
index 0000000..0f9e5d6
--- /dev/null
+++ b/waflib/Tools/gdc.py
@@ -0,0 +1,34 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/gfortran.py b/waflib/Tools/gfortran.py
new file mode 100644
index 0000000..4a9b39e
--- /dev/null
+++ b/waflib/Tools/gfortran.py
@@ -0,0 +1,69 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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',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 --git a/waflib/Tools/glib2.py b/waflib/Tools/glib2.py
new file mode 100644
index 0000000..81c3e91
--- /dev/null
+++ b/waflib/Tools/glib2.py
@@ -0,0 +1,174 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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(target)
+ options='--comments "<!-- @comment@ -->" --fhead "<schemalist>" --vhead " <@type@ id=\\"%s. at EnumName@\\">" --vprod " <value nick=\\"@valuenick@\\" value=\\"@valuenum@\\"/>" --vtail " </@type@>" --ftail "</schemalist>" '%(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')
+ install_files.append(schema)
+ schema_node=self.path.find_resource(schema)
+ if not schema_node:
+ raise Errors.WafError("Cannot find the schema file '%s'"%schema)
+ 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 --git a/waflib/Tools/gnu_dirs.py b/waflib/Tools/gnu_dirs.py
new file mode 100644
index 0000000..d00a8e7
--- /dev/null
+++ b/waflib/Tools/gnu_dirs.py
@@ -0,0 +1,64 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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<len(_options)+1:
+ iter+=1
+ complete=True
+ for name,help,default in _options:
+ name=name.upper()
+ if not env[name]:
+ try:
+ env[name]=Utils.subst_vars(get_param(name,default),env)
+ except TypeError:
+ complete=False
+ if not complete:
+ lst=[name for name,_,_ in _options if not env[name.upper()]]
+ raise Errors.WafError('Variable substitution failure %r'%lst)
+def options(opt):
+ inst_dir=opt.add_option_group('Installation directories','By default, "waf install" will put the files in\
+ "/usr/local/bin", "/usr/local/lib" etc. An installation prefix other\
+ than "/usr/local" can be given using "--prefix", for example "--prefix=$HOME"')
+ for k in('--prefix','--destdir'):
+ option=opt.parser.get_option(k)
+ if option:
+ opt.parser.remove_option(k)
+ inst_dir.add_option(option)
+ inst_dir.add_option('--exec-prefix',help='installation prefix [Default: ${PREFIX}]',default='',dest='EXEC_PREFIX')
+ dirs_options=opt.add_option_group('Pre-defined installation directories','')
+ for name,help,default in _options:
+ option_name='--'+name
+ str_default=default
+ str_help='%s [Default: %s]'%(help,str_default)
+ dirs_options.add_option(option_name,help=str_help,default='',dest=name.upper())
diff --git a/waflib/Tools/gxx.py b/waflib/Tools/gxx.py
new file mode 100644
index 0000000..c1fc64e
--- /dev/null
+++ b/waflib/Tools/gxx.py
@@ -0,0 +1,98 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+from waflib import Configure,Options,Utils
+from waflib.Tools import ccroot,ar
+from waflib.Configure import conf
+def find_gxx(conf):
+ cxx=conf.find_program(['g++','c++'],var='CXX')
+ cxx=conf.cmd_to_list(cxx)
+ conf.get_cc_version(cxx,gcc=True)
+ conf.env.CXX_NAME='gcc'
+ conf.env.CXX=cxx
+def gxx_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']='-Wl,-h,%s'
+ v['SHLIB_MARKER']='-Wl,-Bdynamic'
+ v['STLIB_MARKER']='-Wl,-Bstatic'
+ v['cxxprogram_PATTERN']='%s'
+ v['CXXFLAGS_cxxshlib']=['-fPIC']
+ v['LINKFLAGS_cxxshlib']=['-shared']
+ v['cxxshlib_PATTERN']='lib%s.so'
+ v['LINKFLAGS_cxxstlib']=['-Wl,-Bstatic']
+ v['cxxstlib_PATTERN']='lib%s.a'
+ v['LINKFLAGS_MACBUNDLE']=['-bundle','-undefined','dynamic_lookup']
+ v['CXXFLAGS_MACBUNDLE']=['-fPIC']
+ v['macbundle_PATTERN']='%s.bundle'
+def gxx_modifier_win32(conf):
+ v=conf.env
+ v['cxxprogram_PATTERN']='%s.exe'
+ v['cxxshlib_PATTERN']='%s.dll'
+ v['implib_PATTERN']='lib%s.dll.a'
+ v['IMPLIB_ST']='-Wl,--out-implib,%s'
+ v['CXXFLAGS_cxxshlib']=[]
+ v.append_value('CXXFLAGS_cxxshlib',['-DDLL_EXPORT'])
+ v.append_value('LINKFLAGS',['-Wl,--enable-auto-import'])
+def gxx_modifier_cygwin(conf):
+ gxx_modifier_win32(conf)
+ v=conf.env
+ v['cxxshlib_PATTERN']='cyg%s.dll'
+ v.append_value('LINKFLAGS_cxxshlib',['-Wl,--enable-auto-image-base'])
+ v['CXXFLAGS_cxxshlib']=[]
+def gxx_modifier_darwin(conf):
+ v=conf.env
+ v['CXXFLAGS_cxxshlib']=['-fPIC','-compatibility_version','1','-current_version','1']
+ v['LINKFLAGS_cxxshlib']=['-dynamiclib']
+ v['cxxshlib_PATTERN']='lib%s.dylib'
+ v['FRAMEWORKPATH_ST']='-F%s'
+ v['FRAMEWORK_ST']=['-framework']
+ v['ARCH_ST']=['-arch']
+ v['LINKFLAGS_cxxstlib']=[]
+ v['SHLIB_MARKER']=[]
+ v['STLIB_MARKER']=[]
+ v['SONAME_ST']=[]
+def gxx_modifier_aix(conf):
+ v=conf.env
+ v['LINKFLAGS_cxxprogram']=['-Wl,-brtl']
+ v['LINKFLAGS_cxxshlib']=['-shared','-Wl,-brtl,-bexpfull']
+ v['SHLIB_MARKER']=[]
+def gxx_modifier_hpux(conf):
+ v=conf.env
+ v['SHLIB_MARKER']=[]
+ v['CFLAGS_cxxshlib']=['-fPIC','-DPIC']
+ v['cxxshlib_PATTERN']='lib%s.sl'
+def gxx_modifier_platform(conf):
+ gxx_modifier_func=getattr(conf,'gxx_modifier_'+conf.env.DEST_OS,None)
+ if gxx_modifier_func:
+ gxx_modifier_func()
+def configure(conf):
+ conf.find_gxx()
+ conf.find_ar()
+ conf.gxx_common_flags()
+ conf.gxx_modifier_platform()
+ conf.cxx_load_tools()
+ conf.cxx_add_flags()
+ conf.link_add_flags()
+
+conf(find_gxx)
+conf(gxx_common_flags)
+conf(gxx_modifier_win32)
+conf(gxx_modifier_cygwin)
+conf(gxx_modifier_darwin)
+conf(gxx_modifier_aix)
+conf(gxx_modifier_hpux)
+conf(gxx_modifier_platform)
\ No newline at end of file
diff --git a/waflib/Tools/icc.py b/waflib/Tools/icc.py
new file mode 100644
index 0000000..bee81a1
--- /dev/null
+++ b/waflib/Tools/icc.py
@@ -0,0 +1,31 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+from waflib.Tools import ccroot,ar,gcc
+from waflib.Configure import conf
+def find_icc(conf):
+ if sys.platform=='cygwin':
+ conf.fatal('The Intel compiler does not work on Cygwin')
+ 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('icc',var='CC')
+ if not cc:cc=conf.find_program('ICL',var='CC')
+ if not cc:conf.fatal('Intel C Compiler (icc) was not found')
+ cc=conf.cmd_to_list(cc)
+ conf.get_cc_version(cc,icc=True)
+ v['CC']=cc
+ v['CC_NAME']='icc'
+def configure(conf):
+ conf.find_icc()
+ 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_icc)
\ No newline at end of file
diff --git a/waflib/Tools/icpc.py b/waflib/Tools/icpc.py
new file mode 100644
index 0000000..a917336
--- /dev/null
+++ b/waflib/Tools/icpc.py
@@ -0,0 +1,30 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+from waflib.Tools import ccroot,ar,gxx
+from waflib.Configure import conf
+def find_icpc(conf):
+ if sys.platform=='cygwin':
+ conf.fatal('The Intel compiler does not work on Cygwin')
+ v=conf.env
+ cxx=None
+ if v['CXX']:cxx=v['CXX']
+ elif'CXX'in conf.environ:cxx=conf.environ['CXX']
+ if not cxx:cxx=conf.find_program('icpc',var='CXX')
+ if not cxx:conf.fatal('Intel C++ Compiler (icpc) was not found')
+ cxx=conf.cmd_to_list(cxx)
+ conf.get_cc_version(cxx,icc=True)
+ v['CXX']=cxx
+ v['CXX_NAME']='icc'
+def configure(conf):
+ conf.find_icpc()
+ conf.find_ar()
+ conf.gxx_common_flags()
+ conf.gxx_modifier_platform()
+ conf.cxx_load_tools()
+ conf.cxx_add_flags()
+ conf.link_add_flags()
+
+conf(find_icpc)
\ No newline at end of file
diff --git a/waflib/Tools/ifort.py b/waflib/Tools/ifort.py
new file mode 100644
index 0000000..ec48ba1
--- /dev/null
+++ b/waflib/Tools/ifort.py
@@ -0,0 +1,42 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import re
+from waflib import Utils
+from waflib.Tools import fc,fc_config,fc_scan
+from waflib.Configure import conf
+def find_ifort(conf):
+ fc=conf.find_program('ifort',var='FC')
+ fc=conf.cmd_to_list(fc)
+ conf.get_ifort_version(fc)
+ conf.env.FC_NAME='IFORT'
+def ifort_modifier_cygwin(conf):
+ raise NotImplementedError("Ifort on cygwin not yet implemented")
+def ifort_modifier_platform(conf):
+ dest_os=conf.env['DEST_OS']or Utils.unversioned_sys_platform()
+ ifort_modifier_func=getattr(conf,'ifort_modifier_'+dest_os,None)
+ if ifort_modifier_func:
+ ifort_modifier_func()
+def get_ifort_version(conf,fc):
+ version_re=re.compile(r"ifort\s*\(IFORT\)\s*(?P<major>\d*)\.(?P<minor>\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_platform)
+conf(get_ifort_version)
\ No newline at end of file
diff --git a/waflib/Tools/intltool.py b/waflib/Tools/intltool.py
new file mode 100644
index 0000000..771673a
--- /dev/null
+++ b/waflib/Tools/intltool.py
@@ -0,0 +1,78 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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_ at .]+')
+ 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'))
+ conf.define('DATADIR',datadir)
+ 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 --git a/waflib/Tools/irixcc.py b/waflib/Tools/irixcc.py
new file mode 100644
index 0000000..553cec9
--- /dev/null
+++ b/waflib/Tools/irixcc.py
@@ -0,0 +1,49 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/javaw.py b/waflib/Tools/javaw.py
new file mode 100644
index 0000000..c89baac
--- /dev/null
+++ b/waflib/Tools/javaw.py
@@ -0,0 +1,263 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import os,re
+from waflib.Configure import conf
+from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node
+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='**/*'
+re_verbose=re.compile(r'^\[.*?\]\n*',re.M)
+re_classes=re.compile(r'\[wrote (?:RegularFileObject\[)*(.*?\.class)\]')
+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.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
+ self.last_cmd=lst=[]
+ lst.extend(to_list(env['JAVAC']))
+ lst.extend(['-classpath'])
+ lst.extend(to_list(env['CLASSPATH']))
+ lst.extend(['-d'])
+ lst.extend(to_list(env['OUTDIR']))
+ lst.extend(to_list(env['JAVACFLAGS']))
+ lst.extend([a.path_from(bld.bldnode)for a in self.inputs])
+ lst=[x for x in lst if x]
+ try:
+ self.out=self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None,output=0,quiet=0)[1]
+ except:
+ self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None)
+ def post_run(self):
+ for x in re_classes.findall(self.out):
+ if os.path.isabs(x):
+ n=self.generator.bld.root.find_node(x)
+ else:
+ n=self.generator.bld.bldnode.find_node(x)
+ if not n:
+ raise ValueError('cannot find %r in %r'%(x,self.generator.bld.bldnode.abspath()))
+ n.sig=Utils.h_file(n.abspath())
+ self.generator.bld.task_sigs[self.uid()]=self.cache_sig
+ out=re_verbose.sub('',self.out).strip()
+ if out:
+ self.generator.bld.to_log(out+'\n')
+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']=['-verbose']
+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')
+ 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)')
+ libDirs=[x.parent.abspath()for x in f]or[javaHome]
+ for i,d in enumerate(libDirs):
+ if conf.check(header_name='jni.h',define_name='HAVE_JNI_H',lib='jvm',libpath=d,includes=incDirs,uselib_store='JAVA',uselib='JAVA'):
+ 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 --git a/waflib/Tools/kde4.py b/waflib/Tools/kde4.py
new file mode 100644
index 0000000..220e7d3
--- /dev/null
+++ b/waflib/Tools/kde4.py
@@ -0,0 +1,49 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/lua.py b/waflib/Tools/lua.py
new file mode 100644
index 0000000..7d57bf4
--- /dev/null
+++ b/waflib/Tools/lua.py
@@ -0,0 +1,19 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/msvc.py b/waflib/Tools/msvc.py
new file mode 100644
index 0000000..937f8da
--- /dev/null
+++ b/waflib/Tools/msvc.py
@@ -0,0 +1,608 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 setup_msvc(conf,versions):
+ 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=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.split()
+ 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()
+ 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_msvc_versions(conf,versions):
+ 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 ce_sdk:
+ 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:
+ 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))
+ 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,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]))
+ for(v,version,reg)in detected_versions:
+ try:
+ msvc_version=_winreg.OpenKey(_winreg.HKEY_LOCAL_MACHINE,reg+"\\Setup\\VS")
+ path,type=_winreg.QueryValueEx(msvc_version,'ProductDir')
+ path=str(path)
+ targets=[]
+ if ce_sdk:
+ for device,platforms in supported_wince_platforms:
+ cetargets=[]
+ for platform,compiler,include,lib in platforms:
+ winCEpath=os.path.join(path,'VC','ce')
+ if os.path.isdir(winCEpath):
+ try:
+ common_bindirs,_1,_2=conf.get_msvc_version('msvc',version,'x86',os.path.join(path,'Common7','Tools','vsvars32.bat'))
+ except conf.errors.ConfigurationError:
+ pass
+ else:
+ 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=[include,os.path.join(winCEpath,'include'),os.path.join(winCEpath,'atlmfc','include')]
+ libdirs=[lib,os.path.join(winCEpath,'lib',platform),os.path.join(winCEpath,'atlmfc','lib',platform)]
+ cetargets.append((platform,(platform,(bindirs,incdirs,libdirs))))
+ versions.append((device+' '+version,cetargets))
+ if os.path.isfile(os.path.join(path,'VC','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(path,'VC','vcvarsall.bat')))))
+ except conf.errors.ConfigurationError:
+ pass
+ elif os.path.isfile(os.path.join(path,'Common7','Tools','vsvars32.bat')):
+ try:
+ targets.append(('x86',('x86',conf.get_msvc_version('msvc',version,'x86',os.path.join(path,'Common7','Tools','vsvars32.bat')))))
+ except conf.errors.ConfigurationError:
+ pass
+ versions.append(('msvc '+version,targets))
+ except WindowsError:
+ continue
+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 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()
+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=detect_msvc(conf)
+ v['PATH']=path
+ v['INCLUDES']=includes
+ v['LIBPATH']=libdirs
+ v['MSVC_COMPILER']=compiler
+ v['CC_VERSION']=(str(version),'0','0')
+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
+ compiler,version,path,includes,libdirs=detect_msvc(conf)
+ v['PATH']=path
+ v['INCLUDES']=includes
+ v['LIBPATH']=libdirs
+ v['MSVC_VERSION']=float(version)
+ compiler_name,linker_name,lib_name=_get_prog_names(conf,compiler)
+ v.MSVC_MANIFEST=(compiler=='msvc'and float(version)>=8)or(compiler=='wsdk'and float(version)>=6)or(compiler=='intel'and float(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)
+ 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'
+ try:v.prepend_value('INCLUDES',conf.environ['INCLUDE'])
+ except KeyError:pass
+ try:v.prepend_value('LIBPATH',conf.environ['LIB'])
+ except KeyError:pass
+ 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 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,' '.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]
+ 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 winrc 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_versions)
+conf(gather_icl_versions)
+conf(get_msvc_versions)
+conf(print_all_msvc_detected)
+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(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 --git a/waflib/Tools/nasm.py b/waflib/Tools/nasm.py
new file mode 100644
index 0000000..e4b0acc
--- /dev/null
+++ b/waflib/Tools/nasm.py
@@ -0,0 +1,13 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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'
+
+feature('asm')(apply_nasm_vars)
\ No newline at end of file
diff --git a/waflib/Tools/perl.py b/waflib/Tools/perl.py
new file mode 100644
index 0000000..6ca7be5
--- /dev/null
+++ b/waflib/Tools/perl.py
@@ -0,0 +1,79 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 not getattr(Options.options,'perlbinary',None):
+ perl=self.find_program('perl',var='PERL')
+ if not perl:
+ return False
+ else:
+ self.env['PERL']=perl=Options.options.perlbinary
+ 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<minver:
+ res=False
+ if minver is None:
+ cver=""
+ else:
+ cver=".".join(map(str,minver))
+ self.msg('Checking for perl version',cver)
+ return res
+def check_perl_module(self,module):
+ cmd=[self.env['PERL'],'-e','use %s'%module]
+ self.start_msg('perl module %s'%module)
+ try:
+ r=self.cmd_and_log(cmd)
+ except:
+ self.end_msg(False)
+ return None
+ self.end_msg(r or True)
+ return r
+def check_perl_ext_devel(self):
+ env=self.env
+ perl=env.PERL
+ if not perl:
+ self.fatal('find perl first')
+ def read_out(cmd):
+ return Utils.to_list(self.cmd_and_log(perl+cmd))
+ env['LINKFLAGS_PERLEXT']=read_out(" -MConfig -e'print $Config{lddlflags}'")
+ env['INCLUDES_PERLEXT']=read_out(" -MConfig -e'print \"$Config{archlib}/CORE\"'")
+ env['CFLAGS_PERLEXT']=read_out(" -MConfig -e'print \"$Config{ccflags} $Config{cccdlflags}\"'")
+ env['XSUBPP']=read_out(" -MConfig -e'print \"$Config{privlib}/ExtUtils/xsubpp$Config{exe_ext}\"'")
+ env['EXTUTILS_TYPEMAP']=read_out(" -MConfig -e'print \"$Config{privlib}/ExtUtils/typemap\"'")
+ if not getattr(Options.options,'perlarchdir',None):
+ env['ARCHDIR_PERL']=self.cmd_and_log(perl+" -MConfig -e'print $Config{sitearch}'")
+ else:
+ env['ARCHDIR_PERL']=getattr(Options.options,'perlarchdir')
+ env['perlext_PATTERN']='%s.'+self.cmd_and_log(perl+" -MConfig -e'print $Config{dlext}'")
+def options(opt):
+ opt.add_option('--with-perl-binary',type='string',dest='perlbinary',help='Specify alternate perl binary',default=None)
+ opt.add_option('--with-perl-archdir',type='string',dest='perlarchdir',help='Specify directory where to install arch specific files',default=None)
+
+before_method('apply_incpaths','apply_link','propagate_uselib_vars')(init_perlext)
+feature('perlext')(init_perlext)
+extension('.xs')(xsubpp_file)
+conf(check_perl_version)
+conf(check_perl_module)
+conf(check_perl_ext_devel)
\ No newline at end of file
diff --git a/waflib/Tools/python.py b/waflib/Tools/python.py
new file mode 100644
index 0000000..9a5b96b
--- /dev/null
+++ b/waflib/Tools/python.py
@@ -0,0 +1,282 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+from waflib import TaskGen,Utils,Utils,Runner,Options,Build,Errors
+from waflib.Logs import debug,warn,info,error
+from waflib.TaskGen import extension,taskgen_method,before_method,after_method,feature
+from waflib.Configure import conf
+FRAG='''
+#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
+for pyfile in sys.argv[1:]:
+ py_compile.compile(pyfile, pyfile + %r)
+'''
+def process_py(self,node):
+ try:
+ if not self.bld.is_install:
+ return
+ except:
+ return
+ if not getattr(self,'install_path',None):
+ 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[]
+ argv=self.env['PYTHON']+lst+['-c',INST%x,path]
+ 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):
+ if not getattr(self,'install_path',None):
+ 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['pyext_PATTERN']
+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(conf,variables,imports=['import sys']):
+ 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=conf.cmd_and_log(conf.env.PYTHON+['-c','\n'.join(program)],env=os_env)
+ except Errors.WafError:
+ conf.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],['from distutils.sysconfig import get_config_var'])
+ 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['LDSHARED']+' '+dct['CFLAGS']
+ conf.parse_flags(all_flags,'PYEMBED')
+ 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(sys.platform=='win32'or sys.platform.startswith('os2')or sys.platform=='darwin'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+[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'])
+ 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 sys.platform=='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']],['from distutils.sysconfig import get_config_var, get_python_lib'])
+ else:
+ python_LIBDEST=None
+ (pydir,)=conf.get_python_variables(["get_python_lib(standard_lib=0, prefix=%r) or ''"%conf.env['PREFIX']],['from distutils.sysconfig import get_python_lib'])
+ 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']],['from distutils.sysconfig import get_python_lib'])
+ 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)
+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 --git a/waflib/Tools/qt4.py b/waflib/Tools/qt4.py
new file mode 100644
index 0000000..18982fd
--- /dev/null
+++ b/waflib/Tools/qt4.py
@@ -0,0 +1,348 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 TaskGen,Task,Utils,Runner,Options,Node,Errors
+from waflib.TaskGen import feature,after_method,extension
+from waflib.Logs import error
+MOC_H=['.h','.hpp','.hxx','.hh']
+EXT_RCC=['.qrc']
+EXT_UI=['.ui']
+EXT_QT4=['.cpp','.cc','.cxx','.C']
+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:
+ 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]
+ 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']:
+ 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]
+ 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} ${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(['<file>%s</file>'%k.path_from(self.outputs[0].parent)for k in self.inputs])
+ code='<!DOCTYPE RCC><RCC version="1.0">\n<qresource>\n%s\n</qresource>\n</RCC>'%txt
+ self.outputs[0].write(code)
+def configure(self):
+ env=self.env
+ opt=Options.options
+ qtdir=getattr(opt,'qtdir','')
+ qtbin=getattr(opt,'qtbin','')
+ qtlibs=getattr(opt,'qtlibs','')
+ useframework=getattr(opt,'use_qt4_osxframework',True)
+ 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:
+ qmake=cand
+ else:
+ self.fatal('could not find qmake for qt4')
+ self.env.QMAKE=qmake
+ qtincludes=self.cmd_and_log([qmake,'-query','QT_INSTALL_HEADERS']).strip()
+ qtdir=self.cmd_and_log([qmake,'-query','QT_INSTALL_PREFIX']).strip()+os.sep
+ qtbin=self.cmd_and_log([qmake,'-query','QT_INSTALL_BINS']).strip()+os.sep
+ if not qtlibs:
+ try:
+ qtlibs=self.cmd_and_log([qmake,'-query','QT_INSTALL_LIBS']).strip()
+ except Errors.WafError:
+ qtlibs=os.path.join(qtdir,'lib')
+ 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:
+ version=self.cmd_and_log(env['QT_UIC']+" -version 2>&1").strip()
+ except self.errors.ConfigurationError:
+ self.fatal('your uic compiler is for qt3, add uic for qt4 to your path')
+ version=version.replace('Qt User Interface Compiler ','')
+ version=version.replace('User Interface Compiler for Qt','')
+ if version.find(' 3.')!=-1:
+ self.msg('Checking for uic version','(%s: too old)'%version,False)
+ self.fatal('uic is too old')
+ self.msg('Checking for uic version','(%s)'%version)
+ 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']
+ vars="QtCore QtGui QtUiTools QtNetwork QtOpenGL QtSql QtSvg QtTest QtXml QtWebKit Qt3Support".split()
+ vars_debug=[a+'_debug'for a in vars]
+ 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)
+ for i in vars_debug+vars:
+ try:
+ self.check_cfg(package=i,args='--cflags --libs')
+ except self.errors.ConfigurationError:
+ pass
+ 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(vars,'LIBPATH_QTCORE')
+ process_lib(vars_debug,'LIBPATH_QTCORE_DEBUG')
+ 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(vars,'LIBPATH_QTCORE')
+ process_rpath(vars_debug,'LIBPATH_QTCORE_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)
+ if sys.platform=="darwin":
+ opt.add_option('--no-qt4-framework',action="store_false",help='do not use the framework version of Qt4 in OS X',dest='use_qt4_osxframework',default=True)
+ 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)
\ No newline at end of file
diff --git a/waflib/Tools/ruby.py b/waflib/Tools/ruby.py
new file mode 100644
index 0000000..f0fe381
--- /dev/null
+++ b/waflib/Tools/ruby.py
@@ -0,0 +1,88 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os
+from waflib import Task,Options,Utils
+from waflib.TaskGen import before_method,feature,after_method
+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<minver:
+ self.fatal('ruby is too old %r'%ver)
+ cver='.'.join([str(x)for x in minver])
+ self.msg('ruby',cver)
+def check_ruby_ext_devel(self):
+ if not self.env.RUBY:
+ self.fatal('ruby detection is required first')
+ if not self.env.CC_NAME and not self.env.CXX_NAME:
+ self.fatal('load a c/c++ compiler first')
+ version=tuple(map(int,self.env.RUBY_VERSION.split(".")))
+ def read_out(cmd):
+ return Utils.to_list(self.cmd_and_log([self.env.RUBY,'-rrbconfig','-e',cmd]))
+ def read_config(key):
+ return read_out('puts Config::CONFIG[%r]'%key)
+ ruby=self.env['RUBY']
+ archdir=read_config('archdir')
+ cpppath=archdir
+ if version>=(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 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)
\ No newline at end of file
diff --git a/waflib/Tools/suncc.py b/waflib/Tools/suncc.py
new file mode 100644
index 0000000..044789e
--- /dev/null
+++ b/waflib/Tools/suncc.py
@@ -0,0 +1,54 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/suncxx.py b/waflib/Tools/suncxx.py
new file mode 100644
index 0000000..104f732
--- /dev/null
+++ b/waflib/Tools/suncxx.py
@@ -0,0 +1,55 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waflib/Tools/tex.py b/waflib/Tools/tex.py
new file mode 100644
index 0000000..4210a56
--- /dev/null
+++ b/waflib/Tools/tex.py
@@ -0,0 +1,221 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,re
+from waflib import Utils,Task,Runner,Build,Errors
+from waflib.TaskGen import feature,before_method
+from waflib.Logs import error,warn,debug
+re_bibunit=re.compile(r'\\(?P<type>putbib)\[(?P<file>[^\[\]]*)\]',re.M)
+def bibunitscan(self):
+ node=self.inputs[0]
+ env=self.env
+ 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']
+re_tex=re.compile(r'\\(?P<type>include|bibliography|putbib|includegraphics|input|import|bringin|lstinputlisting)(\[[^\[\]]*\])?{(?P<file>[^{}]*)}',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(self):
+ node=self.inputs[0]
+ env=self.env
+ 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):
+ path=match.group('file')
+ 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:
+ nodes.append(found)
+ add_name=False
+ if found.name.endswith('.tex')or found.name.endswith('.ltx'):
+ parse_node(found)
+ 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):
+ try:
+ ct=self.aux_node.read()
+ except(OSError,IOError):
+ error('error bibtex scan')
+ else:
+ fo=g_bibtex_re.findall(ct)
+ if fo:
+ 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_node.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
+ bld=self.generator.bld
+ 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()
+ self.TEXINPUTS=node.parent.get_bld().abspath()+os.pathsep+node.parent.get_src().abspath()+os.pathsep
+ self.aux_node=node.change_ext('.aux')
+ self.idx_node=node.change_ext('.idx')
+ 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.bibfile()
+ self.bibunits()
+ self.makeindex()
+ hash=''
+ for i in range(10):
+ prev_hash=hash
+ try:
+ hash=Utils.h_file(self.aux_node.abspath())
+ except(OSError,IOError):
+ error('could not read aux.h -> %s'%self.aux_node.abspath())
+ 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 --git a/waflib/Tools/vala.py b/waflib/Tools/vala.py
new file mode 100644
index 0000000..858eaa7
--- /dev/null
+++ b/waflib/Tools/vala.py
@@ -0,0 +1,216 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os.path,shutil,re
+from waflib import Context,Task,Runner,Utils,Logs,Build,Node,Options,Errors
+from waflib.TaskGen import extension,after_method,before_method
+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:
+ output_dir=self.outputs[0].bld_dir()
+ 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=getattr(Context.g_module,'API_VERSION',None)
+ if api_version==None:
+ version=Context.g_module.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.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:
+ 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<min_version:
+ self.fatal("%s version %r is too old, need >= %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 --git a/waflib/Tools/waf_unit_test.py b/waflib/Tools/waf_unit_test.py
new file mode 100644
index 0000000..3ad9ccd
--- /dev/null
+++ b/waflib/Tools/waf_unit_test.py
@@ -0,0 +1,80 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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):
+ status=0
+ 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 sys.platform=='win32':
+ add_path(fu,lst,'PATH')
+ elif 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 --git a/waflib/Tools/winres.py b/waflib/Tools/winres.py
new file mode 100644
index 0000000..1d9eb40
--- /dev/null
+++ b/waflib/Tools/winres.py
@@ -0,0 +1,35 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys,re
+from waflib import TaskGen,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':
+ winrc=conf.find_program('RC',var='WINRC',path_list=v['PATH'])
+ v['WINRC_TGT_F']='/fo'
+ v['WINRC_SRC_F']=''
+ else:
+ winrc=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 --git a/waflib/Tools/xlc.py b/waflib/Tools/xlc.py
new file mode 100644
index 0000000..c942a82
--- /dev/null
+++ b/waflib/Tools/xlc.py
@@ -0,0 +1,46 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+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.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 --git a/waflib/Tools/xlcxx.py b/waflib/Tools/xlcxx.py
new file mode 100644
index 0000000..01ab961
--- /dev/null
+++ b/waflib/Tools/xlcxx.py
@@ -0,0 +1,46 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,sys
+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.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 --git a/waflib/Utils.py b/waflib/Utils.py
new file mode 100644
index 0000000..fb54f77
--- /dev/null
+++ b/waflib/Utils.py
@@ -0,0 +1,328 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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=='win32'
+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()
+ while(filename):
+ filename=f.read(100000)
+ m.update(filename)
+ 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:
+ from ctypes import windll,byref,create_string_buffer
+ def listdir_win32(s):
+ if not s:
+ dlen=4
+ maxdrives=26
+ buf=create_string_buffer(maxdrives*dlen)
+ ndrives=windll.kernel32.GetLogicalDriveStringsA(maxdrives,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<len(ver):
+ ret+=256**(3-i)*int(ver[i])
+ return ret
+ return ver
+def ex_stack():
+ exc_type,exc_value,tb=sys.exc_info()
+ exc_lines=traceback.format_exception(exc_type,exc_value,tb)
+ return''.join(exc_lines)
+def to_list(sth):
+ if isinstance(sth,str):
+ return sth.split()
+ else:
+ return sth
+re_nl=re.compile('\r*\n',re.M)
+def str_to_dict(txt):
+ tbl={}
+ lines=re_nl.split(txt)
+ for x in lines:
+ x=x.strip()
+ if not x or x.startswith('#')or x.find('=')<0:
+ continue
+ tmp=x.split('=')
+ tbl[tmp[0].strip()]='='.join(tmp[1:]).strip()
+ return tbl
+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 is_win32:
+ split_path=split_path_win32
+split_path.__doc__="""
+Split a path by / or \\. This function is not like os.path.split
+
+:type path: string
+:param path: path to split
+:return: list of strings
+"""
+def check_dir(path):
+ if not os.path.isdir(path):
+ try:
+ os.makedirs(path)
+ except OSError ,e:
+ if not os.path.isdir(path):
+ raise Errors.WafError('Cannot create the folder %r'%path,ex=e)
+def def_attrs(cls,**kw):
+ for k,v in kw.items():
+ if not hasattr(cls,k):
+ setattr(cls,k,v)
+def quote_define_name(s):
+ fu=re.compile("[^a-zA-Z0-9]").sub("_",s)
+ fu=fu.upper()
+ return fu
+def h_list(lst):
+ m=md5()
+ m.update(str(lst))
+ return m.digest()
+def h_fun(fun):
+ try:
+ return fun.code
+ except AttributeError:
+ try:
+ h=inspect.getsource(fun)
+ except IOError:
+ h="nocode"
+ try:
+ fun.code=h
+ except AttributeError:
+ pass
+ return h
+reg_subst=re.compile(r"(\\\\)|(\$\$)|\$\{([^}]+)\}")
+def subst_vars(expr,params):
+ def repl_var(m):
+ if m.group(1):
+ return'\\'
+ if m.group(2):
+ return'$'
+ try:
+ return params.get_flat(m.group(3))
+ except AttributeError:
+ return params[m.group(3)]
+ return reg_subst.sub(repl_var,expr)
+def destos_to_binfmt(key):
+ if key=='darwin':
+ return'mac-o'
+ elif key in('win32','cygwin','uwin','msys'):
+ return'pe'
+ return'elf'
+def unversioned_sys_platform():
+ s=sys.platform
+ if s=='java':
+ from java.lang import System
+ s=System.getProperty('os.name')
+ if s=='Mac OS X':
+ return'darwin'
+ elif s.startswith('Windows '):
+ return'win32'
+ elif s=='OS/2':
+ return'os2'
+ elif s=='HP-UX':
+ return'hpux'
+ elif s in('SunOS','Solaris'):
+ return'sunos'
+ else:s=s.lower()
+ if s=='win32'or s.endswith('os2')and s!='sunos2':return s
+ return re.split('\d+$',s)[0]
+def nada(*k,**kw):
+ pass
+class Timer(object):
+ def __init__(self):
+ self.start_time=datetime.datetime.utcnow()
+ def __str__(self):
+ delta=datetime.datetime.utcnow()-self.start_time
+ days=int(delta.days)
+ hours=delta.seconds//3600
+ minutes=(delta.seconds-hours*3600)//60
+ seconds=delta.seconds-hours*3600-minutes*60+float(delta.microseconds)/1000/1000
+ result=''
+ if days:
+ result+='%dd'%days
+ if days or hours:
+ result+='%dh'%hours
+ if days or hours or minutes:
+ result+='%dm'%minutes
+ return'%s%.3fs'%(result,seconds)
+if is_win32:
+ old=shutil.copy2
+ def copy2(src,dst):
+ old(src,dst)
+ shutil.copystat(src,src)
+ setattr(shutil,'copy2',copy2)
+if os.name=='java':
+ try:
+ gc.disable()
+ gc.enable()
+ except NotImplementedError:
+ gc.disable=gc.enable
+def read_la_file(path):
+ sp=re.compile(r'^([^=]+)=\'(.*)\'$')
+ dc={}
+ for line in readf(path).splitlines():
+ try:
+ _,left,right,_=sp.split(line.strip())
+ dc[left]=right
+ except ValueError:
+ pass
+ return dc
+def nogc(fun):
+ def f(*k,**kw):
+ try:
+ gc.disable()
+ ret=fun(*k,**kw)
+ finally:
+ gc.enable()
+ return ret
+ f.__doc__=fun.__doc__
+ return f
+def run_once(fun):
+ cache={}
+ def wrap(k):
+ try:
+ return cache[k]
+ except KeyError:
+ ret=fun(k)
+ cache[k]=ret
+ return ret
+ wrap.__cache__=cache
+ return wrap
+def get_registry_app_path(key,filename):
+ if not winreg:
+ return None
+ try:
+ result=winreg.QueryValue(key,"Software\\Microsoft\\Windows\\CurrentVersion\\App Paths\\%s.exe"%filename[0])
+ except WindowsError:
+ pass
+ else:
+ if os.path.isfile(result):
+ return result
diff --git a/waflib/__init__.py b/waflib/__init__.py
new file mode 100644
index 0000000..95a3b6a
--- /dev/null
+++ b/waflib/__init__.py
@@ -0,0 +1,4 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
diff --git a/waflib/ansiterm.py b/waflib/ansiterm.py
new file mode 100644
index 0000000..180de93
--- /dev/null
+++ b/waflib/ansiterm.py
@@ -0,0 +1,174 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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_char(' '),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_char(' '),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
+ neg=False
+ 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 --git a/waflib/extras/__init__.py b/waflib/extras/__init__.py
new file mode 100644
index 0000000..95a3b6a
--- /dev/null
+++ b/waflib/extras/__init__.py
@@ -0,0 +1,4 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
diff --git a/waflib/extras/boost.py b/waflib/extras/boost.py
new file mode 100644
index 0000000..cad9e4a
--- /dev/null
+++ b/waflib/extras/boost.py
@@ -0,0 +1,185 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+'''
+To add the boost tool to the waf file:
+$ ./waf-light --tools=compat15,boost
+ or, if you have waf >= 1.6.2
+$ ./waf update --files=boost
+
+The wscript will look like:
+
+def options(opt):
+ opt.load('compiler_cxx boost')
+
+def configure(conf):
+ conf.load('compiler_cxx boost')
+ conf.check_boost(lib='system filesystem', mt=True, static=True)
+
+def build(bld):
+ bld(source='main.cpp', target='app', use='BOOST')
+'''
+import sys
+import re
+from waflib import Utils,Logs
+from waflib.Configure import conf
+BOOST_LIBS=('/usr/lib','/usr/local/lib','/opt/local/lib','/sw/lib','/lib')
+BOOST_INCLUDES=('/usr/include','/usr/local/include','/opt/local/include','/sw/include')
+BOOST_VERSION_FILE='boost/version.hpp'
+BOOST_VERSION_CODE='''
+#include <iostream>
+#include <boost/version.hpp>
+int main() { std::cout << BOOST_LIB_VERSION << std::endl; }
+'''
+PLATFORM=Utils.unversioned_sys_platform()
+detect_intel=lambda env:(PLATFORM=='win32')and'iw'or'il'
+detect_clang=lambda env:(PLATFORM=='darwin')and'clang-darwin'or'clang'
+detect_mingw=lambda env:(re.search('MinGW',env.CXX[0]))and'mgw'or'gcc'
+BOOST_TOOLSETS={'borland':'bcb','clang':detect_clang,'como':'como','cw':'cw','darwin':'xgcc','edg':'edg','g++':detect_mingw,'gcc':detect_mingw,'icpc':detect_intel,'intel':detect_intel,'kcc':'kcc','kylix':'bck','mipspro':'mp','mingw':'mgw','msvc':'vc','qcc':'qcc','sun':'sw','sunc++':'sw','tru64cxx':'tru','vacpp':'xlc'}
+def options(opt):
+ opt.add_option('--boost-includes',type='string',default='',dest='boost_includes',help='''path to the boost directory where the includes are
+ e.g. /boost_1_45_0/include''')
+ opt.add_option('--boost-libs',type='string',default='',dest='boost_libs',help='''path to the directory where the boost libs are
+ e.g. /boost_1_45_0/stage/lib''')
+ opt.add_option('--boost-static',action='store_true',default=False,dest='boost_static',help='link static libraries')
+ opt.add_option('--boost-mt',action='store_true',default=False,dest='boost_mt',help='select multi-threaded libraries')
+ opt.add_option('--boost-abi',type='string',default='',dest='boost_abi',help='''select libraries with tags (dgsyp, d for debug),
+ see doc Boost, Getting Started, chapter 6.1''')
+ opt.add_option('--boost-toolset',type='string',default='',dest='boost_toolset',help='force a toolset e.g. msvc, vc90, \
+ gcc, mingw, mgw45 (default: auto)')
+ py_version='%d%d'%(sys.version_info[0],sys.version_info[1])
+ opt.add_option('--boost-python',type='string',default=py_version,dest='boost_python',help='select the lib python with this version \
+ (default: %s)'%py_version)
+def __boost_get_version_file(self,dir):
+ try:
+ return self.root.find_dir(dir).find_node(BOOST_VERSION_FILE)
+ except:
+ return None
+def boost_get_version(self,dir):
+ re_but=re.compile('^#define\\s+BOOST_LIB_VERSION\\s+"(.*)"$',re.M)
+ try:
+ val=re_but.search(self.__boost_get_version_file(dir).read()).group(1)
+ except:
+ val=self.check_cxx(fragment=BOOST_VERSION_CODE,includes=[dir],execute=True,define_ret=True)
+ return val
+def boost_get_includes(self,*k,**kw):
+ includes=k and k[0]or kw.get('includes',None)
+ if includes and self.__boost_get_version_file(includes):
+ return includes
+ for dir in BOOST_INCLUDES:
+ if self.__boost_get_version_file(dir):
+ return dir
+ if includes:
+ self.fatal('headers not found in %s'%includes)
+ else:
+ self.fatal('headers not found, use --boost-includes=/path/to/boost')
+def boost_get_toolset(self,cc):
+ toolset=cc
+ if not cc:
+ build_platform=Utils.unversioned_sys_platform()
+ if build_platform in BOOST_TOOLSETS:
+ cc=build_platform
+ else:
+ cc=self.env.CXX_NAME
+ if cc in BOOST_TOOLSETS:
+ toolset=BOOST_TOOLSETS[cc]
+ return isinstance(toolset,str)and toolset or toolset(self.env)
+def __boost_get_libs_path(self,*k,**kw):
+ ''' return the lib path and all the files in it '''
+ if'files'in kw:
+ return self.root.find_dir('.'),Utils.to_list(kw['files'])
+ libs=k and k[0]or kw.get('libs',None)
+ if libs:
+ path=self.root.find_dir(libs)
+ files=path.ant_glob('*boost_*')
+ if not libs or not files:
+ for dir in BOOST_LIBS:
+ try:
+ path=self.root.find_dir(dir)
+ files=path.ant_glob('*boost_*')
+ if files:
+ break
+ path=self.root.find_dir(dir+'64')
+ files=path.ant_glob('*boost_*')
+ if files:
+ break
+ except:
+ path=None
+ if not path:
+ if libs:
+ self.fatal('libs not found in %s'%libs)
+ else:
+ self.fatal('libs not found, \
+ use --boost-includes=/path/to/boost/lib')
+ return path,files
+def boost_get_libs(self,*k,**kw):
+ '''
+ return the lib path and the required libs
+ according to the parameters
+ '''
+ path,files=self.__boost_get_libs_path(**kw)
+ t=[]
+ if kw['mt']:
+ t.append('mt')
+ if kw['abi']:
+ t.append(kw['abi'])
+ tags=t and'(-%s)+'%'-'.join(t)or''
+ toolset='(-%s[0-9]{0,3})+'%self.boost_get_toolset(kw['toolset'])
+ version='(-%s)+'%self.env.BOOST_VERSION
+ def find_lib(re_lib,files):
+ for file in files:
+ if re_lib.search(file.name):
+ return file
+ return None
+ def format_lib_name(name):
+ if name.startswith('lib'):
+ name=name[3:]
+ return name.split('.')[0]
+ libs=[]
+ for lib in Utils.to_list(k and k[0]or kw.get('lib',None)):
+ py=(lib=='python')and'(-py%s)+'%kw['python']or''
+ for pattern in['boost_%s%s%s%s%s'%(lib,toolset,tags,py,version),'boost_%s%s%s%s'%(lib,tags,py,version),'boost_%s%s%s'%(lib,tags,version),'boost_%s%s%s%s'%(lib,toolset,tags,py),'boost_%s%s%s'%(lib,tags,py),'boost_%s%s'%(lib,tags)]:
+ file=find_lib(re.compile(pattern),files)
+ if file:
+ libs.append(format_lib_name(file.name))
+ break
+ else:
+ self.fatal('lib %s not found in %s'%(lib,path))
+ return path.abspath(),libs
+def check_boost(self,*k,**kw):
+ if not self.env['CXX']:
+ self.fatal('load a c++ compiler first, conf.load("compiler_cxx")')
+ params={'lib':k and k[0]or kw.get('lib',None)}
+ for key,value in self.options.__dict__.items():
+ if not key.startswith('boost_'):
+ continue
+ key=key[len('boost_'):]
+ params[key]=value and value or kw.get(key,'')
+ self.start_msg('Checking boost includes')
+ self.env.INCLUDES_BOOST=self.boost_get_includes(**params)
+ self.env.BOOST_VERSION=self.boost_get_version(self.env.INCLUDES_BOOST)
+ self.end_msg(self.env.BOOST_VERSION)
+ if Logs.verbose:
+ Logs.pprint('CYAN',' path : %s'%self.env.INCLUDES_BOOST)
+ if not params['lib']:
+ return
+ self.start_msg('Checking boost libs')
+ suffix=params['static']and'ST'or''
+ path,libs=self.boost_get_libs(**params)
+ self.env['%sLIBPATH_BOOST'%suffix]=[path]
+ self.env['%sLIB_BOOST'%suffix]=libs
+ self.end_msg('ok')
+ if Logs.verbose:
+ Logs.pprint('CYAN',' path : %s'%path)
+ Logs.pprint('CYAN',' libs : %s'%libs)
+
+conf(__boost_get_version_file)
+conf(boost_get_version)
+conf(boost_get_includes)
+conf(boost_get_toolset)
+conf(__boost_get_libs_path)
+conf(boost_get_libs)
+conf(check_boost)
\ No newline at end of file
diff --git a/waflib/extras/compat15.py b/waflib/extras/compat15.py
new file mode 100644
index 0000000..374b1c9
--- /dev/null
+++ b/waflib/extras/compat15.py
@@ -0,0 +1,223 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import sys
+from waflib import ConfigSet,Logs,Options,Scripting,Task,Build,Configure,Node,Runner,TaskGen,Utils,Errors,Context
+sys.modules['Environment']=ConfigSet
+ConfigSet.Environment=ConfigSet.ConfigSet
+sys.modules['Logs']=Logs
+sys.modules['Options']=Options
+sys.modules['Scripting']=Scripting
+sys.modules['Task']=Task
+sys.modules['Build']=Build
+sys.modules['Configure']=Configure
+sys.modules['Node']=Node
+sys.modules['Runner']=Runner
+sys.modules['TaskGen']=TaskGen
+sys.modules['Utils']=Utils
+from waflib.Tools import c_preproc
+sys.modules['preproc']=c_preproc
+from waflib.Tools import c_config
+sys.modules['config_c']=c_config
+ConfigSet.ConfigSet.copy=ConfigSet.ConfigSet.derive
+ConfigSet.ConfigSet.set_variant=Utils.nada
+Build.BuildContext.add_subdirs=Build.BuildContext.recurse
+Build.BuildContext.new_task_gen=Build.BuildContext.__call__
+Build.BuildContext.is_install=0
+Node.Node.relpath_gen=Node.Node.path_from
+def name_to_obj(self,s,env=None):
+ Logs.warn('compat: change "name_to_obj(name, env)" by "get_tgen_by_name(name)"')
+ return self.get_tgen_by_name(s)
+Build.BuildContext.name_to_obj=name_to_obj
+def env_of_name(self,name):
+ try:
+ return self.all_envs[name]
+ except KeyError:
+ Logs.error('no such environment: '+name)
+ return None
+Build.BuildContext.env_of_name=env_of_name
+def set_env_name(self,name,env):
+ self.all_envs[name]=env
+ return env
+Configure.ConfigurationContext.set_env_name=set_env_name
+def retrieve(self,name,fromenv=None):
+ try:
+ env=self.all_envs[name]
+ except KeyError:
+ env=ConfigSet.ConfigSet()
+ self.prepare_env(env)
+ self.all_envs[name]=env
+ else:
+ if fromenv:Logs.warn("The environment %s may have been configured already"%name)
+ return env
+Configure.ConfigurationContext.retrieve=retrieve
+Configure.ConfigurationContext.sub_config=Configure.ConfigurationContext.recurse
+Configure.ConfigurationContext.check_tool=Configure.ConfigurationContext.load
+Configure.conftest=Configure.conf
+Configure.ConfigurationError=Errors.ConfigurationError
+Options.OptionsContext.sub_options=Options.OptionsContext.recurse
+Options.OptionsContext.tool_options=Context.Context.load
+Options.Handler=Options.OptionsContext
+Task.simple_task_type=Task.task_type_from_func=Task.task_factory
+Task.TaskBase.classes=Task.classes
+def setitem(self,key,value):
+ if key.startswith('CCFLAGS'):
+ key=key[1:]
+ self.table[key]=value
+ConfigSet.ConfigSet.__setitem__=setitem
+def old_importpaths(self):
+ if getattr(self,'importpaths',[]):
+ self.includes=self.importpaths
+from waflib import Context
+eld=Context.load_tool
+def load_tool(*k,**kw):
+ ret=eld(*k,**kw)
+ if'set_options'in ret.__dict__:
+ Logs.warn('compat: rename "set_options" to options')
+ ret.options=ret.set_options
+ if'detect'in ret.__dict__:
+ Logs.warn('compat: rename "detect" to "configure"')
+ ret.configure=ret.detect
+ return ret
+Context.load_tool=load_tool
+rev=Context.load_module
+def load_module(path):
+ ret=rev(path)
+ if'set_options'in ret.__dict__:
+ Logs.warn('compat: rename "set_options" to "options" (%r)'%path)
+ ret.options=ret.set_options
+ if'srcdir'in ret.__dict__:
+ Logs.warn('compat: rename "srcdir" to "top" (%r)'%path)
+ ret.top=ret.srcdir
+ if'blddir'in ret.__dict__:
+ Logs.warn('compat: rename "blddir" to "out" (%r)'%path)
+ ret.out=ret.blddir
+ return ret
+Context.load_module=load_module
+old_post=TaskGen.task_gen.post
+def post(self):
+ self.features=self.to_list(self.features)
+ if'cc'in self.features:
+ Logs.warn('compat: the feature cc does not exist anymore (use "c")')
+ self.features.remove('cc')
+ self.features.append('c')
+ if'cstaticlib'in self.features:
+ Logs.warn('compat: the feature cstaticlib does not exist anymore (use "cstlib" or "cxxstlib")')
+ self.features.remove('cstaticlib')
+ self.features.append(('cxx'in self.features)and'cxxstlib'or'cstlib')
+ if getattr(self,'ccflags',None):
+ Logs.warn('compat: "ccflags" was renamed to "cflags"')
+ self.cflags=self.ccflags
+ return old_post(self)
+TaskGen.task_gen.post=post
+def waf_version(*k,**kw):
+ Logs.warn('wrong version (waf_version was removed in waf 1.6)')
+Utils.waf_version=waf_version
+import os
+def apply_uselib_local(self):
+ env=self.env
+ from waflib.Tools.ccroot import stlink_task
+ self.uselib=self.to_list(getattr(self,'uselib',[]))
+ self.includes=self.to_list(getattr(self,'includes',[]))
+ names=self.to_list(getattr(self,'uselib_local',[]))
+ get=self.bld.get_tgen_by_name
+ seen=set([])
+ tmp=Utils.deque(names)
+ if tmp:
+ Logs.warn('compat: "uselib_local" is deprecated, replace by "use"')
+ while tmp:
+ lib_name=tmp.popleft()
+ if lib_name in seen:
+ continue
+ y=get(lib_name)
+ y.post()
+ seen.add(lib_name)
+ if getattr(y,'uselib_local',None):
+ for x in self.to_list(getattr(y,'uselib_local',[])):
+ obj=get(x)
+ obj.post()
+ if getattr(obj,'link_task',None):
+ if not isinstance(obj.link_task,stlink_task):
+ tmp.append(x)
+ if getattr(y,'link_task',None):
+ link_name=y.target[y.target.rfind(os.sep)+1:]
+ if isinstance(y.link_task,stlink_task):
+ env.append_value('STLIB',[link_name])
+ else:
+ env.append_value('LIB',[link_name])
+ self.link_task.set_run_after(y.link_task)
+ self.link_task.dep_nodes+=y.link_task.outputs
+ tmp_path=y.link_task.outputs[0].parent.bldpath()
+ if not tmp_path in env['LIBPATH']:
+ env.prepend_value('LIBPATH',[tmp_path])
+ for v in self.to_list(getattr(y,'uselib',[])):
+ if not env['STLIB_'+v]:
+ if not v in self.uselib:
+ self.uselib.insert(0,v)
+ if getattr(y,'export_includes',None):
+ self.includes.extend(y.to_incnodes(y.export_includes))
+def apply_objdeps(self):
+ names=getattr(self,'add_objects',[])
+ if not names:
+ return
+ names=self.to_list(names)
+ get=self.bld.get_tgen_by_name
+ seen=[]
+ while names:
+ x=names[0]
+ if x in seen:
+ names=names[1:]
+ continue
+ y=get(x)
+ if getattr(y,'add_objects',None):
+ added=0
+ lst=y.to_list(y.add_objects)
+ lst.reverse()
+ for u in lst:
+ if u in seen:continue
+ added=1
+ names=[u]+names
+ if added:continue
+ y.post()
+ seen.append(x)
+ for t in getattr(y,'compiled_tasks',[]):
+ self.link_task.inputs.extend(t.outputs)
+def process_obj_files(self):
+ if not hasattr(self,'obj_files'):
+ return
+ for x in self.obj_files:
+ node=self.path.find_resource(x)
+ self.link_task.inputs.append(node)
+def add_obj_file(self,file):
+ if not hasattr(self,'obj_files'):self.obj_files=[]
+ if not'process_obj_files'in self.meths:self.meths.append('process_obj_files')
+ self.obj_files.append(file)
+old_define=Configure.ConfigurationContext.__dict__['define']
+def define(self,key,val,quote=True):
+ old_define(self,key,val,quote)
+ if key.startswith('HAVE_'):
+ self.env[key]=1
+old_undefine=Configure.ConfigurationContext.__dict__['undefine']
+def undefine(self,key):
+ old_undefine(self,key)
+ if key.startswith('HAVE_'):
+ self.env[key]=0
+def set_incdirs(self,val):
+ Logs.warn('compat: change "export_incdirs" by "export_includes"')
+ self.export_includes=val
+TaskGen.task_gen.export_incdirs=property(None,set_incdirs)
+
+TaskGen.feature('d')(old_importpaths)
+TaskGen.before('apply_incpaths')(old_importpaths)
+TaskGen.feature('c','cxx','d')(apply_uselib_local)
+TaskGen.before('apply_incpaths','propagate_uselib_vars')(apply_uselib_local)
+TaskGen.after('apply_link','process_source')(apply_uselib_local)
+TaskGen.feature('cprogram','cxxprogram','cstlib','cxxstlib','cshlib','cxxshlib','dprogram','dstlib','dshlib')(apply_objdeps)
+TaskGen.after('apply_link')(apply_objdeps)
+TaskGen.after('apply_link')(process_obj_files)
+TaskGen.taskgen_method(add_obj_file)
+Configure.conf(define)
+Configure.conf(undefine)
\ No newline at end of file
diff --git a/waflib/extras/cython.py b/waflib/extras/cython.py
new file mode 100644
index 0000000..828a2f3
--- /dev/null
+++ b/waflib/extras/cython.py
@@ -0,0 +1,77 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import re
+import waflib
+import waflib.Logs as _msg
+from waflib import Task
+from waflib.TaskGen import extension,feature,before_method,after_method
+cy_api_pat=re.compile(r'\s*?cdef\s*?(public|api)\w*')
+re_cyt=re.compile('import\\s(\\w+)\\s*$',re.M)
+def add_cython_file(self,node):
+ ext='.c'
+ if'cxx'in self.features:
+ self.env.append_unique('CYTHONFLAGS','--cplus')
+ ext='.cc'
+ tsk=self.create_task('cython',node,node.change_ext(ext))
+ self.source+=tsk.outputs
+class cython(Task.Task):
+ run_str='${CYTHON} ${CYTHONFLAGS} -o ${TGT[0].abspath()} ${SRC}'
+ color='GREEN'
+ vars=['INCLUDES']
+ ext_out=['.h']
+ def runnable_status(self):
+ ret=super(cython,self).runnable_status()
+ if ret==Task.ASK_LATER:
+ return ret
+ for x in self.generator.bld.raw_deps[self.uid()]:
+ if x.startswith('header:'):
+ self.outputs.append(self.inputs[0].parent.find_or_declare(x.replace('header:','')))
+ return super(cython,self).runnable_status()
+ def scan(self):
+ txt=self.inputs[0].read()
+ mods=[]
+ for m in re_cyt.finditer(txt):
+ mods.append(m.group(1))
+ _msg.debug("cython: mods %r"%mods)
+ incs=getattr(self.generator,'cython_includes',[])
+ incs=[self.generator.path.find_dir(x)for x in incs]
+ incs.append(self.inputs[0].parent)
+ found=[]
+ missing=[]
+ for x in mods:
+ for y in incs:
+ k=y.find_resource(x+'.pxd')
+ if k:
+ found.append(k)
+ break
+ else:
+ missing.append(x)
+ _msg.debug("cython: found %r"%found)
+ has_api=False
+ has_public=False
+ for l in txt.splitlines():
+ if cy_api_pat.match(l):
+ if' api 'in l:
+ has_api=True
+ if' public 'in l:
+ has_public=True
+ name=self.inputs[0].name.replace('.pyx','')
+ if has_api:
+ missing.append('header:%s_api.h'%name)
+ if has_public:
+ missing.append('header:%s.h'%name)
+ return(found,missing)
+def options(ctx):
+ ctx.add_option('--cython-flags',action='store',default='',help='space separated list of flags to pass to cython')
+def configure(ctx):
+ if not ctx.env.CC and not ctx.env.CXX:
+ ctx.fatal('Load a C/C++ compiler first')
+ if not ctx.env.PYTHON:
+ ctx.fatal('Load the python tool first!')
+ ctx.find_program('cython',var='CYTHON')
+ if ctx.options.cython_flags:
+ ctx.env.CYTHONFLAGS=ctx.options.cython_flags
+
+extension('.pyx')(add_cython_file)
\ No newline at end of file
diff --git a/waflib/extras/erlang.py b/waflib/extras/erlang.py
new file mode 100644
index 0000000..59f5891
--- /dev/null
+++ b/waflib/extras/erlang.py
@@ -0,0 +1,9 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+from waflib import TaskGen
+TaskGen.declare_chain(name='erlc',rule='${ERLC} ${ERLC_FLAGS} ${SRC[0].abspath()} -o ${TGT[0].name}',reentrant=False,ext_in='.erl',ext_out='.beam')
+def configure(conf):
+ conf.find_program('erlc',var='ERLC')
+ conf.env.ERLC_FLAGS=[]
diff --git a/waflib/extras/go.py b/waflib/extras/go.py
new file mode 100644
index 0000000..c28a08a
--- /dev/null
+++ b/waflib/extras/go.py
@@ -0,0 +1,181 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,platform
+from waflib import Utils,Task
+from waflib.TaskGen import feature,extension,after_method,before_method
+from waflib.Tools.ccroot import link_task,stlink_task
+class go(Task.Task):
+ run_str='${GOC} ${GOCFLAGS} ${CPPPATH_ST:INCPATHS} -o ${TGT} ${SRC}'
+class gopackage(stlink_task):
+ run_str='${GOP} grc ${TGT} ${SRC}'
+class goprogram(link_task):
+ run_str='${GOL} ${GOLFLAGS} -o ${TGT} ${SRC}'
+ inst_to='${BINDIR}'
+ chmod=Utils.O755
+class cgopackage(stlink_task):
+ color='YELLOW'
+ inst_to='${LIBDIR}'
+ ext_in=['.go']
+ ext_out=['.a']
+ def run(self):
+ src_dir=self.generator.bld.path
+ source=self.inputs
+ target=self.outputs[0].change_ext('')
+ bld_dir=self.outputs[1]
+ bld_dir.mkdir()
+ obj_dir=bld_dir.make_node('_obj')
+ obj_dir.mkdir()
+ bld_srcs=[]
+ for s in source:
+ b=bld_dir.make_node(s.path_from(src_dir).replace(os.sep,'_'))
+ b.parent.mkdir()
+ try:
+ try:os.remove(b.abspath())
+ except Exception:pass
+ os.symlink(s.abspath(),b.abspath())
+ except Exception:
+ b.write(s.read())
+ bld_srcs.append(b)
+ b.sig=Utils.h_file(b.abspath())
+ pass
+ cgo_flags_node=bld_dir.make_node('_waf_cgoflags.go')
+ cgo_flags_node.write('''\
+package %(target)s
+
+/*
+ #cgo CFLAGS: %(cgo_cflags)s
+ #cgo LDFLAGS: %(cgo_ldflags)s
+*/
+import "C"
+// EOF
+'''%{'target':target,'cgo_cflags':' '.join(l for l in self.env['GOCFLAGS']),'cgo_ldflags':' '.join(l for l in self.env['GOLFLAGS']),})
+ bld_srcs.insert(0,cgo_flags_node)
+ cgo_flags_node.sig=Utils.h_file(cgo_flags_node.abspath())
+ makefile_node=bld_dir.make_node("Makefile")
+ makefile_tmpl='''\
+# Copyright 2009 The Go Authors. All rights reserved.
+# Use of this source code is governed by a BSD-style
+# license that can be found in the LICENSE file. ---
+
+include $(GOROOT)/src/Make.inc
+
+TARG=%(target)s
+
+CGOFILES=\\
+\t%(source)s
+
+include $(GOROOT)/src/Make.pkg
+
+%%: install %%.go
+ $(GC) $*.go
+ $(LD) -o $@ $*.$O
+
+'''%{'target':target.path_from(obj_dir),'source':' '.join([b.path_from(bld_dir)for b in bld_srcs])}
+ makefile_node.write(makefile_tmpl)
+ cmd=Utils.subst_vars('gomake ${GOMAKE_FLAGS}',self.env).strip()
+ o=self.outputs[0].change_ext('.gomake.log')
+ fout_node=bld_dir.find_or_declare(o.name)
+ fout=open(fout_node.abspath(),'w')
+ rc=self.generator.bld.exec_command(cmd,stdout=fout,stderr=fout,cwd=bld_dir.abspath(),)
+ if rc!=0:
+ import waflib.Logs as msg
+ msg.error('** error running [%s] (cgo-%s)'%(cmd,target))
+ msg.error(fout_node.read())
+ return rc
+ self.generator.bld.read_stlib(target,paths=[obj_dir.abspath(),],)
+ tgt=self.outputs[0]
+ if tgt.parent!=obj_dir:
+ install_dir=os.path.join('${LIBDIR}',tgt.parent.path_from(obj_dir))
+ else:
+ install_dir='${LIBDIR}'
+ self.generator.bld.install_files(install_dir,tgt.abspath(),relative_trick=False,postpone=False,)
+ return rc
+def compile_go(self,node):
+ if not('cgopackage'in self.features):
+ return self.create_compiled_task('go',node)
+ bld_dir=node.parent.get_bld()
+ obj_dir=bld_dir.make_node('_obj')
+ target=obj_dir.make_node(node.change_ext('.a').name)
+ return self.create_task('cgopackage',node,node.change_ext('.a'))
+def go_compiler_is_foobar(self):
+ if self.env.GONAME=='gcc':
+ return
+ self.source=self.to_nodes(self.source)
+ src=[]
+ go=[]
+ for node in self.source:
+ if node.name.endswith('.go'):
+ go.append(node)
+ else:
+ src.append(node)
+ self.source=src
+ if not('cgopackage'in self.features):
+ tsk=self.create_compiled_task('go',go[0])
+ tsk.inputs.extend(go[1:])
+ else:
+ bld_dir=self.path.get_bld().make_node('cgopackage--%s'%self.target.replace(os.sep,'_'))
+ obj_dir=bld_dir.make_node('_obj')
+ target=obj_dir.make_node(self.target+'.a')
+ tsk=self.create_task('cgopackage',go,[target,bld_dir])
+ self.link_task=tsk
+def go_local_libs(self):
+ names=self.to_list(getattr(self,'use',[]))
+ for name in names:
+ tg=self.bld.get_tgen_by_name(name)
+ if not tg:
+ raise Utils.WafError('no target of name %r necessary for %r in go uselib local'%(name,self))
+ tg.post()
+ lnk_task=getattr(tg,'link_task',None)
+ if lnk_task:
+ for tsk in self.tasks:
+ if isinstance(tsk,(go,cgopackage)):
+ tsk.set_run_after(lnk_task)
+ tsk.dep_nodes.extend(lnk_task.outputs)
+ path=lnk_task.outputs[0].parent.abspath()
+ self.env.append_unique('GOCFLAGS',['-I%s'%path])
+ self.env.append_unique('GOLFLAGS',['-L%s'%path])
+ for n in getattr(tg,'includes_nodes',[]):
+ self.env.append_unique('GOCFLAGS',['-I%s'%n.abspath()])
+ pass
+ pass
+def configure(conf):
+ def set_def(var,val):
+ if not conf.env[var]:
+ conf.env[var]=val
+ goarch=os.getenv('GOARCH')
+ if goarch=='386':
+ set_def('GO_PLATFORM','i386')
+ elif goarch=='amd64':
+ set_def('GO_PLATFORM','x86_64')
+ elif goarch=='arm':
+ set_def('GO_PLATFORM','arm')
+ else:
+ set_def('GO_PLATFORM',platform.machine())
+ if conf.env.GO_PLATFORM=='x86_64':
+ set_def('GO_COMPILER','6g')
+ set_def('GO_LINKER','6l')
+ elif conf.env.GO_PLATFORM in['i386','i486','i586','i686']:
+ set_def('GO_COMPILER','8g')
+ set_def('GO_LINKER','8l')
+ elif conf.env.GO_PLATFORM=='arm':
+ set_def('GO_COMPILER','5g')
+ set_def('GO_LINKER','5l')
+ set_def('GO_EXTENSION','.5')
+ if not(conf.env.GO_COMPILER or conf.env.GO_LINKER):
+ raise conf.fatal('Unsupported platform '+platform.machine())
+ set_def('GO_PACK','gopack')
+ set_def('gopackage_PATTERN','%s.a')
+ set_def('CPPPATH_ST','-I%s')
+ set_def('GOMAKE_FLAGS',['--quiet'])
+ conf.find_program(conf.env.GO_COMPILER,var='GOC')
+ conf.find_program(conf.env.GO_LINKER,var='GOL')
+ conf.find_program(conf.env.GO_PACK,var='GOP')
+ conf.find_program('cgo',var='CGO')
+
+extension('.go')(compile_go)
+feature('gopackage','goprogram','cgopackage')(go_compiler_is_foobar)
+before_method('process_source')(go_compiler_is_foobar)
+feature('gopackage','goprogram','cgopackage')(go_local_libs)
+after_method('process_source','apply_incpaths',)(go_local_libs)
\ No newline at end of file
diff --git a/waflib/extras/ocaml.py b/waflib/extras/ocaml.py
new file mode 100644
index 0000000..ffbba11
--- /dev/null
+++ b/waflib/extras/ocaml.py
@@ -0,0 +1,242 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import os,re
+from waflib import TaskGen,Utils,Task,Build
+from waflib.Logs import error
+from waflib.TaskGen import feature,before_method,after_method,extension
+EXT_MLL=['.mll']
+EXT_MLY=['.mly']
+EXT_MLI=['.mli']
+EXT_MLC=['.c']
+EXT_ML=['.ml']
+open_re=re.compile('^\s*open\s+([a-zA-Z]+)(;;){0,1}$',re.M)
+foo=re.compile(r"""(\(\*)|(\*\))|("(\\.|[^"\\])*"|'(\\.|[^'\\])*'|.[^()*"'\\]*)""",re.M)
+def filter_comments(txt):
+ meh=[0]
+ def repl(m):
+ if m.group(1):meh[0]+=1
+ elif m.group(2):meh[0]-=1
+ elif not meh[0]:return m.group(0)
+ return''
+ return foo.sub(repl,txt)
+def scan(self):
+ node=self.inputs[0]
+ code=filter_comments(node.read())
+ global open_re
+ names=[]
+ import_iterator=open_re.finditer(code)
+ if import_iterator:
+ for import_match in import_iterator:
+ names.append(import_match.group(1))
+ found_lst=[]
+ raw_lst=[]
+ for name in names:
+ nd=None
+ for x in self.incpaths:
+ nd=x.find_resource(name.lower()+'.ml')
+ if not nd:nd=x.find_resource(name+'.ml')
+ if nd:
+ found_lst.append(nd)
+ break
+ else:
+ raw_lst.append(name)
+ return(found_lst,raw_lst)
+native_lst=['native','all','c_object']
+bytecode_lst=['bytecode','all']
+def init_ml(self):
+ Utils.def_attrs(self,type='all',incpaths_lst=[],bld_incpaths_lst=[],mlltasks=[],mlytasks=[],mlitasks=[],native_tasks=[],bytecode_tasks=[],linktasks=[],bytecode_env=None,native_env=None,compiled_tasks=[],includes='',uselib='',are_deps_set=0)
+def init_envs_ml(self):
+ self.islibrary=getattr(self,'islibrary',False)
+ global native_lst,bytecode_lst
+ self.native_env=None
+ if self.type in native_lst:
+ self.native_env=self.env.derive()
+ if self.islibrary:self.native_env['OCALINKFLAGS']='-a'
+ self.bytecode_env=None
+ if self.type in bytecode_lst:
+ self.bytecode_env=self.env.derive()
+ if self.islibrary:self.bytecode_env['OCALINKFLAGS']='-a'
+ if self.type=='c_object':
+ self.native_env.append_unique('OCALINKFLAGS_OPT','-output-obj')
+def apply_incpaths_ml(self):
+ inc_lst=self.includes.split()
+ lst=self.incpaths_lst
+ for dir in inc_lst:
+ node=self.path.find_dir(dir)
+ if not node:
+ error("node not found: "+str(dir))
+ continue
+ if not node in lst:
+ lst.append(node)
+ self.bld_incpaths_lst.append(node)
+def apply_vars_ml(self):
+ for i in self.incpaths_lst:
+ if self.bytecode_env:
+ app=self.bytecode_env.append_value
+ app('OCAMLPATH',['-I',i.bldpath(),'-I',i.srcpath()])
+ if self.native_env:
+ app=self.native_env.append_value
+ app('OCAMLPATH',['-I',i.bldpath(),'-I',i.srcpath()])
+ varnames=['INCLUDES','OCAMLFLAGS','OCALINKFLAGS','OCALINKFLAGS_OPT']
+ for name in self.uselib.split():
+ for vname in varnames:
+ cnt=self.env[vname+'_'+name]
+ if cnt:
+ if self.bytecode_env:self.bytecode_env.append_value(vname,cnt)
+ if self.native_env:self.native_env.append_value(vname,cnt)
+def apply_link_ml(self):
+ if self.bytecode_env:
+ ext=self.islibrary and'.cma'or'.run'
+ linktask=self.create_task('ocalink')
+ linktask.bytecode=1
+ linktask.set_outputs(self.path.find_or_declare(self.target+ext))
+ linktask.env=self.bytecode_env
+ self.linktasks.append(linktask)
+ if self.native_env:
+ if self.type=='c_object':ext='.o'
+ elif self.islibrary:ext='.cmxa'
+ else:ext=''
+ linktask=self.create_task('ocalinkx')
+ linktask.set_outputs(self.path.find_or_declare(self.target+ext))
+ linktask.env=self.native_env
+ self.linktasks.append(linktask)
+ self.compiled_tasks.append(linktask)
+def mll_hook(self,node):
+ mll_task=self.create_task('ocamllex',node,node.change_ext('.ml'))
+ mll_task.env=self.native_env.derive()
+ self.mlltasks.append(mll_task)
+ self.source.append(mll_task.outputs[0])
+def mly_hook(self,node):
+ mly_task=self.create_task('ocamlyacc',node,[node.change_ext('.ml'),node.change_ext('.mli')])
+ mly_task.env=self.native_env.derive()
+ self.mlytasks.append(mly_task)
+ self.source.append(mly_task.outputs[0])
+ task=self.create_task('ocamlcmi',mly_task.outputs[1],mly_task.outputs[1].change_ext('.cmi'))
+ task.env=self.native_env.derive()
+def mli_hook(self,node):
+ task=self.create_task('ocamlcmi',node,node.change_ext('.cmi'))
+ task.env=self.native_env.derive()
+ self.mlitasks.append(task)
+def mlc_hook(self,node):
+ task=self.create_task('ocamlcc',node,node.change_ext('.o'))
+ task.env=self.native_env.derive()
+ self.compiled_tasks.append(task)
+def ml_hook(self,node):
+ if self.native_env:
+ task=self.create_task('ocamlx',node,node.change_ext('.cmx'))
+ task.env=self.native_env.derive()
+ task.incpaths=self.bld_incpaths_lst
+ self.native_tasks.append(task)
+ if self.bytecode_env:
+ task=self.create_task('ocaml',node,node.change_ext('.cmo'))
+ task.env=self.bytecode_env.derive()
+ task.bytecode=1
+ task.incpaths=self.bld_incpaths_lst
+ self.bytecode_tasks.append(task)
+def compile_may_start(self):
+ if not getattr(self,'flag_deps',''):
+ self.flag_deps=1
+ if getattr(self,'bytecode',''):alltasks=self.generator.bytecode_tasks
+ else:alltasks=self.generator.native_tasks
+ self.signature()
+ tree=self.generator.bld
+ env=self.env
+ for node in self.inputs:
+ lst=tree.node_deps[self.uid()]
+ for depnode in lst:
+ for t in alltasks:
+ if t==self:continue
+ if depnode in t.inputs:
+ self.set_run_after(t)
+ delattr(self,'cache_sig')
+ self.signature()
+ return Task.Task.runnable_status(self)
+class ocamlx(Task.Task):
+ color='GREEN'
+ run_str='${OCAMLOPT} ${OCAMLPATH} ${OCAMLFLAGS} ${OCAMLINCLUDES} -c -o ${TGT} ${SRC}'
+ scan=scan
+ runnable_status=compile_may_start
+class ocaml(Task.Task):
+ color='GREEN'
+ run_str='${OCAMLC} ${OCAMLPATH} ${OCAMLFLAGS} ${OCAMLINCLUDES} -c -o ${TGT} ${SRC}'
+ scan=scan
+ runnable_status=compile_may_start
+class ocamlcmi(Task.Task):
+ color='BLUE'
+ run_str='${OCAMLC} ${OCAMLPATH} ${OCAMLINCLUDES} -o ${TGT} -c ${SRC}'
+ before=['ocamlcc','ocaml','ocamlcc']
+class ocamlcc(Task.Task):
+ color='GREEN'
+ run_str='cd ${TGT[0].bld_dir()} && ${OCAMLOPT} ${OCAMLFLAGS} ${OCAMLPATH} ${OCAMLINCLUDES} -c ${SRC[0].abspath()}'
+class ocamllex(Task.Task):
+ color='BLUE'
+ run_str='${OCAMLLEX} ${SRC} -o ${TGT}'
+ before=['ocamlcmi','ocaml','ocamlcc']
+class ocamlyacc(Task.Task):
+ color='BLUE'
+ run_str='${OCAMLYACC} -b ${TGT[0].bld_base(env)} ${SRC}'
+ before=['ocamlcmi','ocaml','ocamlcc']
+def link_may_start(self):
+ if getattr(self,'bytecode',0):alltasks=self.generator.bytecode_tasks
+ else:alltasks=self.generator.native_tasks
+ for x in alltasks:
+ if not x.hasrun:
+ return Task.ASK_LATER
+ if not getattr(self,'order',''):
+ seen=[]
+ pendant=[]+alltasks
+ while pendant:
+ task=pendant.pop(0)
+ if task in seen:continue
+ for x in task.run_after:
+ if not x in seen:
+ pendant.append(task)
+ break
+ else:
+ seen.append(task)
+ self.inputs=[x.outputs[0]for x in seen]
+ self.order=1
+ return Task.Task.runnable_status(self)
+class ocalink(Task.Task):
+ color='YELLOW'
+ run_str='${OCAMLC} -o ${TGT} ${OCAMLINCLUDES} ${OCALINKFLAGS} ${SRC}'
+ runnable_status=link_may_start
+ after=['ocaml','ocamlcc']
+class ocalinkx(Task.Task):
+ color='YELLOW'
+ run_str='${OCAMLOPT} -o ${TGT} ${OCAMLINCLUDES} ${OCALINKFLAGS_OPT} ${SRC}'
+ runnable_status=link_may_start
+ after=['ocamlx','ocamlcc']
+def configure(conf):
+ opt=conf.find_program('ocamlopt',var='OCAMLOPT',mandatory=False)
+ occ=conf.find_program('ocamlc',var='OCAMLC',mandatory=False)
+ if(not opt)or(not occ):
+ conf.fatal('The objective caml compiler was not found:\ninstall it or make it available in your PATH')
+ v=conf.env
+ v['OCAMLC']=occ
+ v['OCAMLOPT']=opt
+ v['OCAMLLEX']=conf.find_program('ocamllex',var='OCAMLLEX',mandatory=False)
+ v['OCAMLYACC']=conf.find_program('ocamlyacc',var='OCAMLYACC',mandatory=False)
+ v['OCAMLFLAGS']=''
+ v['OCAMLLIB']=conf.cmd_and_log(conf.env['OCAMLC']+' -where').strip()+os.sep
+ v['LIBPATH_OCAML']=conf.cmd_and_log(conf.env['OCAMLC']+' -where').strip()+os.sep
+ v['INCLUDES_OCAML']=conf.cmd_and_log(conf.env['OCAMLC']+' -where').strip()+os.sep
+ v['LIB_OCAML']='camlrun'
+
+feature('ocaml')(init_ml)
+feature('ocaml')(init_envs_ml)
+after_method('init_ml')(init_envs_ml)
+feature('ocaml')(apply_incpaths_ml)
+before_method('apply_vars_ml')(apply_incpaths_ml)
+after_method('init_envs_ml')(apply_incpaths_ml)
+feature('ocaml')(apply_vars_ml)
+before_method('process_source')(apply_vars_ml)
+feature('ocaml')(apply_link_ml)
+after_method('process_source')(apply_link_ml)
+extension(*EXT_MLL)(mll_hook)
+extension(*EXT_MLY)(mly_hook)
+extension(*EXT_MLI)(mli_hook)
+extension(*EXT_MLC)(mlc_hook)
+extension(*EXT_ML)(ml_hook)
\ No newline at end of file
diff --git a/waflib/extras/pep8.py b/waflib/extras/pep8.py
new file mode 100644
index 0000000..9aefa70
--- /dev/null
+++ b/waflib/extras/pep8.py
@@ -0,0 +1,73 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+'''
+Install pep8 module:
+$ easy_install pep8
+ or
+$ pip install pep8
+
+To add the boost tool to the waf file:
+$ ./waf-light --tools=compat15,pep8
+ or, if you have waf >= 1.6.2
+$ ./waf update --files=pep8
+
+
+Then add this to your wscript:
+
+[at]extension('.py', 'wscript')
+def run_pep8(self, node):
+ self.create_task('Pep8', node)
+
+'''
+import threading
+from waflib import TaskGen,Task,Options
+pep8=__import__('pep8')
+class Pep8(Task.Task):
+ color='PINK'
+ lock=threading.Lock()
+ def check_options(self):
+ if pep8.options:
+ return
+ pep8.options=Options.options
+ pep8.options.prog='pep8'
+ excl=pep8.options.exclude.split(',')
+ pep8.options.exclude=[s.rstrip('/')for s in excl]
+ if pep8.options.filename:
+ pep8.options.filename=pep8.options.filename.split(',')
+ if pep8.options.select:
+ pep8.options.select=pep8.options.select.split(',')
+ else:
+ pep8.options.select=[]
+ if pep8.options.ignore:
+ pep8.options.ignore=pep8.options.ignore.split(',')
+ elif pep8.options.select:
+ pep8.options.ignore=['']
+ elif pep8.options.testsuite or pep8.options.doctest:
+ pep8.options.ignore=[]
+ else:
+ pep8.options.ignore=pep8.DEFAULT_IGNORE.split(',')
+ pep8.options.physical_checks=pep8.find_checks('physical_line')
+ pep8.options.logical_checks=pep8.find_checks('logical_line')
+ pep8.options.counters=dict.fromkeys(pep8.BENCHMARK_KEYS,0)
+ pep8.options.messages={}
+ def run(self):
+ with Pep8.lock:
+ self.check_options()
+ pep8.input_file(self.inputs[0].abspath())
+ return 0 if not pep8.get_count()else-1
+def options(opt):
+ opt.add_option('-q','--quiet',default=0,action='count',help="report only file names, or nothing with -qq")
+ opt.add_option('-r','--repeat',action='store_true',help="show all occurrences of the same error")
+ opt.add_option('--exclude',metavar='patterns',default=pep8.DEFAULT_EXCLUDE,help="exclude files or directories which match these ""comma separated patterns (default: %s)"%pep8.DEFAULT_EXCLUDE,dest='exclude')
+ opt.add_option('--filename',metavar='patterns',default='*.py',help="when parsing directories, only check filenames ""matching these comma separated patterns (default: ""*.py)")
+ opt.add_option('--select',metavar='errors',default='',help="select errors and warnings (e.g. E,W6)")
+ opt.add_option('--ignore',metavar='errors',default='',help="skip errors and warnings (e.g. E4,W)")
+ opt.add_option('--show-source',action='store_true',help="show source code for each error")
+ opt.add_option('--show-pep8',action='store_true',help="show text of PEP 8 for each error")
+ opt.add_option('--statistics',action='store_true',help="count errors and warnings")
+ opt.add_option('--count',action='store_true',help="print total number of errors and warnings ""to standard error and set exit code to 1 if ""total is not null")
+ opt.add_option('--benchmark',action='store_true',help="measure processing speed")
+ opt.add_option('--testsuite',metavar='dir',help="run regression tests from dir")
+ opt.add_option('--doctest',action='store_true',help="run doctest on myself")
diff --git a/waflib/extras/scala.py b/waflib/extras/scala.py
new file mode 100644
index 0000000..b9a762f
--- /dev/null
+++ b/waflib/extras/scala.py
@@ -0,0 +1,93 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+import sys
+if sys.hexversion < 0x020400f0: from sets import Set as set
+import os,re
+from waflib.Configure import conf
+from waflib import TaskGen,Task,Utils,Options,Build,Errors,Node
+from waflib.TaskGen import feature,before_method,after_method
+from waflib.Tools import ccroot
+ccroot.USELIB_VARS['scalac']=set(['CLASSPATH','SCALACFLAGS'])
+from waflib.Tools import javaw
+def apply_scalac(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.env['OUTDIR']=outdir.abspath()
+ self.scalac_task=tsk=self.create_task('scalac')
+ 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
+feature('scalac')(javaw.use_javac_files)
+after('apply_scalac')(javaw.use_javac_files)
+feature('scalac')(javaw.set_classpath)
+after('apply_scalac','use_scalac_files')(javaw.set_classpath)
+SOURCE_RE='**/*.scala'
+class scalac(javaw.javac):
+ color='GREEN'
+ vars=['CLASSPATH','SCALACFLAGS','SCALAC','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(javaw.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
+ self.last_cmd=lst=[]
+ lst.extend(to_list(env['SCALAC']))
+ lst.extend(['-classpath'])
+ lst.extend(to_list(env['CLASSPATH']))
+ lst.extend(['-d'])
+ lst.extend(to_list(env['OUTDIR']))
+ lst.extend(to_list(env['SCALACFLAGS']))
+ lst.extend([a.abspath()for a in self.inputs])
+ lst=[x for x in lst if x]
+ try:
+ self.out=self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None,output=0,quiet=0)[1]
+ except:
+ self.generator.bld.cmd_and_log(lst,cwd=wd,env=env.env or None)
+def configure(self):
+ java_path=self.environ['PATH'].split(os.pathsep)
+ v=self.env
+ if'SCALA_HOME'in self.environ:
+ java_path=[os.path.join(self.environ['SCALA_HOME'],'bin')]+java_path
+ self.env['SCALA_HOME']=[self.environ['SCALA_HOME']]
+ for x in'scalac scala'.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']
+ v.SCALACFLAGS=['-verbose']
+ if not v['SCALAC']:self.fatal('scalac is required for compiling scala classes')
+
+feature('scalac')(apply_scalac)
+before_method('process_source')(apply_scalac)
\ No newline at end of file
diff --git a/waflib/fixpy2.py b/waflib/fixpy2.py
new file mode 100644
index 0000000..b533bb4
--- /dev/null
+++ b/waflib/fixpy2.py
@@ -0,0 +1,50 @@
+#! /usr/bin/env python
+# encoding: utf-8
+# WARNING! All changes made to this file will be lost!
+
+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 --git a/waterfall.c b/waterfall.c
new file mode 100644
index 0000000..4b05385
--- /dev/null
+++ b/waterfall.c
@@ -0,0 +1,612 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ waterfall.c
+ draw the waterfall display, and tuning cursors
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+#include <math.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <gtk/gtk.h>
+
+#include "waterfall.h"
+
+// A bit of a hack to swap x,y arguments around if using vertical orientation,
+// helps avoid a lot of switch statements and having multiple copies of code.
+// Also makes it possible to move the scale bar to the top in horizontal mode.
+#define wf_transpose(x, y) \
+ ((wf->orientation==WF_O_VERTICAL) ? (x) : (y)+SCALE_WIDTH), \
+ ((wf->orientation==WF_O_VERTICAL) ? (y) : wf->width-(x))
+#define wf_swap(x, y) \
+ ((wf->orientation==WF_O_VERTICAL) ? (x) : (y)), \
+ ((wf->orientation==WF_O_VERTICAL) ? (y) : (x))
+#define wf_remap(x, y) \
+ ((wf->orientation==WF_O_VERTICAL) ? (x) : (y)+SCALE_WIDTH), \
+ ((wf->orientation==WF_O_VERTICAL) ? (y) : (x))
+#define wf_rectangle(x, y, xsize, ysize) \
+ wf_transpose((x)+((wf->orientation==WF_O_VERTICAL)?0:(xsize)),y), \
+ ((wf->orientation==WF_O_VERTICAL) ? (xsize) : (ysize)), \
+ ((wf->orientation==WF_O_VERTICAL) ? (ysize) : (xsize)) \
+
+static GtkWidgetClass *parent_class = NULL;
+G_DEFINE_TYPE (SDRWaterfall, sdr_waterfall, GTK_TYPE_DRAWING_AREA);
+
+static gboolean sdr_waterfall_motion_notify (GtkWidget *widget, GdkEventMotion *event);
+static gboolean sdr_waterfall_expose(GtkWidget *widget, GdkEventExpose *event);
+static gboolean sdr_waterfall_button_press(GtkWidget *widget, GdkEventButton *event);
+static gboolean sdr_waterfall_button_release(GtkWidget *widget, GdkEventButton *event);
+static gboolean sdr_waterfall_scroll(GtkWidget *widget, GdkEventScroll *event);
+static void sdr_waterfall_realize(GtkWidget *widget);
+static void sdr_waterfall_unrealize(GtkWidget *widget);
+void sdr_waterfall_set_lowpass(SDRWaterfall *wf, gdouble value);
+void sdr_waterfall_set_highpass(SDRWaterfall *wf, gdouble value);
+
+static void sdr_waterfall_class_init (SDRWaterfallClass *class) {
+ GtkWidgetClass *widget_class = GTK_WIDGET_CLASS(class);
+ GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+ parent_class = gtk_type_class(GTK_TYPE_DRAWING_AREA);
+
+ widget_class->realize = sdr_waterfall_realize;
+ widget_class->unrealize = sdr_waterfall_unrealize; // hate american spelling
+ widget_class->expose_event = sdr_waterfall_expose;
+ widget_class->button_press_event = sdr_waterfall_button_press;
+ widget_class->button_release_event = sdr_waterfall_button_release;
+ widget_class->motion_notify_event = sdr_waterfall_motion_notify;
+ widget_class->scroll_event = sdr_waterfall_scroll;
+
+ g_type_class_add_private (class, sizeof (SDRWaterfallPrivate));
+
+}
+
+static void sdr_waterfall_init (SDRWaterfall *wf) {
+
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ gtk_widget_set_events(GTK_WIDGET(wf), GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
+ priv->prelight = P_NONE;
+ priv->drag = P_NONE;
+ priv->scroll_pos = 0;
+ wf->centre_freq = 0;
+}
+
+void sdr_waterfall_filter_cursors(SDRWaterfall *wf) {
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ gint width = wf->width;
+
+ // FIXME - work out best place to put the enum
+ // FIXME - use accessors for filters rather than gtk_adjustment_get_value
+ switch(wf->mode) {
+ case 0:
+ priv->lp_pos = priv->cursor_pos - (width*(gtk_adjustment_get_value(wf->lp_tune)/wf->sample_rate));
+ priv->hp_pos = priv->cursor_pos - (width*(gtk_adjustment_get_value(wf->hp_tune)/wf->sample_rate));
+ break;
+ case 1:
+ priv->lp_pos = priv->cursor_pos + (width*(gtk_adjustment_get_value(wf->lp_tune)/wf->sample_rate));
+ priv->hp_pos = priv->cursor_pos + (width*(gtk_adjustment_get_value(wf->hp_tune)/wf->sample_rate));
+ break;
+ }
+
+}
+
+static void sdr_waterfall_realize(GtkWidget *widget) {
+ // here we handle things that must happen once the widget has a size
+ SDRWaterfall *wf;
+// GtkAllocation *allocation;
+ cairo_t *cr;
+ gint i, j, scale, width;
+ char s[10];
+
+ g_return_if_fail(SDR_IS_WATERFALL(widget));
+
+ wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+
+ // chain up so we even *have* the size;
+ GTK_WIDGET_CLASS(parent_class)->realize(widget);
+
+ // save width and height to clamp rendering size
+ // this just segfaults
+ //gtk_widget_get_allocation(widget, allocation);
+ //width = allocation->width;
+ //wf->width = width;
+ //wf->wf_height = allocation->height - SCALE_HEIGHT;
+
+ // do it the non-Gtk3-friendly way
+ switch (wf->orientation) {
+ case WF_O_VERTICAL:
+ width = widget->allocation.width;
+ wf->wf_height = widget->allocation.height - SCALE_HEIGHT;
+ break;
+ case WF_O_HORIZONTAL:
+ width = widget->allocation.height;
+ wf->wf_height = widget->allocation.width - SCALE_WIDTH;
+ break;
+ }
+ wf->width = width;
+
+ // FIXME we do this a lot, maybe it should be a function
+ // maybe we don't need it, since we poke the tuning adjustment
+ priv->cursor_pos = width * (0.5+(gtk_adjustment_get_value(wf->tuning)/wf->sample_rate));
+ // FIXME investigate cairo surfaces and speed
+ wf->pixmap = gdk_pixmap_new(gtk_widget_get_window(widget), wf_swap(width, wf->wf_height), -1);
+
+ // clear the waterfall pixmap to black
+ // not sure if there's a better way to do this
+ cr = gdk_cairo_create (wf->pixmap);
+ //cairo_rectangle(cr, 0, 0, wf_remap(width, wf->wf_height));
+ cairo_rectangle(cr, wf_rectangle(0, 0, width, wf->wf_height));
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ cairo_paint(cr);
+ cairo_destroy(cr);
+
+ sdr_waterfall_set_scale(widget, wf->centre_freq);
+
+ g_mutex_init(&priv->mutex);
+ gtk_adjustment_value_changed(wf->tuning);
+}
+
+static void sdr_waterfall_unrealize(GtkWidget *widget) {
+ // ensure that the pixel buffer is freed
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+
+ g_object_unref(wf->pixmap); // we should definitely have a pixmap
+ if (wf->scale) // we might not have a scale
+ g_object_unref(wf->scale);
+
+ g_mutex_clear(&priv->mutex);
+ GTK_WIDGET_CLASS(parent_class)->unrealize(widget);
+}
+
+static void sdr_waterfall_tuning_changed(GtkWidget *widget, gpointer *p) {
+ // if the tuning adjustment changes, ensure the pointer is recalculated
+ SDRWaterfall *wf = SDR_WATERFALL(p);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ int width = wf->width;
+ gdouble value = gtk_adjustment_get_value(wf->tuning); // FIXME - get from *widget?
+ priv->cursor_pos = width * (0.5+(value/wf->sample_rate));
+ // need to update the filter positions too
+ //priv->lp_pos = priv->cursor_pos - (width*(wf->lp_tune->value/wf->sample_rate));
+ //priv->hp_pos = priv->cursor_pos - (width*(wf->hp_tune->value/wf->sample_rate));
+ sdr_waterfall_filter_cursors(wf);
+ gtk_widget_queue_draw(GTK_WIDGET(wf));
+}
+
+static void sdr_waterfall_lowpass_changed(GtkWidget *widget, gpointer *p) {
+ SDRWaterfall *wf = SDR_WATERFALL(p);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ int width = wf->width;
+ gdouble value = gtk_adjustment_get_value(wf->lp_tune);
+ sdr_waterfall_filter_cursors(wf);
+ //priv->lp_pos = priv->cursor_pos - (width*(value/wf->sample_rate));
+ gtk_widget_queue_draw(GTK_WIDGET(wf));
+}
+
+static void sdr_waterfall_highpass_changed(GtkWidget *widget, gpointer *p) {
+ SDRWaterfall *wf = SDR_WATERFALL(p);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ int width = wf->width;
+ gdouble value = gtk_adjustment_get_value(wf->hp_tune);
+ sdr_waterfall_filter_cursors(wf);
+ //priv->hp_pos = priv->cursor_pos - (width*(value/wf->sample_rate));
+ gtk_widget_queue_draw(GTK_WIDGET(wf));
+}
+
+SDRWaterfall *sdr_waterfall_new(GtkAdjustment *tuning, GtkAdjustment *lp_tune, GtkAdjustment *hp_tune, gint sample_rate, gint fft_size) {
+ // call this with three Adjustments, for tuning, lowpass filter and highpass filter
+ // the tuning Adjustment should have its upper and lower bounds set to half the sample rate
+ SDRWaterfall *wf;
+
+ wf = g_object_new(
+ SDR_TYPE_WATERFALL,
+ NULL
+ );
+
+ // assign the GtkAdjustments
+ wf->tuning = tuning;
+ wf->lp_tune = lp_tune;
+ wf->hp_tune = hp_tune;
+ // internal parameters
+ wf->sample_rate = sample_rate;
+ wf->fft_size = fft_size;
+
+ // signals for when the adjustments change
+ g_signal_connect (tuning, "value-changed",
+ G_CALLBACK (sdr_waterfall_tuning_changed), wf);
+ g_signal_connect (lp_tune, "value-changed",
+ G_CALLBACK (sdr_waterfall_lowpass_changed), wf);
+ g_signal_connect (hp_tune, "value-changed",
+ G_CALLBACK (sdr_waterfall_highpass_changed), wf);
+ return wf;
+
+}
+
+void sdr_waterfall_set_scale(GtkWidget *widget, gint centre_freq) {
+ // draw the scale to a handy pixmap
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ gint width = wf->width;
+ cairo_t *cr;
+ gint i, j, scale;
+ gchar s[10];
+
+ wf->centre_freq = centre_freq;
+
+ if (!wf->scale) {
+ switch (wf->orientation) {
+ case WF_O_VERTICAL:
+ wf->scale = gdk_pixmap_new(gtk_widget_get_window(widget), width, SCALE_HEIGHT, -1);
+ break;
+ case WF_O_HORIZONTAL:
+ wf->scale = gdk_pixmap_new(gtk_widget_get_window(widget), SCALE_WIDTH, width, -1);
+ break;
+ }
+ }
+
+ cr = gdk_cairo_create(wf->scale);
+ switch (wf->orientation) {
+ case WF_O_VERTICAL:
+ cairo_rectangle(cr, 0, 0, width, SCALE_HEIGHT);
+ cairo_clip(cr);
+
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ cairo_paint(cr);
+ cairo_set_source_rgb(cr, 1, 0, 0);
+ cairo_move_to(cr, 0, 0);
+ cairo_line_to(cr, width, 0);
+ cairo_stroke(cr);
+ cairo_set_line_width(cr, 1);
+
+ scale = (trunc(wf->sample_rate/SCALE_TICK)+1)*SCALE_TICK;
+
+ for (i=-scale; i<scale; i+=SCALE_TICK) { // FIXME hardcoded
+ j = width * (0.5+((double)i/wf->sample_rate));
+ cairo_set_source_rgb(cr, 1, 0, 0);
+ cairo_move_to(cr, 0.5+j, 0);
+ cairo_line_to(cr, 0.5+j, 8);
+ cairo_stroke(cr);
+ cairo_move_to(cr, j-10, 18);
+ cairo_set_source_rgb(cr, .75, .75, .75);
+ sprintf(s, "%4.3f", (wf->centre_freq/1000000.0f)+(i/1000000.0f));
+ cairo_show_text(cr,s);
+ }
+ break;
+ case WF_O_HORIZONTAL:
+ cairo_rectangle(cr, 0, 0, SCALE_WIDTH, width);
+ cairo_clip(cr);
+
+ cairo_set_source_rgb(cr, 0, 0, 0);
+ cairo_paint(cr);
+ cairo_set_source_rgb(cr, 1, 0, 0);
+ cairo_move_to(cr, 0, 0);
+ cairo_line_to(cr, 0, width);
+ cairo_stroke(cr);
+ cairo_set_line_width(cr, 1);
+
+ scale = (trunc(wf->sample_rate/SCALE_TICK)+1)*SCALE_TICK;
+
+ for (i=-scale; i<scale; i+=SCALE_TICK) { // FIXME hardcoded
+ j = width * (0.5+((double)i/wf->sample_rate));
+ cairo_set_source_rgb(cr, 1, 0, 0);
+ cairo_move_to(cr, 0, j);
+ cairo_line_to(cr, 8, j);
+ cairo_stroke(cr);
+ cairo_move_to(cr, 12, j+4);
+ cairo_set_source_rgb(cr, .75, .75, .75);
+ sprintf(s, "%4.3f", (wf->centre_freq/1000000.0f)+(i/1000000.0f));
+ cairo_show_text(cr,s);
+ }
+ break;
+ }
+ cairo_destroy(cr);
+
+}
+
+static gboolean sdr_waterfall_motion_notify (GtkWidget *widget, GdkEventMotion *event) {
+
+ gint prelight = P_NONE;
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+
+ gdouble value;
+ gint offset;
+ gboolean dirty = FALSE;
+
+ gint width = wf->width;
+ gint x = CLAMP((wf->orientation == WF_O_VERTICAL) ? event->x : (wf->width-event->y), 0, width);
+ if (priv->drag == P_NONE) {
+ if (WITHIN(x, priv->cursor_pos)) {
+ prelight = P_TUNING;
+ dirty = TRUE;
+ }
+ if (WITHIN(x, priv->lp_pos)) {
+ prelight = P_LOWPASS;
+ dirty = TRUE;
+ }
+ if (WITHIN(x, priv->hp_pos)) {
+ prelight = P_HIGHPASS;
+ dirty = TRUE;
+ }
+ }
+ if (priv->drag == P_TUNING) {
+ // drag cursor to tune
+ value = ((float)x/width-0.5)*wf->sample_rate;
+ sdr_waterfall_set_tuning(wf, value);
+ prelight = P_TUNING;
+ dirty = TRUE;
+ }
+
+ if (priv->drag == P_BANDSPREAD) {
+ // right-drag for fine tuning (1Hz steps)
+ offset = x - priv->click_pos;
+ value = priv->bandspread + (float)offset;
+ sdr_waterfall_set_tuning(wf, value);
+ prelight = P_TUNING;
+ dirty = TRUE;
+ }
+
+ if (priv->drag == P_LOWPASS) {
+ if (wf->mode == 0) {
+ offset = priv->cursor_pos - x;
+ } else {
+ offset = x - priv->cursor_pos;
+ }
+ value = ((float)offset/width)*wf->sample_rate;
+ sdr_waterfall_set_lowpass(wf, (float)value);
+ prelight = P_LOWPASS;
+ }
+
+ if (priv->drag == P_HIGHPASS) {
+ if (wf->mode == 0) {
+ offset = priv->cursor_pos - x;
+ } else {
+ offset = x - priv->cursor_pos;
+ }
+ value = ((float)offset/width)*wf->sample_rate;
+ sdr_waterfall_set_highpass(wf, (float)value);
+ prelight = P_HIGHPASS;
+ }
+
+ // redraw if the prelight has changed
+ if (prelight != priv->prelight) {
+ dirty = TRUE;
+ }
+ if (dirty) {
+ gtk_widget_queue_draw(widget);
+ priv->prelight = prelight;
+ }
+ return TRUE;
+}
+
+static gboolean sdr_waterfall_button_press(GtkWidget *widget, GdkEventButton *event) {
+ // detect button presses
+ // there are four distinct cases to check for
+ // click off the whole cursor = jump tuning
+ // click on the cursor bounding box but not on a cursor = do nothing but allow drag
+ // click on cursor hairline = allow drag (done)
+ // right-click = bandspread (done)
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ gint x = (wf->orientation == WF_O_VERTICAL) ? event->x : (wf->width-event->y);
+ switch (event->button) {
+ case 1:
+ // clicking off the cursor should jump the tuning to wherever we clicked
+ if (priv->prelight == P_NONE) {
+ priv->prelight = P_TUNING;
+ sdr_waterfall_set_tuning(wf, ((float)x/wf->width-0.5)*wf->sample_rate);
+ }
+ priv->drag = priv->prelight; // maybe the cursor is on something
+ priv->click_pos = x;
+ break;
+ case 3:
+ // right-click for bandspread tuning
+ priv->prelight = P_TUNING;
+ priv->drag = P_BANDSPREAD;
+ priv->click_pos = x;
+ priv->bandspread = gtk_adjustment_get_value(wf->tuning);
+ gtk_widget_queue_draw(widget);
+ break;
+ }
+ return TRUE;
+}
+
+static gboolean sdr_waterfall_button_release(GtkWidget *widget, GdkEventButton *event) {
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ priv->click_pos=0;
+ if (priv->drag == P_BANDSPREAD) {
+ priv->prelight = P_NONE;
+ gtk_widget_queue_draw(widget);
+ }
+ priv->drag = P_NONE;
+ return FALSE;
+}
+
+static gboolean sdr_waterfall_scroll(GtkWidget *widget, GdkEventScroll *event) {
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ float tuning = gtk_adjustment_get_value(wf->tuning);
+ float step;
+
+ if (event->state & GDK_MOD1_MASK) {
+ step = 10000.0;
+ } else if (event->state & GDK_SHIFT_MASK) {
+ step = 1000.0;
+ } else {
+ step = 100.0;
+ }
+
+ if (wf->orientation == WF_O_HORIZONTAL)
+ step = -step;
+
+ switch (event->direction) {
+ case GDK_SCROLL_UP:
+ tuning -= step;
+ break;
+ case GDK_SCROLL_DOWN:
+ tuning += step;
+ break;
+ default:
+ break;
+ }
+
+ sdr_waterfall_set_tuning(wf, tuning);
+
+ return FALSE;
+}
+
+static gboolean sdr_waterfall_expose(GtkWidget *widget, GdkEventExpose *event) {
+
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+ int width = wf->width;
+ int height = wf->wf_height;
+ int cursor;
+
+ cairo_t *cr = gdk_cairo_create (gtk_widget_get_window(widget));
+
+ if (wf->scale) { // might not have a scale
+ switch (wf->orientation) {
+ case WF_O_VERTICAL:
+ gdk_cairo_set_source_pixmap(cr, wf->scale, 0, height);
+ break;
+ case WF_O_HORIZONTAL:
+ gdk_cairo_set_source_pixmap(cr, wf->scale, 0, 0);
+ break;
+ }
+ cairo_paint(cr);
+ }
+
+ // clip region is waterfall size
+ cairo_rectangle(cr, wf_rectangle(0, 0, width, height));
+ cairo_clip(cr);
+
+ g_mutex_lock(&priv->mutex);
+ gdk_cairo_set_source_pixmap(cr, wf->pixmap, wf_remap(0, -priv->scroll_pos));
+ cairo_paint(cr);
+ gdk_cairo_set_source_pixmap(cr, wf->pixmap, wf_remap(0, height-priv->scroll_pos));
+ cairo_paint(cr);
+ g_mutex_unlock(&priv->mutex);
+
+ // cursor is translucent when "off", opaque when prelit
+ cursor = priv->cursor_pos;
+ if (priv->prelight == P_TUNING) {
+ cairo_set_source_rgba(cr, 1, 0, 0, 1); // red for cursor
+ } else {
+ cairo_set_source_rgba(cr, 1, 0, 0, 0.5); // red for cursor
+ }
+ cairo_set_line_width(cr, 2);
+ cairo_move_to(cr, wf_transpose(0.5f+cursor, 0)); // must be offset by a half-pixel for a single line
+ cairo_line_to(cr, wf_transpose(0.5f+cursor, height));
+ cairo_stroke(cr);
+
+ // filter cursor
+ cairo_set_source_rgba(cr, 0.5, 0.5, 0, 0.25);
+ cairo_rectangle(cr,
+ wf_rectangle(MIN(priv->hp_pos, priv->lp_pos), 0,
+ abs(priv->lp_pos - priv->hp_pos), height));
+ cairo_fill(cr);
+
+ // side rails
+ // lowpass
+ cairo_set_line_width(cr, 1);
+ if (priv->prelight == P_LOWPASS) {
+ cairo_set_source_rgba(cr, 1, 1, 0.5, 0.75);
+ } else {
+ cairo_set_source_rgba(cr, 1, 1, 0.5, 0.25);
+
+ }
+
+ cairo_move_to(cr, wf_transpose(0.5 + priv->lp_pos, 0));
+ cairo_line_to(cr, wf_transpose(0.5 + priv->lp_pos, height));
+ cairo_stroke(cr);
+
+ // highpass
+ if (priv->prelight == P_HIGHPASS) {
+ cairo_set_source_rgba(cr, 1, 1, 0.5, 0.75);
+ } else {
+ cairo_set_source_rgba(cr, 1, 1, 0.5, 0.25);
+ }
+ cairo_move_to(cr, wf_transpose(0.5 + priv->hp_pos-1, 0));
+ cairo_line_to(cr, wf_transpose(0.5 + priv->hp_pos-1, height));
+ cairo_stroke(cr);
+
+ cairo_destroy (cr);
+
+ return FALSE;
+}
+
+void sdr_waterfall_update(GtkWidget *widget, guchar *row) {
+ // bang a bunch of pixels onto the current row, update and wrap if need be
+ SDRWaterfall *wf = SDR_WATERFALL(widget);
+ SDRWaterfallPrivate *priv = SDR_WATERFALL_GET_PRIVATE(wf);
+
+ //return;
+ cairo_t *cr = gdk_cairo_create (wf->pixmap);
+ cairo_surface_t *s_row = cairo_image_surface_create_for_data (
+ row,
+ CAIRO_FORMAT_RGB24,
+ wf_swap(wf->fft_size, 1),
+ (wf->orientation == WF_O_VERTICAL) ? (4*wf->fft_size) : 4
+ );
+
+ g_mutex_lock(&priv->mutex);
+ switch (wf->orientation) {
+ case WF_O_VERTICAL:
+ cairo_set_source_surface (cr, s_row, 0, priv->scroll_pos);
+ break;
+ case WF_O_HORIZONTAL:
+ cairo_set_source_surface (cr, s_row, priv->scroll_pos, 0);
+ break;
+ }
+ cairo_paint(cr);
+ g_mutex_unlock(&priv->mutex);
+
+ priv->scroll_pos++;
+ if (priv->scroll_pos >= wf->wf_height) priv->scroll_pos = 0;
+
+ cairo_surface_destroy(s_row);
+ cairo_destroy(cr);
+ gtk_widget_queue_draw(widget);
+
+}
+
+/* accessor functions */
+float sdr_waterfall_get_tuning(SDRWaterfall *wf) {
+ return gtk_adjustment_get_value(wf->tuning);
+}
+float sdr_waterfall_get_lowpass(SDRWaterfall *wf) {
+ return gtk_adjustment_get_value(wf->lp_tune);
+}
+float sdr_waterfall_get_highpass(SDRWaterfall *wf) {
+ return gtk_adjustment_get_value(wf->hp_tune);
+}
+
+void sdr_waterfall_set_tuning(SDRWaterfall *wf, gdouble value) {
+ gtk_adjustment_set_value(wf->tuning, value);
+}
+
+void sdr_waterfall_set_lowpass(SDRWaterfall *wf, gdouble value) {
+ gtk_adjustment_set_value(wf->lp_tune, value);
+ gtk_adjustment_set_upper(wf->hp_tune, value);
+}
+void sdr_waterfall_set_highpass(SDRWaterfall *wf, gdouble value) {
+ gtk_adjustment_set_value(wf->hp_tune, value);
+ gtk_adjustment_set_lower(wf->lp_tune, value);
+}
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/waterfall.h b/waterfall.h
new file mode 100644
index 0000000..276ab4f
--- /dev/null
+++ b/waterfall.h
@@ -0,0 +1,117 @@
+/* lysdr Software Defined Radio
+ (C) 2010-2011 Gordon JC Pearce MM0YEQ and others
+
+ waterfall.h
+
+ This file is part of lysdr.
+
+ lysdr is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 2 of the License, or
+ any later version.
+
+ lysdr is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with lysdr. If not, see <http://www.gnu.org/licenses/>.
+*/
+
+
+
+#ifndef __WATERFALL_H
+#define __WATERFALL_H
+
+#include <gtk/gtk.h>
+
+G_BEGIN_DECLS
+
+typedef struct _SDRWaterfall SDRWaterfall;
+typedef struct _SDRWaterfallClass SDRWaterfallClass;
+typedef struct _SDRWaterfallPrivate SDRWaterfallPrivate;
+
+enum {
+ P_NONE,
+ P_TUNING,
+ P_HIGHPASS,
+ P_LOWPASS,
+ P_BANDSPREAD
+};
+
+enum {
+ WF_O_VERTICAL,
+ WF_O_HORIZONTAL
+};
+
+struct _SDRWaterfall {
+ GtkDrawingArea parent;
+
+ GtkAdjustment *tuning;
+ GtkAdjustment *lp_tune;
+ GtkAdjustment *hp_tune;
+
+ GdkPixmap *pixmap;
+ GdkPixmap *scale;
+ cairo_surface_t *pix;
+
+ gint mode;
+ gint orientation;
+
+ gint width;
+ gint wf_height;
+
+ gint sample_rate;
+ gint centre_freq;
+ gint fft_size;
+};
+
+struct _SDRWaterfallClass {
+ GtkDrawingAreaClass parent_class;
+};
+
+struct _SDRWaterfallPrivate {
+ gint cursor_pos; // pixel position for tuning cursor
+ gint lp_pos; // pixel position for lowpass cursor
+ gint hp_pos; // pixel position for highpass cursor
+ gint scroll_pos; // which line the scroller is on
+ gint prelight;
+ gint drag;
+ gint click_pos;
+ gdouble bandspread;
+ GMutex mutex;
+};
+
+#define SDR_TYPE_WATERFALL (sdr_waterfall_get_type ())
+#define SDR_WATERFALL(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SDR_TYPE_WATERFALL, SDRWaterfall))
+#define SDR_WATERFALL_CLASS(obj) (G_TYPE_CHECK_CLASS_CAST ((obj), SDR_WATERFALL, SDRWaterfallClass))
+#define SDR_IS_WATERFALL(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SDR_TYPE_WATERFALL))
+#define SDR_IS_WATERFALL_CLASS(obj) (G_TYPE_CHECK_CLASS_TYPE ((obj), SDR_TYPE_WATERFALL))
+#define SDR_WATERFALL_GET_CLASS (G_TYPE_INSTANCE_GET_CLASS ((obj), SDR_TYPE_WATERFALL, SDRWaterfallClass))
+#define SDR_WATERFALL_GET_PRIVATE(obj) (G_TYPE_INSTANCE_GET_PRIVATE ((obj), SDR_TYPE_WATERFALL, SDRWaterfallPrivate))
+
+G_END_DECLS
+
+#define LOOSE 2
+#define WITHIN(x, p) (x-1 > p-LOOSE) && (x-1 < p + LOOSE)
+
+#define SCALE_HEIGHT 24
+#define SCALE_WIDTH 50
+#define SCALE_TICK 5000
+
+SDRWaterfall *sdr_waterfall_new(GtkAdjustment *tuning, GtkAdjustment *lp_tune, GtkAdjustment *hp_tune, gint sample_rate, gint fft_size);
+float sdr_waterfall_get_tuning(SDRWaterfall *wf);
+float sdr_waterfall_get_lowpass(SDRWaterfall *wf);
+float sdr_waterfall_get_highpass(SDRWaterfall *wf);
+
+void sdr_waterfall_set_tuning(SDRWaterfall *wf, gdouble value);
+void sdr_waterfall_update(GtkWidget *widget, guchar *row);
+void sdr_waterfall_set_scale(GtkWidget *widget, gint centre_freq);
+void sdr_waterfall_filter_cursors(SDRWaterfall *wf);
+void sdr_waterfall_set_lowpass(SDRWaterfall *wf, gdouble value);
+void sdr_waterfall_set_highpass(SDRWaterfall *wf, gdouble value);
+GType sdr_waterfall_get_type(void);
+#endif /* __WATERFALL_H */
+
+/* vim: set noexpandtab ai ts=4 sw=4 tw=4: */
diff --git a/wscript b/wscript
new file mode 100644
index 0000000..3d07ec1
--- /dev/null
+++ b/wscript
@@ -0,0 +1,38 @@
+#! /usr/bin/env python
+
+# the following two variables are used by the target "waf dist"
+VERSION='0.0.6'
+APPNAME='lysdr'
+
+# these variables are mandatory ('/' are converted automatically)
+top = '.'
+out = 'build'
+
+def options(opt):
+ opt.tool_options('compiler_cc')
+
+def configure(conf):
+ conf.check_tool('compiler_cc')
+ conf.check(header_name='stdlib.h')
+ conf.check(header_name='math.h')
+
+ # set for debugging
+ conf.env.CCFLAGS = ['-O0', '-g3', '-ggdb']
+ #conf.env.CCFLAGS += ['-DG_DISABLE_SINGLE_INCLUDES','-DGDK_PIXBUF_DISABLE_SINGLE_INCLUDES', '-DGTK_DISABLE_SINGLE_INCLUDES']
+ #conf.env.CCFLAGS += ["-DG_DISABLE_DEPRECATED -DGDK_PIXBUF_DISABLE_DEPRECATED -DGDK_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED"]
+ #conf.env.CCFLAGS += ["-DGSEAL_ENABLE"]
+
+ conf.check_cfg(package='gtk+-2.0', uselib_store='GTK', atleast_version='2.6.0', mandatory=True, args='--cflags --libs')
+ conf.check_cfg(package = 'jack', uselib_store='JACK', atleast_version = '0.118.0', mandatory=True, args = '--cflags --libs')
+ conf.check_cfg(package = 'fftw3', uselib_store='FFTW', atleast_version = '3.2.2', mandatory=True, args = '--cflags --libs')
+ conf.check(lib=['m'], uselib_store='M')
+
+def build(bld):
+ # the main program
+ bld(
+ features = 'c cprogram',
+ source = ['lysdr.c', 'sdr.c', 'filter.c', 'audio_jack.c', 'gui.c', 'smeter.c', 'waterfall.c'],
+ target = 'lysdr',
+ uselib = "GTK JACK FFTW M",
+ includes = '. /usr/include ./waterfall')
+
--
Alioth's /usr/local/bin/git-commit-notice on /srv/git.debian.org/git/pkg-hamradio/lysdr.git
More information about the pkg-hamradio-commits
mailing list