+++ /dev/null
-Maintainers:
-Murray Cumming <murrayc@usa.net>
+++ /dev/null
- GNU LESSER GENERAL PUBLIC LICENSE
- Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL. It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
- Preamble
-
- The licenses for most software are designed to take away your
-freedom to share and change it. By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
- This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it. You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
- When we speak of free software, we are referring to freedom of use,
-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 this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
- To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights. These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
- For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you. You must make sure that they, too, receive or can get the source
-code. If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it. And you must show them these terms so they know their rights.
-
- We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
- To protect each distributor, we want to make it very clear that
-there is no warranty for the free library. Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-\f
- Finally, software patents pose a constant threat to the existence of
-any free program. We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder. Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
- Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License. This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License. We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
- When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library. The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom. The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
- We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License. It also provides other free software developers Less
-of an advantage over competing non-free programs. These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries. However, the Lesser license provides advantages in certain
-special circumstances.
-
- For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard. To achieve this, non-free programs must be
-allowed to use the library. A more frequent case is that a free
-library does the same job as widely used non-free libraries. In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
- In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software. For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
- Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
- The precise terms and conditions for copying, distribution and
-modification follow. Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library". The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-\f
- GNU LESSER GENERAL PUBLIC LICENSE
- TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
- 0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
- A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
- The "Library", below, refers to any such software library or work
-which has been distributed under these terms. A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language. (Hereinafter, translation is
-included without limitation in the term "modification".)
-
- "Source code" for a work means the preferred form of the work for
-making modifications to it. For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
- Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope. The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it). Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
- 1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
- You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-\f
- 2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
- a) The modified work must itself be a software library.
-
- b) You must cause the files modified to carry prominent notices
- stating that you changed the files and the date of any change.
-
- c) You must cause the whole of the work to be licensed at no
- charge to all third parties under the terms of this License.
-
- d) If a facility in the modified Library refers to a function or a
- table of data to be supplied by an application program that uses
- the facility, other than as an argument passed when the facility
- is invoked, then you must make a good faith effort to ensure that,
- in the event an application does not supply such function or
- table, the facility still operates, and performs whatever part of
- its purpose remains meaningful.
-
- (For example, a function in a library to compute square roots has
- a purpose that is entirely well-defined independent of the
- application. Therefore, Subsection 2d requires that any
- application-supplied function or table used by this function must
- be optional: if the application does not supply it, the square
- root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole. If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works. But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
- 3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library. To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License. (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.) Do not make any other change in
-these notices.
-\f
- Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
- This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
- 4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
- If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
- 5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library". Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
- However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library". The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
- When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library. The
-threshold for this to be true is not precisely defined by law.
-
- If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work. (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
- Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-\f
- 6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
- You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License. You must supply a copy of this License. If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License. Also, you must do one
-of these things:
-
- a) Accompany the work with the complete corresponding
- machine-readable source code for the Library including whatever
- changes were used in the work (which must be distributed under
- Sections 1 and 2 above); and, if the work is an executable linked
- with the Library, with the complete machine-readable "work that
- uses the Library", as object code and/or source code, so that the
- user can modify the Library and then relink to produce a modified
- executable containing the modified Library. (It is understood
- that the user who changes the contents of definitions files in the
- Library will not necessarily be able to recompile the application
- to use the modified definitions.)
-
- b) Use a suitable shared library mechanism for linking with the
- Library. A suitable mechanism is one that (1) uses at run time a
- copy of the library already present on the user's computer system,
- rather than copying library functions into the executable, and (2)
- will operate properly with a modified version of the library, if
- the user installs one, as long as the modified version is
- interface-compatible with the version that the work was made with.
-
- c) Accompany the work with a written offer, valid for at
- least three years, to give the same user the materials
- specified in Subsection 6a, above, for a charge no more
- than the cost of performing this distribution.
-
- d) If distribution of the work is made by offering access to copy
- from a designated place, offer equivalent access to copy the above
- specified materials from the same place.
-
- e) Verify that the user has already received a copy of these
- materials or that you have already sent this user a copy.
-
- For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it. However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
- It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system. Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-\f
- 7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
- a) Accompany the combined library with a copy of the same work
- based on the Library, uncombined with any other library
- facilities. This must be distributed under the terms of the
- Sections above.
-
- b) Give prominent notice with the combined library of the fact
- that part of it is a work based on the Library, and explaining
- where to find the accompanying uncombined form of the same work.
-
- 8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License. Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License. However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
- 9. You are not required to accept this License, since you have not
-signed it. However, nothing else grants you permission to modify or
-distribute the Library or its derivative works. These actions are
-prohibited by law if you do not accept this License. Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
- 10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions. You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-\f
- 11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-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
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all. For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices. Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
- 12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded. In such case, this License incorporates the limitation as if
-written in the body of this License.
-
- 13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser 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 Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation. If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-\f
- 14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission. For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this. Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
- NO WARRANTY
-
- 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "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
-LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
- 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY 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
-LIBRARY (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 LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
- END OF TERMS AND CONDITIONS
-\f
- How to Apply These Terms to Your New Libraries
-
- If you develop a new library, and you want it to be of the greatest
-possible use to the public, we recommend making it free software that
-everyone can redistribute and change. You can do so by permitting
-redistribution under these terms (or, alternatively, under the terms of the
-ordinary General Public License).
-
- To apply these terms, attach the following notices to the library. It is
-safest to attach them to the start of each source file to most effectively
-convey 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 library's name and a brief idea of what it does.>
- Copyright (C) <year> <name of author>
-
- This library is free software; you can redistribute it and/or
- modify it under the terms of the GNU Lesser General Public
- License as published by the Free Software Foundation; either
- version 2.1 of the License, or (at your option) any later version.
-
- This library 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
- Lesser General Public License for more details.
-
- You should have received a copy of the GNU Lesser General Public
- License along with this library; if not, write to the Free Software
- Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-
-Also add information on how to contact you by electronic and paper mail.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the library, if
-necessary. Here is a sample; alter the names:
-
- Yoyodyne, Inc., hereby disclaims all copyright interest in the
- library `Frob' (a library for tweaking knobs) written by James Random Hacker.
-
- <signature of Ty Coon>, 1 April 1990
- Ty Coon, President of Vice
-
-That's all there is to it!
-
-
+++ /dev/null
-2.6.1:
-
-2005-09-07 Murray Cumming <murrayc@murrayc.com>
-
- * NEWS: Updated.
- * configure.in: Increased version.
-
-2005-03-10 Cedric Gustin <cedric.gustin@swing.be>
-
- * MSVC_Net2003/Makefile.am: Add blank.cpp to EXTRA_DIST.
- * MSVC_Net2003/libglademm/libglademm.vcproj: Disable warning #4250.
- * MSVC_Net2003/examples/*/*.vcproj: Change name of
- PDB file to $(OutDir)/$(TargetName).pdb. Disable warning #4250.
-
-2.6.0:
-
-2005-01-24 Cedric Gustin <cedric.gustin@swing.be>
-
- * MSVC_Net2003/libglademm/Makefile.am: Rewrote rule for local copy
- of glibmmconfig.h (required for 'make distcheck').
- * MSVC_Net2003/libglademm/libglademm.vcproj: Removed GLIBMM_BUILD
- macro.
-
-2.5.1:
-
-2005-01-11 Murray Cumming <murrayc@murrayc.com>
-
- * MSVC_Net2003/libglademm/Makefile.am: Add libglademmconfig.h to
- DISTCLEANFILES, to fix the distcheck.
-
-2004-12-13 Cedric Gustin <cedric.gustin@swing.be>
-
- * configure.in : parse version tags at configure time (for
- libglademm-2.4.rc).
- * MSVC_Net2003/libglademm/libglademm-2.4.rc.in : New resource file.
- * MSVC_Net2003/libglademm/Makefile.am: Include libglademm-2.4.rc
- in distribution.
- * MSVC_Net2003/libglademm/libglademm.vcproj: Added resource file.
-
-2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
-
- * MSVC_Net2003/: Initial release.
- * configure.in: Added MSVC_Net2003 Makefiles.
- * Makefile.am: Added MSVC_Net2003 subdir.
-
-2004-08-28 Alberto Paro <alberto@paro.homeunix.org>
-
- * libglade/xml.{ccg|hg}: Added connect_clicked() for easy connection of
- buttons and menuitems signals to a signal handler.
- * libglade/variablesmap.[ccg|hg]: Glade::VariablesMap now handles
- Entry, ComboTextEntry, SpinButton, *Scale, Calendar and CheckBox.
- * example/variablesmap: Improved the example to handle new
- VariablesMap types.
-
-2004-09-19 Murray Cumming <murrayc@murrayc.com>
-
- * This is the HEAD branch.
-
-2004-09-19 Murray Cumming <murrayc@murrayc.com>
-
- * libglademm/xml.hg: Fix from Denis Leroy in bug #151872.
-
-2.4.1:
-
-2004-06-02 Bryan Forbes <bryan@reigndropsfall.net>
-
- * examples/derived/deriveddialog.h: fix to compile with gcc 3.4.0.
-
-2.4.0:
-
-2.3.3:
-
-2004-03-28 <jdhall@uiuc.edu>
-
- * libglade/xml.hg: Check the return value of get_cwidget().
-
-2004-03-18 Murray Cumming <murrayc@murrayc.com>
-
- * docs/reference/Makefile.am: Removed make target dependency on
- installed beautify_docs, so it does not try to rebuild them when
- building from a tarball. Bug #137548 from Dalgoda.
-
-2004-03-15 Cedric Gustin <cedric.gustin@swing.be>
-
- * tools/m4/Makefile.am: install m4 files in libglademm-2.4 subdir
- instead of libglademm-2.0.
-
-2004-03-15 Cedric Gustin <cedric.gustin@swing.be>
-
- * configure.in: Added test for struct packing convention on win32
- (-mms-bitfields / -fnative-struct).
-
-2004-03-12 Murray Cumming <murrayc@murrayc.com>
-
- * libglade/src/xml.hg: get_widget_derived(): actually return the
- existing widget when a wrapper instance already exists. Bug #136913
- from Roger Whinlatter who submitted it to debian but should have
- submitted it to bugzilla.gnome.org first.
-
-2.3.2:
-
-2004-02-13 Murray Cumming <murrayc@murrayc.com>
-
- * Updated for latest libsigc++ 2 API.
-
-2.3.1:
-
-2003-12-31 Murray Cumming <murrayc@usa.net>
-
- * docs/reference/Makefile.am: Generate a real devhelp file. Added
- a doxygen_to_devhelp.xsl file for this, by copying it from gtkmm and
- modifying it.
-
-2003-12-29 Murray Cumming <murrayc@usa.net>
-
- * configure.in: Use glibmm_check_perl() m4 macro installed by glibmm,
- so that doxygen can know the PERL_PATH.
- * docs/reference/Makefile.am: Added the docs rules from the same
- file in gtkmm, so that the docs are built and distributed and installed
- and uploaded.
-
-2003-12-22 Murray Cumming <murrayc@usa.net>
-
- * docs/reference/Makefile.am: Use beautify_docs.pl installed from
- glibmm 2.4.
-
-2.3.0:
-
-2003-12-07 Murray Cumming <murrayc@usa.net>
-
- * examples/menus/example.glade: Corrected the text. Patch by
- Billy O'Connor in bug 128683.
-
-2003-11-29 Murray Cumming <murrayc@usa.net>
-
- * libglade/libglade-2.0.pc.in: Corrected library name.
-
-2003-11-06 Cedric Gustin <cedric.gustin@swing.be>
-
- * configure.in: Added test of win32 platform. Commented
- out AM_DISABLE_SHARED (DLLs are shared libraries).
- * build_shared/Makefile_build.am_fragment: added a few LDFLAGS
- for win32 DLLs (defined in win32_dlls_ldflags and appended to
- common_ldflags).
-
-2003-11-06 Murray Cumming <murrayc@usa.net>
-
- * Added examples/menus.
- * examples/basic: Added and distributed basic.gladep which is
- necessary to prevent glade-2 from creating libgnomeui menus.
-
-2003-11-02 Murray Cumming <murrayc@usa.net>
-
- * This is now libglademm 2.4, which builds against gtkmm 2.4, and is
- parallel-installable with libglademm 2.0/2.2.
-
-This is HEAD, for GNOME 2.6, using gtkmm 2.4.
-
-2003-10-30 Murray Cumming <murrayc@usa.net>
-
- * libglade/libglademm.h: Include gtkmmconfig.h rather than
- libgnomemmconfig.h. These are platform-specific stuff. I am
- surprised that it built before, because this does not depend
- on libgnomemm at all.
-
-2003-10-17 Alberto Paro <alberto@paro.homeunix.org>
-
- * docs/reference/Doxyfile.in: fixed docs generation
-
-2.1.2:
-
-2003-09-25 Eric Bourque <ericb@computer.org>
-
- * libglademm.spec.in: new file
-
-2003-09-02 Murray Cumming <murrayc@usa.net>
-
- * libglademm/src/xml.hg: Added code to get_widget_derived(),
- to return an existing C++ instance if one exists. This makes
- get_widget_derived() always return the same instance, like
- get_widget() already does. I added some more explicit explanation
- to the gtkmm book about this.
-
-2.1.1:
-
-2003-09-01 Murray Cumming <murrayc@usa.net>
-
- * Just rebuilt the tarball. Some corruption was causing the
- .la files to not be installed.
-
-2.1.0:
-
-2003-08-23 Murray Cumming <murrayc@usa.net>
-
- * libglademm/src/xml.[hg|ccg]: Added
- Glade::Xml::get_widget_derived() templated method.
- * Added examples/derived/ to demonstrate it. This allows you
- to encapsulate the handling of the child widgets inside the
- container widget's code.
- * Makefile.am: Added examples to SUBDIRS so that they are built
- by default, for regression testing.
- * examples/Makefile.am_fragment: Added top_srcdir include for
- distcheck.
-
-2.0.0:
-
-2002-12-20 Daniel Elstner <daniel.elstner@gmx.net>
-
- * examples/basic/basic.cc (main): Exit the program if loading
- the glade file failed, so that it won't segfault.
-
-2002-12-20 Murray Cumming <murrayc@usa.net>
-
- * _IGNORE()ed some internal libglade functions.
-
-2002-12-20 Murray Cumming <murrayc@usa.net>
-
- * examples/basic/basic.cc: Used try/catch to catch the new XmlError
- exception. Added some comments.
-
-2002-12-20 Daniel Elstner <daniel.elstner@gmx.net>
-
- * libglade/src/xml.{ccg,hg} (XmlError): New exception class.
- (Xml::Xml): Throw an XmlError exception if glade_xml_construct()
- or glade_xml_create_from_buffer() failed.
-
-2002-12-16 Daniel Elstner <daniel.elstner@gmx.net>
-
- * libglade/src/xml.{ccg,hg} (Xml::Xml): In order to reduce code
- size, replace the ctor overloads with a single ctor and default
- arguments, and treat empty strings as 0. Also, use std::string
- instead of Glib::ustring for the filename argument.
- (Xml::Xml): Add ctor overload for glade_xml_new_from_buffer().
- We should use a construct() function instead but that requires
- an API addition to libglade.
- (Xml::create): Use std::string for the filename argument, and
- reduce code by using default arguments instead of 3 overloads.
- (Xml::create_from_buffer): Take a plain const char* for the buffer
- argument, plus an int for its size. We already need to do this
- for the ctor to avoid overload ambiguities, and I don't see much
- of a point in providing an additional create_from_buffer() overload
- since it's rarely used.
- (Xml::get_widget_checked): New internal method that checks the
- type of the widget and prints a warning on failure.
- (Xml::get_widget): Move most of the code into the non-templated
- method get_widget_checked(), to reduce binary size.
- (Xml::relative_file): Take and return std::string, since it's
- a filename.
- (Xml::get_filename): New accessor to public struct data member.
- (Xml::get_widget_name): Add.
- (Xml::glade_get_widget_tree): Add.
-
- * tools/m4/convert_libglademm.m4: Add conversion from GladeXML*
- to Glib::RefPtr<Xml>.
-
-2002-12-16 Murray Cumming <murrayc@usa.net>
-
- * src/xml.hg: reparent_widget() is no longer virtual.
-
-2002-12-16 Murray Cumming <murrayc@usa.net>
-
- * src/xml.[hg|ccg]: Renamed lookup_type() to lookup_type_vfunc(), to
- be consistent with other gtkmm vfuncs, and made it virtual.
-
-2002-12-12 Murray Cumming <murrayc@usa.net>
-
- * configure.in: Increased version from 1.3.x to 2.0
- * libglademm/libglademm/Makefile.am: Changed librarary name.
- * libglademm/*.pc.in: Changed library name.
- * examples/Makefile.am_fragment: Changed library name.
-
-2002-12-10 Bradley Bell <btb@debian.org>
-
- * scripts/Makefile.am: distribute macros.m4
-
-1.3.5:
- * Updated for gtkmm2.
-
-1.3.4:
-
-2002-08-07 Murray Cumming <murrayc@usa.net>
-
- * Glade::Xml now uses the new gtkmm _CONSTRUCT macro, so it uses
- the correct Glib::Object constructor.
-
-2002-08-06 Martin Schulze <MHL.Schulze@t-online.de>
-
- * examples/basic/Makefile.am: Replace 'example' with 'basic' to
- match the actual file names.
-
-1.3.3:
-
-2002-07-16 Murray Cumming <murrayc@usa.net>
-
- * Rebuilt for latest gtkmm.
-
-1.3.2:
-
-2002-06-23 Murray Cumming <murrayc@usa.net>
-
- * Rebuilt for latest gtkmm.
- * VariablesMap: Fixed "no return statement" warning.
-
-1.3.1:
-
-2002-05-02 Murray Cumming <murrayc@usa.net>
-
- * Added Gnome::Glade::VariablesMap, with an example. This allows
- you to map named Glade widgets to member variables, and transfer
- all the data with one method call.
-
-1.3.0:
-
-2002-04-29 Murray Cumming <murrayc@usa.net>
-
- * Added reparent_widget() method.
-
-2002-04-28 Murray Cumming <murrayc@usa.net>
-
- * Added templated get_widget(name, widget) override, which
- does the dynamic casting and warns about any runtime errors, so
- that application code doesn't need to.
-
-2002-04-25 Murray Cumming <murrayc@usa.net>
-
- * examples/basic: Use a GtkDialog in the .glade file instead of
- the deprecated GnomeDialog. The signal connection now seems to
- work.
- * libglade/src/xml.[hg|ccg]: Added a lookup_type() vfunc
- that instantiates gtkmm types instead of gtk+ types. This requires
- the latest libglade.
-
-2002-04-25 Michael A. Koziarski <michael@koziarski.org>
-
- * libglade/src/xml.ccg
- * libglade/src/xml.hg: As requested, implemented overloaded
- create_from_buffer methods.
-
-2002-04-25 Murray Cumming <murrayc@usa.net>
-
- * Added "basic" example based on the libglade docs and Michael
- Koziarski's .glade file.
-
-2002-04-24 Michael A. Koziarski <michael@koziarski.org>
-
- * libglade/src/xml.ccg
- * libglade/src/xml.hg: Implemented overloaded create methods &
- constructors. Most applications won't need to send a domain
- parameter, and some don't need a root parameter
-
-2002-04-23 Murray Cumming <murrayc@usa.net>
-
- * Generated sources are now distributed. The
- build_shared/*.am_fragement files were copied from libgnomecanvasmm.
-
-2002-04-23 Murray Cumming <murrayc@usa.net>
-
- * Xml constructor uses the glade_xml_construct() function because
- GladeXML doesn't have construct-time properties yet.
-
-
+++ /dev/null
-2.6.1:
-
-* Windows build fixes. (Cedric Gustin)
-
-2.6.0:
-
-libglademm 2.6 is API/ABI-compatible with libglademm 2.4.
-
-Changes since libglademm 2.4:
-
-* Glade::Xml: Added connect_clicked() for easy connection of
- buttons and menuitems signals. (Alberto Paro)
-* Glade::VariablesMap: now handles Entry, ComboTextEntry,
- SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
-
-
-2.5.1:
-
-* Glade::Xml: Added connect_clicked() for easy connection of
- buttons and menuitems signals. (Alberto Paro)
-* Glade::VariablesMap: now handles Entry, ComboTextEntry,
- SpinButton, *Scale, Calendar and CheckBox. (Alberto Paro).
-
-2.4.1:
-
-* gcc 3.4 build fix. (Bryan Forbes)
-
-2.4.0:
-
-The API is now stable.
-
-2.3.3:
-
-* get_widget():
- - Don't create a C++ object with a null C object, when the
- C object can not be found. (jdhall)
- - Really return existing widget wrappers. (Murray Cumming)
-* Stop accidental need for doxygen when building from tarballs.
- (Murray Cumming)
-* win32: Test for -mms-bitfields / -fnative-struct.
-
-2.3.2:
-
-* Updated for new libsigc++ 2 syntax.
-
-2.3.1:
-
-Documentation:
-- Generate and install devhelp file.
-- beautify hmtl documentation, like the gtkmm docs.
-- Install html documentation.
-
-2.3.0:
-
-This is the new unstable branch of the parallel-installable libglademm 2.4,
-for use with gtkmm 2.4.
-
-2.1.2:
-
-* get_widget_derived() now returns an existing C++ instance if one exists, like
- get_widget() already does. (Murray Cumming)
-
-2.1.1:
-
-No changes. Just recreated the tarball - it was not installing the .la files.
-
-2.1.0:
-
-This is the development phase for libglademm 2.2.0,
-which will add API but will not break API or ABI.
-
-* Added Glade::Xml::get_widget_derived() and
- examples/derived/ to demonstrate it.
- This allows you to use Glade to layout your
- own derived container widgets. Tell me what you
- think.
- (Murray Cumming)
-
-
-2.0.1:
-
-* Rebuilt the tarball with newer autotools, fixing the $SED problem.
-
-2.0.0
-
-* Glade::Xml::create() now throws an XmlError expection if it fails.
- (Daniel Elstner)
-* Minimise use of templates, to reduce application code size.
- (Daniel Elstner)
-
-1.3.5
-
-
-
-
+++ /dev/null
-# -*- python -*-
-
-import os
-import os.path
-import glob
-
-Import('env libraries install_prefix')
-
-libglademm_files = glob.glob('libglademm/*.cc')
-
-libglademm = env.Copy()
-libglademm.Merge([libraries['gtk2'], libraries['glade2'], libraries['sigc2'], libraries['glibmm2'], libraries['pangomm'], libraries['atkmm'], libraries['gdkmm2'], libraries['gtkmm2']])
-
-libglade = libglademm.SharedLibrary('libglademm', libglademm_files)
-
-Default(libglade)
-
-env.Alias('install', env.Install(os.path.join(install_prefix, env['LIBDIR'], 'ardour2'), libglade))
-
-env.Alias('tarball', env.Distribute (env['DISTTREE'],
- [ 'SConscript', 'libglademmconfig.h', 'libglademm.h'] +
- libglademm_files +
- glob.glob('libglademm/*.h') +
- glob.glob('libglademm/private/*.h')
- ))
+++ /dev/null
-/* $Id$ */
-/* libglademm - a C++ wrapper for libglade
- *
- * Copyright 1999-2001 Free Software Foundation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef LIBGLADEMM_H
-#define LIBGLADEMM_H
-
-/* libglademm version. */
-extern const int libglademm_major_version;
-extern const int libglademm_minor_version;
-extern const int libglademm_micro_version;
-
-#include <libglademm/xml.h>
-
-#endif /* #ifndef LIBGLADEMM_H */
+++ /dev/null
-// -*- c++ -*-
-/* $Id$ */
-
-/* init.cc
- *
- * Copyright 2001 Free Software Foundation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <libglademm/init.h>
-#include <libglademm/wrap_init.h>
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-
-} //namespace Glade
-} //namespace Gnome
+++ /dev/null
-// -*- c++ -*-
-#ifndef _LIBGLADEMM_INIT_H
-#define _LIBGLADEMM_INIT_H
-/* $Id$ */
-
-/* init.h
- *
- * Copyright 2001 Free Software Foundation
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-
-
-} /* namespace Glade */
-} //namespace Gnome
-
-#endif //_LIBGLADEMM_INIT_H
-
+++ /dev/null
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _LIBGLADEMM_XML_P_H
-#define _LIBGLADEMM_XML_P_H
-#include <glibmm/private/object_p.h>
-
-#include <glibmm/class.h>
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-class Xml_Class : public Glib::Class
-{
-public:
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
- typedef Xml CppObjectType;
- typedef GladeXML BaseObjectType;
- typedef GladeXMLClass BaseClassType;
- typedef Glib::Object_Class CppClassParent;
- typedef GObjectClass BaseClassParent;
-
- friend class Xml;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
- const Glib::Class& init();
-
- static void class_init_function(void* g_class, void* class_data);
-
- static Glib::ObjectBase* wrap_new(GObject*);
-
-protected:
-
- //Callbacks (default signal handlers):
- //These will call the *_impl member methods, which will then call the existing default signal callbacks, if any.
- //You could prevent the original default signal handlers being called by overriding the *_impl method.
-
- //Callbacks (virtual functions):
- static GType lookup_type_vfunc_callback(GladeXML* self, const char* classname);
- };
-
-
-} // namespace Glade
-
-} // namespace Gnome
-
-#endif /* _LIBGLADEMM_XML_P_H */
-
+++ /dev/null
-/* variablesmap.cc
- *
- * Copyright (C) 2002 The libglademm Development Team
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <libglademm/variablesmap.h>
-#include <gtkmm/togglebutton.h>
-#include <gtkmm/entry.h>
-#include <gtkmm/calendar.h>
-#include <gtkmm/scale.h>
-#include <gtkmm/comboboxentry.h>
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-VariablesMap::VariablesMap(const Glib::RefPtr<Glade::Xml>& glade)
-: m_refGlade(glade)
-{
-}
-
-VariablesMap::~VariablesMap()
-{
-}
-
-
-void VariablesMap::connect_widget(const Glib::ustring& widget_name, bool& variable)
-{
- Gtk::ToggleButton* pToggleButton = 0;
- m_refGlade->get_widget(widget_name, pToggleButton); //Glade::Xml will complain if it is not a ToggleButton.
- if(pToggleButton)
- {
- m_mapWidgetsToVariables[pToggleButton] = (void*)(&variable);
- }
-}
-
-void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable)
-{
- Gtk::Widget* pWidget = 0;
- m_refGlade->get_widget(widget_name, pWidget);
-
- Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget); //it mange both Gtk::entry and Gtk::SpinButton
- Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
- if(pEntry)
- {
- m_mapWidgetsToVariables[pEntry] = (void*)(&variable);
- }
- if(pComboBoxEntry)
- {
- m_mapWidgetsToVariables[pComboBoxEntry] = (void*)(&variable);
- }
-}
-
-void VariablesMap::connect_widget(const Glib::ustring& widget_name, double& variable)
-{
- Gtk::Widget* pWidget = 0;
- m_refGlade->get_widget(widget_name, pWidget);
-
- Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget);
- if(pScale)
- {
- m_mapWidgetsToVariables[pScale] = (void*)(&variable);
- }
-}
-
-void VariablesMap::connect_widget(const Glib::ustring& widget_name, Glib::Date& variable)
-{
- Gtk::Widget* pWidget = 0;
- m_refGlade->get_widget(widget_name, pWidget);
-
- Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget);
- if(pCalendar)
- {
- m_mapWidgetsToVariables[pCalendar] = (void*)(&variable);
- }
-}
-
-void VariablesMap::transfer_widgets_to_variables()
-{
- if(validate_widgets()) //If the widgets' data is correct. Useful to override.
- {
- for(type_mapWidgetsToVariables::iterator iter = m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
- {
- transfer_one_widget(iter->first, true); //true = to_variable.
- }
- }
-}
-
-void VariablesMap::transfer_variables_to_widgets()
-{
- for(type_mapWidgetsToVariables::iterator iter = m_mapWidgetsToVariables.begin(); iter != m_mapWidgetsToVariables.end(); ++iter)
- {
- transfer_one_widget(iter->first, false); //false = to_widget.
- }
-}
-
-
-void VariablesMap::transfer_one_widget(Gtk::Widget* pWidget, bool to_variable)
-{
- //Find the widget in the map:
- type_mapWidgetsToVariables::iterator iterFind = m_mapWidgetsToVariables.find(pWidget);
- if(iterFind != m_mapWidgetsToVariables.end())
- {
- //Get the variable for the widget:
- void* pVariable = iterFind->second;
- if(pVariable)
- {
- //Cast the variable appropriately and set it appropriately:
- Gtk::Entry* pEntry = dynamic_cast<Gtk::Entry*>(pWidget);
- Gtk::ComboBoxEntry* pComboBoxEntry = dynamic_cast<Gtk::ComboBoxEntry*>(pWidget);
-
- Gtk::ToggleButton* pToggleButton = dynamic_cast<Gtk::ToggleButton*>(pWidget); //CheckButtons and RadioButtons.
- Gtk::Scale* pScale = dynamic_cast<Gtk::Scale*>(pWidget);
- Gtk::Calendar* pCalendar = dynamic_cast<Gtk::Calendar*>(pWidget);
-
- if(pEntry)
- {
- Glib::ustring* pVar = (Glib::ustring*)(pVariable);
-
- if(to_variable)
- (*pVar) = pEntry->get_text();
- else
- pEntry->set_text(*pVar);
- }
- if(pComboBoxEntry)
- {
- Glib::ustring* pVar = (Glib::ustring*)(pVariable);
- Gtk::Entry* pIEntry = dynamic_cast<Gtk::Entry*>(pComboBoxEntry->get_child());
-
- if(to_variable){
- if(pIEntry)
- (*pVar) = pIEntry->get_text();
- } else {
- if(pIEntry)
- pIEntry->set_text(*pVar);
- }
- }
- if(pToggleButton)
- {
- bool* pVar = (bool*)(pVariable);
-
- if(to_variable)
- (*pVar) = pToggleButton->get_active();
- else
- pToggleButton->set_active(*pVar);
- }
- if(pScale)
- {
- double* pVar = (double*)(pVariable);
-
- if(to_variable)
- (*pVar) = pScale->get_value();
- else
- pScale->set_value(*pVar);
- }
- if(pCalendar)
- {
- Glib::Date* pVar = (Glib::Date*)(pVariable);
-
- if(to_variable){
- guint year,month,day;
- pCalendar->get_date(year,month,day);
- (*pVar) = Glib::Date(day,(Glib::Date::Month)month,year);
- } else {
- pCalendar->select_day(pVar->get_day());
- pCalendar->select_month(pVar->get_month(), pVar->get_year());
- }
- }
- }
- }
-}
-
-bool VariablesMap::validate_widgets()
-{
- //Override to add validation.
- //TODO: We could add some automatic data-range and text-length validation.
- return true;
-}
-
-
-
-} /* namespace Glade */
-} /* namespace Gnome */
+++ /dev/null
-/* variablesmap.h
- *
- * Copyright (C) 2002 The libglademm Development Team
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#ifndef _LIBGLADEMM_VARIABLESMAP_H
-#define _LIBGLADEMM_VARIABLESMAP_H
-
-#include <libglademm/xml.h>
-#include <map>
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-/** Associates named Glade widgets with member variables.
- * Use connect_widget() to link the widgets with variables that will contain their data.
- * Then use transfer_widgets_to_variables() and transfer_variables_to_widgets() to get or set all of the variables at once.
- *
- * This is meant to be a bit like MFC's "Dialog Data Exchange and Validation".
- *
- * The association of widget and member varables follow this mapping:
- *
- * Gtk::Entry --> Glib::ustring
- * Gtk::SpinBox --> Glib::ustring
- * Gtk::ComboBoxEntry --> Glib::ustring
- * Gtk::Scale --> double
- * Gtk::Calendar --> Glib::Date
- * Gtk::CheckBox --> bool
- * Gtk::RadioButton --> bool
- *
- */
-class VariablesMap
-{
-public:
- explicit VariablesMap(const Glib::RefPtr<Glade::Xml>& glade);
- virtual ~VariablesMap();
-
- ///For ToggleButton (CheckBox and RadioButton)
- virtual void connect_widget(const Glib::ustring& widget_name, bool& variable);
-
- ///For Entry, ComboBoxEntry and SpinBox
- virtual void connect_widget(const Glib::ustring& widget_name, Glib::ustring& variable);
-
- ///For Scale (HScale and VScale)
- virtual void connect_widget(const Glib::ustring& widget_name, double& variable);
-
- ///For Calendar
- virtual void connect_widget(const Glib::ustring& widget_name, Glib::Date& variable);
-
- ///Transfer data from the widget to the variable.
- virtual void transfer_widgets_to_variables();
-
- ///Transfer data from the variable to the widget.
- virtual void transfer_variables_to_widgets();
-
-protected:
-
- /** Override this to validate the data that the user enters into the widgets.
- * The return value indicates whether the widgets' data is valid.
- */
- virtual bool validate_widgets();
-
- virtual void transfer_one_widget(Gtk::Widget* pWidget, bool to_variable);
-
- typedef std::map<Gtk::Widget*, void*> type_mapWidgetsToVariables;
- type_mapWidgetsToVariables m_mapWidgetsToVariables;
-
- Glib::RefPtr<Glade::Xml> m_refGlade;
-};
-
-} /* namespace Glade */
-} /* namespace Gnome */
-
-
-
-
-#endif /* _LIBGLADEMM_VARIABLESMAP_H */
-
-
+++ /dev/null
-
-#include <glib.h>
-
-// Disable the 'const' function attribute of the get_type() functions.
-// GCC would optimize them out because we don't use the return value.
-#undef G_GNUC_CONST
-#define G_GNUC_CONST /* empty */
-
-#include <libglademm/wrap_init.h>
-#include <glibmm/error.h>
-#include <glibmm/object.h>
-
-// #include the widget headers so that we can call the get_type() static methods:
-
-#include "xml.h"
-
-extern "C"
-{
-
-//Declarations of the *_get_type() functions:
-
-GType glade_xml_get_type(void);
-
-//Declarations of the *_error_quark() functions:
-
-} // extern "C"
-
-
-//Declarations of the *_Class::wrap_new() methods, instead of including all the private headers:
-
-namespace Gnome { namespace Glade { class Xml_Class { public: static Glib::ObjectBase* wrap_new(GObject*); }; } }
-
-namespace Gnome { namespace Glade {
-
-void wrap_init()
-{
- // Register Error domains:
-
-// Map gtypes to gtkmm wrapper-creation functions:
- Glib::wrap_register(glade_xml_get_type(), &Gnome::Glade::Xml_Class::wrap_new);
-
- // Register the gtkmm gtypes:
- Gnome::Glade::Xml::get_type();
-
-} // wrap_init()
-
-} //Glade
-} //Gnome
-
-
+++ /dev/null
-#ifndef _LIBGLADEMM_WRAP_INIT_H
-#define _LIBGLADEMM_WRAP_INIT_H
-
-/* wrap_init.h
- *
- * Copyright (C) 1998-2001 The libglademm Development Team
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-// wrap_init.cc is generated by tools/generate_wrap_init.pl
-
-namespace Gnome
-{
-
-namespace UI
-{
-
-void wrap_init();
-
-} /* namespace UI */
-
-} /* namespace Gnome */
-
-#endif // _LIBGLADEMM_WRAP_INIT_H
+++ /dev/null
-// Generated by gtkmmproc -- DO NOT MODIFY!
-
-#include <libglademm/xml.h>
-#include <libglademm/private/xml_p.h>
-
-/* $Id$ */
-
-/* Copyright (C) 2002 The libglademm Development Team
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <glade/glade-xml.h>
-#include <gtkmm/button.h>
-#include <gtkmm/menuitem.h>
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-XmlError::XmlError(const Glib::ustring& message)
-:
- message_ (message)
-{}
-
-XmlError::~XmlError() throw()
-{}
-
-XmlError::XmlError(const XmlError& other)
-:
- Glib::Exception (other),
- message_ (other.message_)
-{}
-
-XmlError& XmlError::operator=(const XmlError& other)
-{
- message_ = other.message_;
- return *this;
-}
-
-Glib::ustring XmlError::what() const
-{
- return message_;
-}
-
-
-Xml::Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain)
-:
- Glib::ObjectBase(0), //Mark this class as gtkmmproc-generated, rather than a custom class, to allow vfunc optimisations.
- Glib::Object(Glib::ConstructParams(xml_class_.init(), (char*) 0))
-{
- if(!glade_xml_construct(gobj(), filename.c_str(), root.empty() ? 0 : root.c_str(),
- domain.empty() ? 0 : domain.c_str()))
- {
- throw XmlError("Failed to load glade file `" + Glib::filename_to_utf8(filename) + '\'');
- }
-}
-
-// TODO: we need glade_xml_construct_from_buffer()
-Xml::Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain)
-:
- Glib::ObjectBase(0),
- Glib::Object((GObject*) glade_xml_new_from_buffer(
- buffer, size, root.empty() ? 0 : root.c_str(), domain.empty() ? 0 : domain.c_str()))
-{
- if(!gobj())
- throw XmlError("Failed to read glade input buffer");
-}
-
-// static
-Glib::RefPtr<Xml> Xml::create(const std::string& filename,
- const Glib::ustring& root, const Glib::ustring& domain)
-{
- return Glib::RefPtr<Xml>(new Xml(filename, root, domain));
-}
-
-// static
-Glib::RefPtr<Xml> Xml::create_from_buffer(const char* buffer, int size,
- const Glib::ustring& root, const Glib::ustring& domain)
-{
- return Glib::RefPtr<Xml>(new Xml(buffer, size, root, domain));
-}
-
-void Xml::reparent_widget(const Glib::ustring& name, Gtk::Container& container)
-{
- Gtk::Widget* pWidget = 0;
- get_widget(name, pWidget);
-
- g_return_if_fail(pWidget != 0);
-
- pWidget->reparent(container);
-}
-
-Gtk::Widget* Xml::get_widget_checked(const Glib::ustring& name, GType type)
-{
- // Get the widget from the glade file.
- Gtk::Widget *const pWidget = get_widget(name);
-
- if(!pWidget)
- {
- g_critical("widget `%s' not found in glade file `%s'", name.c_str(), gobj()->filename);
- return 0;
- }
-
- // Check if it has the correct type.
- if(!g_type_is_a(G_OBJECT_TYPE(pWidget->gobj()), type))
- {
- g_critical("widget `%s' (in glade file `%s') is of type `%s' but `%s' was expected",
- name.c_str(), gobj()->filename, G_OBJECT_TYPE_NAME(pWidget->gobj()), g_type_name(type));
- return 0;
- }
-
- return pWidget;
-}
-
-GtkWidget* Xml::get_cwidget(const Glib::ustring& name)
-{
- GtkWidget* pCWidget = glade_xml_get_widget(gobj(), name.c_str());
- if(!pCWidget)
- g_critical("Glade::Xml::get_cwidget(): glade_xml_get_widget() failed.");
-
- return pCWidget;
-}
-
-// Custom coded so that we can custom-code the vfunc in the Xml class.
-// This is marginally better than modifying gtkmmproc to allow this.
-//
-GType Xml_Class::lookup_type_vfunc_callback(GladeXML* self, const char* classname)
-{
- CppObjectType *const obj = dynamic_cast<CppObjectType*>(
- Glib::ObjectBase::_get_current_wrapper((GObject*) self));
-
- if(obj)
- {
- try
- {
- return obj->lookup_type_vfunc(Glib::convert_const_gchar_ptr_to_ustring(classname));
- }
- catch(...)
- {
- Glib::exception_handlers_invoke();
- }
- }
- else
- {
- BaseClassType *const base = static_cast<BaseClassType*>(
- g_type_class_peek_parent(G_OBJECT_GET_CLASS(self)) // Get the parent class of the object class.
- );
-
- if(base && base->lookup_type)
- return (*base->lookup_type)(self, classname);
- }
-
- return 0;
-}
-
-GType Xml::lookup_type_vfunc(const Glib::ustring& classname)
-{
- // See if there is a gtkmm version of the gclass:
- Glib::ustring classname_prefixed ("gtkmm__"); // gtkmm uses a prefix
- classname_prefixed += classname;
-
- GType gtype = g_type_from_name(classname_prefixed.c_str());
-
- if(gtype == G_TYPE_INVALID) // if it's not a registered typename
- {
- // There's no gtkmm derived type, so just use the normal one.
- gtype = g_type_from_name(classname.c_str());
- }
-
- return gtype;
-}
-
-void Xml::connect_clicked(const Glib::ustring& widget_name, const sigc::slot<void>& slot_ )
-{
- Gtk::Widget* pWidget = 0;
- get_widget(widget_name, pWidget);
-
- Gtk::Button* pButton = dynamic_cast<Gtk::Button*>(pWidget);
- Gtk::MenuItem* pMenuItem = dynamic_cast<Gtk::MenuItem*>(pWidget);
-
- if(pButton)
- pButton->signal_clicked().connect( slot_);
-
- if(pMenuItem)
- pMenuItem->signal_activate().connect( slot_ );
-}
-
-} // namespace Glade
-} // namespace Gnome
-
-
-namespace
-{
-} // anonymous namespace
-
-
-namespace Glib
-{
-
-Glib::RefPtr<Gnome::Glade::Xml> wrap(GladeXML* object, bool take_copy)
-{
- return Glib::RefPtr<Gnome::Glade::Xml>( dynamic_cast<Gnome::Glade::Xml*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
- //We use dynamic_cast<> in case of multiple inheritance.
-}
-
-} /* namespace Glib */
-
-
-namespace Gnome
-{
-
-namespace Glade
-{
-
-
-/* The *_Class implementation: */
-
-const Glib::Class& Xml_Class::init()
-{
- if(!gtype_) // create the GType if necessary
- {
- // Glib::Class has to know the class init function to clone custom types.
- class_init_func_ = &Xml_Class::class_init_function;
-
- // This is actually just optimized away, apparently with no harm.
- // Make sure that the parent type has been created.
- //CppClassParent::CppObjectType::get_type();
-
- // Create the wrapper type, with the same class/instance size as the base type.
- register_derived_type(glade_xml_get_type());
-
- // Add derived versions of interfaces, if the C type implements any interfaces:
- }
-
- return *this;
-}
-
-void Xml_Class::class_init_function(void* g_class, void* class_data)
-{
- BaseClassType *const klass = static_cast<BaseClassType*>(g_class);
- CppClassParent::class_init_function(klass, class_data);
-
- klass->lookup_type = &lookup_type_vfunc_callback;
- }
-
-
-Glib::ObjectBase* Xml_Class::wrap_new(GObject* object)
-{
- return new Xml((GladeXML*)object);
-}
-
-
-/* The implementation: */
-
-GladeXML* Xml::gobj_copy()
-{
- reference();
- return gobj();
-}
-
-Xml::Xml(const Glib::ConstructParams& construct_params)
-:
- Glib::Object(construct_params)
-{}
-
-Xml::Xml(GladeXML* castitem)
-:
- Glib::Object((GObject*)(castitem))
-{}
-
-Xml::~Xml()
-{}
-
-
-Xml::CppClassType Xml::xml_class_; // initialize static member
-
-GType Xml::get_type()
-{
- return xml_class_.init().get_type();
-}
-
-GType Xml::get_base_type()
-{
- return glade_xml_get_type();
-}
-
-
-std::string Xml::get_filename() const
-{
- return Glib::convert_const_gchar_ptr_to_stdstring(gobj()->filename);
-}
-
-Gtk::Widget* Xml::get_widget(const Glib::ustring& name)
-{
- return Glib::wrap(glade_xml_get_widget(gobj(), name.c_str()));
-}
-
-Glib::ListHandle<Gtk::Widget*> Xml::get_widget_prefix(const Glib::ustring& name)
-{
- return Glib::ListHandle<Gtk::Widget*>(glade_xml_get_widget_prefix(gobj(), name.c_str()), Glib::OWNERSHIP_SHALLOW);
-}
-
-std::string Xml::relative_file(const std::string& filename) const
-{
- return Glib::convert_return_gchar_ptr_to_stdstring(glade_xml_relative_file(const_cast<GladeXML*>(gobj()), filename.c_str()));
-}
-
-Glib::ustring Xml::get_widget_name(Gtk::Widget& widget)
-{
- return Glib::convert_const_gchar_ptr_to_ustring(glade_get_widget_name((widget).gobj()));
-}
-
-Glib::RefPtr<Xml> Xml::get_widget_tree(Gtk::Widget& widget)
-{
-
- Glib::RefPtr<Xml> retvalue = Glib::wrap(glade_get_widget_tree((widget).gobj()));
-
- if(retvalue)
- retvalue->reference(); //The function does not do a ref for us.
- return retvalue;
-}
-
-
-} // namespace Glade
-
-} // namespace Gnome
-
-
+++ /dev/null
-// -*- c++ -*-
-// Generated by gtkmmproc -- DO NOT MODIFY!
-#ifndef _LIBGLADEMM_XML_H
-#define _LIBGLADEMM_XML_H
-
-#include <glibmm.h>
-
-/* $Id$ */
-
-/* Copyright (C) 2002 The libglademm Development Team
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Library General Public
- * License as published by the Free Software Foundation; either
- * version 2 of the License, or (at your option) any later version.
- *
- * This library 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
- * Library General Public License for more details.
- *
- * You should have received a copy of the GNU Library General Public
- * License along with this library; if not, write to the Free
- * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- */
-
-#include <gtkmm/container.h>
-
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-typedef struct _GladeXML GladeXML;
-typedef struct _GladeXMLClass GladeXMLClass;
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-
-namespace Gnome
-{
-
-namespace Glade
-{ class Xml_Class; } // namespace Glade
-
-} // namespace Gnome
-namespace Gnome
-{
-
-namespace Glade
-{
-
-class XmlError : public Glib::Exception
-{
-public:
- explicit XmlError(const Glib::ustring& message);
- virtual ~XmlError() throw();
-
- XmlError(const XmlError& other);
- XmlError& operator=(const XmlError& other);
-
- virtual Glib::ustring what() const;
-
-private:
- Glib::ustring message_;
-};
-
-
-class Xml : public Glib::Object
-{
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
-
-public:
- typedef Xml CppObjectType;
- typedef Xml_Class CppClassType;
- typedef GladeXML BaseObjectType;
- typedef GladeXMLClass BaseClassType;
-
-private: friend class Xml_Class;
- static CppClassType xml_class_;
-
-private:
- // noncopyable
- Xml(const Xml&);
- Xml& operator=(const Xml&);
-
-protected:
- explicit Xml(const Glib::ConstructParams& construct_params);
- explicit Xml(GladeXML* castitem);
-
-#endif /* DOXYGEN_SHOULD_SKIP_THIS */
-
-public:
- virtual ~Xml();
-
-#ifndef DOXYGEN_SHOULD_SKIP_THIS
- static GType get_type() G_GNUC_CONST;
- static GType get_base_type() G_GNUC_CONST;
-#endif
-
- ///Provides access to the underlying C GObject.
- GladeXML* gobj() { return reinterpret_cast<GladeXML*>(gobject_); }
-
- ///Provides access to the underlying C GObject.
- const GladeXML* gobj() const { return reinterpret_cast<GladeXML*>(gobject_); }
-
- ///Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.
- GladeXML* gobj_copy();
-
-private:
-
-
- //Ignore private glade_xml functions.
-
-protected:
- /** Loads a glade XML file.
- * @throw XmlError
- */
- Xml(const std::string& filename, const Glib::ustring& root, const Glib::ustring& domain);
-
- /** Reads glade XML data from memory.
- * @throw XmlError
- */
- Xml(const char* buffer, int size, const Glib::ustring& root, const Glib::ustring& domain);
-
- Gtk::Widget* get_widget_checked(const Glib::ustring& name, GType type);
- GtkWidget* get_cwidget(const Glib::ustring& name);
-
-public:
- typedef Gnome::Glade::XmlError Error;
-
- /** Loads a glade XML file.
- * @throw XmlError
- */
- static Glib::RefPtr<Xml> create(const std::string& filename,
- const Glib::ustring& root = Glib::ustring(),
- const Glib::ustring& domain = Glib::ustring());
-
- /** Reads glade XML data from memory.
- * @throw XmlError
- */
- static Glib::RefPtr<Xml> create_from_buffer(const char* buffer, int size,
- const Glib::ustring& root = Glib::ustring(),
- const Glib::ustring& domain = Glib::ustring());
-
- std::string get_filename() const;
-
-//void glade_xml_signal_connect (GladeXML *self,
-// const char *handlername,
-// GCallback func);
-//void glade_xml_signal_connect_data (GladeXML *self,
-// const char *handlername,
-// GCallback func,
-// gpointer user_data);
-//
-//void glade_xml_signal_autoconnect (GladeXML *self);
-//
-//
-//typedef void (*GladeXMLConnectFunc) (const gchar *handler_name,
-// GObject *object,
-// const gchar *signal_name,
-// const gchar *signal_data,
-// GObject *connect_object,
-// gboolean after,
-// gpointer user_data);
-//
-//
-//void glade_xml_signal_connect_full (GladeXML *self,
-// const gchar *handler_name,
-// GladeXMLConnectFunc func,
-// gpointer user_data);
-//
-//void glade_xml_signal_autoconnect_full (GladeXML *self,
-// GladeXMLConnectFunc func,
-// gpointer user_data);
-//
-//
- /** Get a widget from the glade file.
- * For instance:
- * @code
- * Gtk::Table* pTable = dynamic_cast<Gtk::Table*>(refXml->get_widget("mytable"));
- * @endcode
- * @param name The name of the widget.
- * @return A pointer to the widget, or <tt>0</tt> on failure.
- */
-
- Gtk::Widget* get_widget(const Glib::ustring& name);
-
- /** This is for convenience.
- * It allows for a shorter syntax with less repetition. For instance:
- * @code
- * Gtk::Table* pTable = 0;
- * refXml->get_widget("mytable", pTable);
- * @endcode
- * This method prints a warning message to the console if the widget
- * doesn't exist or has the wrong type, so you don't need to check that
- * manually.
- * @param name The name of the widget.
- * @retval widget A pointer to the widget, or <tt>0</tt> on failure.
- * @return The value of @a widget.
- */
- template <class T_Widget> inline
- T_Widget* get_widget(const Glib::ustring& name, T_Widget*& widget)
- {
- // The dynamic_cast<> should never fail if get_widget_checked() succeeded.
- widget = dynamic_cast<T_Widget*>(this->get_widget_checked(name, T_Widget::get_base_type()));
-
- if(!widget)
- g_critical("Gnome::Glade::Xml::get_widget(): dynamic_cast<> failed.");
-
- return widget;
- }
-
- /** This provides a pointer to a widget whose details are specified in the Glade file, but which is implemented
- * by your own derived class. Your class must have a constructor like so:
- * @code
- * DerivedDialog::DerivedDialog(BaseObjectType* cobject, const Glib::RefPtr<Gnome::Glade::Xml>& refGlade)
- * : Gtk::Dialog(cobject) //Calls the base class constructor
- * @endcode
- *
- * For instance:
- * @code
- * Gtk::DerivedBox* pBox = 0;
- * refXml->get_widget_derived("mybox", pBox);
- * @endcode
- *
- * @param name The name of the widget.
- * @retval widget A pointer to the widget, or <tt>0</tt> on failure.
- * @return The value of @a widget.
- */
- template <class T_Widget> inline
- T_Widget* get_widget_derived(const Glib::ustring& name, T_Widget*& widget)
- {
- // initialize input parameter
- widget = 0;
-
- // Get the widget from the glade file.
- typedef typename T_Widget::BaseObjectType cwidget_type;
- cwidget_type* pCWidget = (cwidget_type*)get_cwidget(name);
-
- //The error was already reported by get_cwidget().
- if(!pCWidget)
- return 0;
-
- //Check whether there is already a C++ wrapper instance associated with this C instance:
- Glib::ObjectBase* pObjectBase = ObjectBase::_get_current_wrapper((GObject*)pCWidget);
-
- //If there is already a C++ instance, then return it again:
- if(pObjectBase)
- {
- widget = dynamic_cast<T_Widget*>( Glib::wrap((GtkWidget*)pCWidget) );
- //Newer, more spec-complaint, versions of g++ not resolve a specific wrap() function in a template.
-
- //The dynamic cast checks that it is of the correct type.
- //Somebody might be trying to call get_widget_derived() after already calling get_widget(),
- //or after already calling get_widget_derived() with a different derived C++ type.
- if(!widget)
- g_critical("Gnome::Glade::Xml::get_widget_derived(): dynamic_cast<> failed. An existing C++ instance, of a different type, seems to exist.");
- }
- else
- {
- //Create a new C++ instance to wrap the existing C instance:
-
- //Set the output variable. We needed to do this because we can not template the return type.
- Glib::RefPtr<Gnome::Glade::Xml> refThis(this);
- refThis->reference(); //take a copy.
- widget = new T_Widget(pCWidget, refThis);
- }
-
- //We return it as well (we need the parameter as well, because C++ can not just template the return type.)
- return widget;
- }
-
-
- Glib::ListHandle<Gtk::Widget*> get_widget_prefix(const Glib::ustring& name);
-
- ///Take the widget from the glade-generated container and put it in another container.
- void reparent_widget(const Glib::ustring& name, Gtk::Container& container);
-
-
- std::string relative_file(const std::string& filename) const;
-
-
- static Glib::ustring get_widget_name(Gtk::Widget& widget);
-
- static Glib::RefPtr<Xml> get_widget_tree(Gtk::Widget& widget);
-
-
- /** Connect a Gtk::Button's clicked signal or a Gtk::MenuItem's activated signal to a slot.
- *
- * For instance:
- * @code
- * refXml->connect_button("button", sigc::mem_fun(*this, &ExampleWindow::on_button_clicked) );
- * @endcode
- *
- * @param name The name of the widget.
- * @param pslot The slot to connect to.
- */
- void connect_clicked(const Glib::ustring& name, const sigc::slot<void>& slot_);
-
-
-///* interface for changing the custom widget handling */
-//typedef GtkWidget *(* GladeXMLCustomWidgetHandler) (GladeXML *xml,
-// gchar *func_name,
-// gchar *name,
-// gchar *string1,
-// gchar *string2,
-// gint int1,
-// gint int2,
-// gpointer user_data);
-
-//void glade_set_custom_handler(GladeXMLCustomWidgetHandler handler,
-// gpointer user_data);
-
-
-protected:
-
-
- virtual GType lookup_type_vfunc(const Glib::ustring& classname);
-
-
-public:
-
-public:
- //C++ methods used to invoke GTK+ virtual functions:
-
-protected:
- //GTK+ Virtual Functions (override these to change behaviour):
-
- //Default Signal Handlers::
-
-
-};
-
-} // namespace Glade
-} // namespace Gnome
-
-
-namespace Glib
-{
- /** @relates Gnome::Glade::Xml
- * @param object The C instance
- * @param take_copy False if the result should take ownership of the C instance. True if it should take a new copy or ref.
- * @result A C++ instance that wraps this C instance.
- */
- Glib::RefPtr<Gnome::Glade::Xml> wrap(GladeXML* object, bool take_copy = false);
-}
-
-
-#endif /* _LIBGLADEMM_XML_H */
-
+++ /dev/null
-/* libglade/libglademmconfig.h. Generated by configure. */
-#ifndef _LIBGLADEMM_CONFIG_H
-#define _LIBGLADEMM_CONFIG_H 1
-
-#include "gtkmmconfig.h"
-
-/* version numbers */
-#define LIBGLADEMM_MAJOR_VERSION 2
-#define LIBGLADEMM_MINOR_VERSION 6
-#define LIBGLADEMM_MICRO_VERSION 1
-#define LIBGLADEMM_VERSION "2.6.1"
-#define LIBGLADE_VERSION_NEEDED_QUOTED "2.3.6"
-
-#endif /* _LIBGLADEMM_CONFIG_H */
-
+2.0.17:
+
+2005-12-20 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: Make all operator--() methods
+ return by reference, like the operator++() methods.
+ Bug #304402 from John Profic.
+
+This is the libsigc-2-0 branch, for maintenance of libsigc++ 2.0.
+API/ABI-compatible API-addition happens in the HEAD branch.
+
+2005-12-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/slot_base.cc:
+ slot_base::disconnect(): Set call_ to 0,
+ to invalidate the slot, even if parent_ is 0.
+ I think parent_ is, for instance, a signal, but
+ disconnect should still work on a slot that is not
+ connected to a signal, because a slot can be invoked
+ directly.
+ Fixes bug #311057 from James Lin.
+
+2005-12-01 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/Makefile.am:
+ * tests/test_slot_disconnect.cc: Added test
+ case from bug #311057.
+
+2005-11-16 Philipp Berndt <philipp.berndt@gmx.net>
+
+ * sigc++/adaptors/macros/exception_catch.h.m4: Make member
+ exception_catch_functor<T_functor, T_catcher, void>::catcher_
+ public so that it can be accessed by visit_each()
+ (bug fixed for generalization on 2004-11-06)
+
+2.0.16:
+
+2005-08-01 Neal E. Coombes <nealc@trdlnk.com>
+
+ * sigc++/signal_base.h: Updated the documentation for temp_slot_list
+ as requested in bug #303896.
+
+2005-08-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adaptors/hide.h.m4: Added missing
+ ) in call to sun_forte_workaround(), fixing
+ build on SUN Forte 5.5. Bug #312020.
+
+2005-08-19 Bruno Martinez <brunom@fing.edu.uy>
+
+ * sigc++/type_traits.h: Renamed
+ ::sigc::is_base_and_derived::internal to
+ ::sigc::is_base_and_derived::internal_class
+ in order to avoid conflict with
+ namespace internal.
+
+2005-07-13 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/manual/libsigc_manual.xml: Correct mentions of
+ 1.2 stuff instead of 2.0. Patch in bug #310213 from
+ pebble.org.uk.
+
+2005-07-13 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/manual/libsigc_manual.xml: Fixed typo
+ found by Antonio Coralles.
+
+2005-07-09 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: Did the same (see
+ last commit) for slot_const_iterator and
+ slot_iterator_buf.
+
+2005-07-09 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: slot_iterator:
+ operator--() now returns value, not reference, like
+ operator++() already did. This caused crashes when
+ using --no-inline with g++. Bug #308651 by
+ Michael Andres.
+
+2.0.15:
+
+2005-07-04 Philip Langdale <plangdale@vmware.com>
+
+ * sigc++/adaptors/macros/compose.h.m4: Add a setter typedef to
+ compose*_functor and use it instead of the (incorrect) getter
+ typedef in the compose* specialization of visit_each<>().
+ This corrects the lifetime management of slots created with
+ compose(). Bug #308433.
+
+2005-06-13 Marek Rouchal <marek.rouchal@infineon.com>
+
+ * tests/test_deduce_result_type.cc: Specify int return type
+ for main(), to be more ISO C++ compliant. Bug #307478.
+
+2005-06-11 Andris Pavenis <pavenis@latnet.lv>
+
+ * sigc++/adaptors/lambda/macros/base.h.m4:
+ * sigc++/adaptors/lambda/macros/select.h.m4
+ * sigc++/adaptors/macros/hide.h.m4: Specify only a type (not a
+ parameter name) for unused member function parameters
+
+2005-06-12 Paul Pogonyshev <pogonyshev@gmx.net>
+
+ * configure.ac:
+ * scripts/cxx.m4:
+ * sigc++config.h.in: Add test for whether the compiler allows
+ referencing to member functions of the class/structure being
+ declared from a definition of a static member variable.
+ Supposedly a generic solution for GCC 3.2 compilation problems.
+
+ * sigc++/type_traits.h: Define SIGC_WRAP_IS_BASE_CLASS_ based on
+ results of the above test.
+ (struct is_base_and_derived): Wrap up is_base_class_() functions
+ in an internal class if SIGC_WRAP_IS_BASE_CLASS_ is defined.
+
+2005-06-10 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adaptors/macros/bind.h.m4:
+ * sigc++/functors/macros/slot.h.m4:
+ * sigc++/macros/signal.h.m4: Use CALL_SIZE instead of
+ hard-coded 7s and 6s.
+
+2.0.14:
+
+2005-06-10 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: Make the
+ limit_derived_target::with_type inner class an outer class,
+ to satisfy the SUN CC 5.7 compiler, though I think it is a
+ compiler bug. Bug #302098 has the test case.
+
+2.0.13:
+
+2005-06-07 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/test_compatibility.cc: Specify the actual class when
+ using test_int(), instead of the derived class, to fix the build
+ on SUN Forte CC 5.5. Patch from Friedemann Kleint in
+ Bug #305647
+
+2005-06-07 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: signal_emit::emit(): Use scope to
+ ensure a certain order of destruction of the member variables, to
+ avoid a leak on MSVC++. Patch by Andreas Ames in Bug #306249.
+
+2005-06-07 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/macros/signal.h.m4: Added comments about commenting-out
+ SIGC_TYPEDEF_REDEFINE_ALLOWED when using SUN Forte CC 5.7,
+ because I can not seem to create a test for it.
+
+2005-06-07 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.ac:
+ * scripts/cxx_std.m4:
+ * sigc++/macros/signal.h.m4:
+ * sigc++config.h.in: Added check for
+ the non-standard SUN Forte reverse_iterator<>,
+ and used it. This is based on the same stuff in
+ gtkmm.
+
+2005-06-07 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: limit_derived_target(): Just some whitespace
+ changes.
+
+2005-05-16 Neal E. Coombes <nealc@trdlnk.com>
+
+ * sigc++/signal_base.h: Modified temp_slot_list to be a temporary view
+ into a slot list. Instead of emptying the original it now simply tacks
+ a placeholder to the end of the original. It then uses this as it's
+ 'end' iterator. This should allow for conscious recursiveness, as well
+ as inserting a slot to any position in the slot list during emittion.
+ See bug #303896.
+
+2005-06-04 Friedemann Kleint <kleint@bifab.de>
+
+ * sigc++/macros/limit_reference.h.m4:
+ visit_each() template specializations:
+ Mention the bool I_derives_trackable
+ template type, to fix the build on Solaris
+ Forte 5.5.
+
+2.0.12:
+
+2005-05-06 Régis Duchesne <hpreg@vmware.com>
+
+ * sigc++/macros/limit_reference.h.m4 (added):
+ * sigc++/Makefile.am:
+ New class that just stores a reference, and makes sure that if the
+ reference derives from trackable, then the trackable reference will be
+ used instead of the derived reference in visit_each().
+ * sigc++/functors/macros/mem_fun.h.m4: Better fix for bug #169225 by
+ Régis Duchesne and Christian Hammond, based on the new limit_reference
+ class.
+ * sigc++/adaptors/bound_argument.h (added): New class (built upon the
+ new limit_reference class) that handles all 3 kinds of bound arguments:
+ by value, by reference, and by constant reference. References are
+ unwrapped in the bound_argument's constructor.
+ * sigc++/adaptors/macros/bind.h.m4: Fix for bug #302327 by Régis
+ Duchesne. Bound arguments now need to know whether they are passed by
+ reference or not. So bind() now builds bind_functor instances using
+ 'reference_wrapper<Foo>' types, instead of 'Foo &' types. The
+ bind_functor code is modified to compensate.
+ * sigc++/adaptors/macros/bind_return.h.m4: Similar fix for a similar
+ bug (unfiled) with bound return arguments.
+ * sigc++/reference_wrapper.h:
+ * sigc++/type_traits.h:
+ The reference_wrapper class is only used in bound_argument.h. Put
+ correct but unused code under #if 0.
+ * sigc++/adaptors/lambda/base.h: This file needs reference_wrapper.h,
+ but was incorrectly relying on type_traits.h to include it.
+ * tests/Makefile.am:
+ * tests/test_virtualbase_delete.cc (deleted):
+ * tests/test_virtualbase_delete_ref_param.cc (deleted):
+ * tests/test_limit_reference.cc (added):
+ Replaced test_virtualbase_delete*.cc with a simpler
+ test_limit_reference.cc which checks for all 3 aspects of the same bug
+ in one file.
+ * tests/test_bind_ref.cc: Slots must use 'Foo &' types. We were lucky
+ this broken usage worked before this change. The change in
+ type_traits.h made this bug obvious, by preventing the code to compile.
+ * tests/test_bind_return.cc: After my change, bind() and bind_return()
+ must use 'reference_wrapper<Foo>' types.
+ * tests/test_custom.cc: Made this test a no-op (so it does not perturb
+ 'make check' on released versions of the library) and made it a
+ template ready to be modified by hackers.
+
+2005-05-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/slot_base.cc:
+ slot_base::slot_base(src): If the source
+ slot_base has a null rep->call_, meaning that the
+ slot is invalid, just return a default-constructed
+ slot, to prevent the crash shown in
+ tests/tests_copy_invalid_slot.cc. Bug #302515 by
+ Régis Duchesne.
+
+2005-05-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/macros/mem_fun.h.m4: bound_*<>:
+ Add a new is_base_and_derived<sigc::trackable>
+ parameter to the template and thereby provide a
+ specialization for T_Obj types that derive from
+ sigc::trackable. This prevents a crash when casting
+ from the derived type to sigc::trackable after the
+ derived destructor has run. This cast can sometimes
+ fail when using multiple inheritance, at least with
+ g++. Bug #169225 by Régis Duchesne and Christian
+ Hammond.
+ * sigc++/type_traits.h: Add documenation for
+ the internal is_base_and_derived<> template, which
+ allows us to specialize other templates for certain
+ template types.
+
+2005-04-28 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/type_traits.h: Added comments for users of
+ g++ 3.2.
+
+2005-04-28 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/Makefile.am:
+ * tests/test_virtualbase_delete.cc: Added
+ simplified test case from bug #169225. We have a patch
+ to make this succeed but I am not ready to commit it
+ just yet.
+
+2005-04-27 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/Makefile.am:
+ * tests/test_custom.cc:
+ Added a place to put extra test code, so I don't have
+ to keep installing my crazy libsigc++ versions.
+
+2005-04-27 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: Revert back to the non-explicit
+ template call, because we can not specify the
+ template specialization so easily, because the
+ specializations have different numbers of types.
+ * tests/Makefile/am:
+ * tests/test_bind_ref.cc: Add a simple test only for
+ sigc::ref disconnection.
+
+2005-04-26 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: Use the explicit template
+ specialization, needed for Tru64 and AIX compilers.
+ This causes a crash in some uses of sigc::ref()
+ (when using g++ 3.3.4 or 3.3.5 , but not with 3.4) but
+ seems to fix a crash in some uses of multiple inheritance
+ (bug #169225).
+ * tests/test_bind.cc: Comment out the crashing (not with
+ g++ 3.4) use of sigc::ref() with an explanatory comment.
+
+2.0.11:
+
+2005-03-09 Cedric Gustin <cedric.gustin@swing.be>
+
+ * Makefile.am: Moved MSVC_Net2003 directory to SUBDIRS.
+ * MSVC_Net2003/Makefile.am: Added blank.cpp to EXTRA_DIST.
+ * MSVC_Net2003/libsigc++2_msvcNet2003.sln: Removed
+ test_accumulated and test_lambda projects as the tests are
+ disabled in the standard, configure-based build.
+ * MSVC_Net2003/MSVC_Net2003/libsigc++2_msvcNet2003.vcproj:
+ Generate a PDB file in the Debug target.
+
+2005-03-05 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/website/stable.html: Mention actual supported compilers.
+ * docs/website/docs.html: Removed broken examples links. Change
+ reference link to the reference overview page.
+
+2005-02-23 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/slot_base.h: Make slot_base::operator=() public, to
+ fix the build with SUN Forte C++ 5.5 and Tru64.
+
+2.0.10:
+
+2005-02-20 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/test_slot.cc, test_disconnect.cc: #included <new> to avoid
+ an unresolved symbol error with the Tru64 compiler. Solution found by
+ Tim Mooney in bug #161503.
+
+2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * sigc++/signal_base.h: Add some documentation.
+
+2005-02-20 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * sigc++/signal_base.cc: Reset deferred_ flag to false in
+ signal_impl::sweep() (Neal E. Coombes). Partly fixes bug #167714.
+
+2005-02-11 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * docs/manual/Makefile.am: Set the correct group in post-html.
+
+2005-02-11 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/website/doc.shtml: Fix typo in url for reference docs. Found by
+ James Lin.
+
+2005-02-06 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/signal_base.h: temp_slot_list::begin(), end(): Actually
+ return the iterators.
+
+2005-02-03 Neal E. Coombes <nealc@trdlnk.com>
+
+ * sigc++/signal_base.h: Add temp_slot_list struct to facilitate
+ allowing new connections to a signal during an emittion without
+ affecting that emittion.
+ * sigc++/macros/signal.h.m4: Use the new struct temp_slot_list to
+ prevent connections made during an emittion from being called in the
+ same emittion (which has the potential of causing things like
+ infinite loops). This guarantees an emittion will be finite, as well
+ as maintaining any order of emittion guarantees that may have already
+ been in place.
+
+2.0.9:
+
+2005-02-02 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: visit_each_type(): Reverted the change, so that
+ we do not specify the template types ot visit_each<>(), because it
+ crashes on g++ 3.3.4 (but not g++ 3.4.2). Added a comment telling users
+ of AIX (and maybe IRIX MipsPro and Tru64) to use the alternative version
+ if they have compilation problems.
+
+2005-02-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adapators/macros/base.h.m4: Add sigc::var<>() documentation,
+ from Roger Ferrer Ibáñez in bug #149483.
+
+2005-02-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adaptors/macros/compose.h.m4: In the template specializations
+ of visit_each(): As before, specify the specific other template
+ specializations of visit_each that we use. Needed by AIX.
+ * tests/Makefile.am: Reenabled most tests, because AIX can now
+ build them.
+
+2005-02-01 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/visit_each.h: visit_each_type(): Specify the specific
+ template specialization of visit_each<>() to use. The AIX compiler,
+ and possibly the Tru64 compiler, need this extra hint.
+
+2005-02-01 Murray Cumming <murrayc@murrayc.com>
+
+ * bind.h.m4: Define bind_functor::operator() inline because the AIX
+ compiler/linker sometimes fails to find it when it is defined
+ outside of the class.
+
+2.0.8:
+
+2005-01-30 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/type_traits.h: is_base_and_derived: Added
+ avoid_gcc3_warning_(), to avoid an incorrect warning when using
+ g++ 3.3.5
+
+2005-01-28 Liza Klerck <liza@trdlnk.com>
+
+ * sigc++/functors/macros/mem_fun.h.m4: Add a sigc:: namespace
+ prefix to the nested use of visit_each(), to avoid ambiguity when
+ using 2 versions of the libsigc++ API inside different namespace.
+
+2005-01-27 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adaptors/macros/adaptor_trait.h.m4: Add a sigc:: namespace
+ prefix to the nested use of visit_each(), to avoid ambiguity when
+ using 2 versions of the libsigc++ API inside different namespace,
+ which is not very advisable anyway. Bug #165222 from
+ liza at trdlnk.com.
+
+2.0.7:
+
+2005-01-24 Cedric Gustin <cedric.gustin@swing.be>
+
+ * sigc++config.h.in : Moved the SIGC_USING_STD macro definition
+ out of the SIGC_CONFIGURE section. We also need it for MSVC.
+ * MSVC_Net2003/.cvsignore : Added .def and .aps files
+ * MSVC_Net2003/Makefile.am: Rewrote rule for local copy of
+ sigc++config.h (required for 'make distcheck').
+ * MSVC_Net2003/libsigc++2_msvcNet2003.sln: Added test_retype and
+ test_disconnect_during_emit tests.
+ * MSVC_Net2003/tests/test_disconnect_during_emit/*,
+ MSVC_Net2003/tests/test_retype/*: Initial commit.
+
+2005-01-21 Murray Cumming <murrayc@murrayc.com>
+
+ * tests/: Disabled the test_accumulator, test_bind, and test_compose
+ tests, and part of test_mem_fun because the AIX xlC compiler can not
+ build them, but it can still do most things, including the examples.
+ See the comments in tests/Makefile.am.
+
+2005-01-21 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/adaptors/bind.h.m4: non-member operator()(): Specify the
+ extra nil arguments in the templated class name prefix. Oddly, the
+ AIX xlC compiler says that the type of the first parameter does not
+ match the template if you don't do this.
+
+2005-01-21 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/type_traits.h: is_base_and_derived struct: Move the
+ is_base_class_() functions out of the inner class, because the AIX
+ xlC compiler does not like that - see the comments in the code.
+ * sigc++/adaptors/bind.h.m4: Add the extra nil template types to
+ the template specializations, as in slot and signal.
+
+2005-01-21 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/macros/slot.h.m4, sigc++/macros/signal.h.m4:
+ slot and signal template specialization for
+ various numbers of template args: In the class slot line, specify
+ all the remaining template types as null, instead of expecting the
+ compiler to guess them in itself. This partly fixes the build on
+ AIX with the xlC compiler. Bug #164685.
+
+2005-01-19 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/type_traits: struct is_base_and_derived: Make the test inner
+ struct a friend, so that it can use the big inner struct. This is
+ required by the Tru64 compiler.
+ * sigc++/adaptors/lambda/base.h: Put the unwrap_lambda_value()
+ definitions at the top, because Tru64 (understandably) needs them to
+ be declared before use.
+
+2005-01-19 Murray Cumming <murrayc@murrayc.com>
+
+ * scripts/: Added cxx_std.m4, with a test copied from
+ glibmm/scripts/cxx_std.m4 to check if the compiler has the std::
+ namespace.
+ * sigcconfig.h: #undef the new #define and add SIGC_USING_STD(),
+ like GLIBMM_USING_STD, to put stuff in the std:: namespace when it
+ is not there already,
+ * configure.in: Used the new test.
+ * tests/*: Uses SIG_USING_STD() for every std:: thing that we use.
+ This is needed by the Tru64 and HP-UX compilers when using their
+ defaults.
+
+2005-01-19 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.in: AC_INIT(): Provide the extra tarball name parameter,
+ so that it does not create a libsigc--- tarball.
+
+2005-01-19 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.in: AC_INIT(): Use libsigc++ instead of sigc++, attempting
+ to get the correct tarball name.
+
+2005-01-18 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.in: Used the autoconf 2.93 and AM_INIT_AUTOMAKE()
+ technique to specify ustar format for the tarball, to prevent files
+ with long file names from appearing at the top of the tarball.
+ Based on the same fix in gtkmm 2.6.
+
+2005-01-18 Murray Cumming <murrayc@murrayc.com>
+
+ * sigc++/functors/macros/slot_h.m4: Specify the base class when
+ using the rep_ member variable. This stops the HP-UX aCC compiler
+ from saying that a Nonstatic member is referenced in a nested class,
+ local class or static member initializer. Bug #150719.
+
+2005-01-18 Murray Cumming <murrayc@murrayc.com>
+
+ * Bug #159597 - patch from e97_far at e.kth.se to replace C-style
+ casts with reinterpret_cast<> and static_cast<> to avoid warnings.
+
+2005-01-17 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/manual/Makefile.am: Specifying html/index.html instead of
+ just the html directory as a target seems to fix distcheck problems.
+ I can also now confirm that the install works on solaris, when using
+ gmake, though not when using make.
+
+2005-01-17 Murray Cumming <murrayc@murrayc.com>
+
+ * MSVC_Net2004/Makefile.am: Add built files to DISTCLEANFILES to fix
+ the distcheck.
+ * docs/reference/Makefile.am, manual/Makefile.am: Specify $srcdir in
+ paths, to fix distcheck of the manual, and maybe fix install problems
+ on Solaris.
+
+2005-01-11 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/website/stable.html: Updated the text about binary packages.
+ * docs/website/docs.html: Link to the 2.0 documentation instead of the
+ 1.2 documentation.
+
+2004-12-17 GregSchussman <schussman@slac.stanford.edu>
+
+ * glossary.shtml: Clean up punctuation, make definitions complete
+ sentences, and add clarifications for certain definitions according to
+ what Murray Cumming's suggestions and answers to my questions.
+ Bug #161580.
+
+2005-01-11 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/: Added manual, copied from the libsigc++-1.2 cvs module,
+ and updated it for the new 2.0 API.
+
+2005-01-11 Murray Cumming <murrayc@murrayc.com>
+
+ * docs/: Added website, copied from the libsigc++-1.2 cvs module.
+ We will use it from here from now on.
+
+2004-12-11 Cedric Gustin <cedric.gustin@swing.be>
+
+ * configure.ac : parse version tags at configure time (for
+ sigc-2.0.rc).
+ * MSVC_Net2003/sigc-2.0.rc.in : New resource file.
+ * MSVC_Net2003/Makefile.am: include sigc-2.0.rc in distribution.
+
+2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
+
+ * MSVC_Net2003/Makefile.am: get sigc++config.h from $(top_builddir)
+ instead of $(top_srcdir).
+
+2004-12-08 Cedric Gustin <cedric.gustin@swing.be>
+
+ * MSVC_Net2003/*/*.vcproj: Renamed libsigc++ target to
+ sigc-2.0d.dll (Debug) and sigc-2.0.dll (Release). Added
+ $(SolutionDir) and $(SolutionDir)\.. to "Additional Include
+ Directories" in tests projects.
+ * sigc++config.h.in: Rewrote dllexport/dllimport macros for
+ MSVC, for better consistency with glibmm/gtkmm.
+ * MSVC_Net2003/Makefile.am: copy sigc++config.h from $(top_srcdir)
+ at build time.
+
+2004-11-27 Murray Cumming <murrayc@murrayc.com>
+
+ * configure.in: Revert the AC_PROG_LIBTOOL change, so that this builds
+ with actually released libtool versions, and in jhbuild, so that it
+ gets testing.
+
+2004-11-06 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * sigc++/adaptors/macros/exception_catch.h.m4: Make catcher_ member
+ public so that it can be accessed by visit_each() (bug reported on
+ ml by Philip Langdale <plangdale@vmware.com>).
+
+2004-10-24 Martin Schulze <mschulze@cvs.gnome.org>
+
+ * MSVC_Net2003/*/*.vcproj: Link with the "multithreaded DLL" runtime
+ libraries and enable RTTI for the MSVC build
+ (patch from Timothy M. Shead <tshead@k-3d.com>).
+ * MSVC_Net2003/*/.cvsignore: Hide generated build files from cvs
+ (patch from Timothy M. Shead <tshead@k-3d.com>).
+
+2.0.6:
+
2004-10-12 Martin Schulze <mschulze@cvs.gnome.org>
* MSVC_Net2003/*/*.vcproj, MSVC_Net2003/blank.cpp: Fix project files
# ACLOCAL_FLAGS = -I scripts
SUBDIRS = sigc++
-DIST_SUBDIRS = $(SUBDIRS)
+DIST_SUBDIRS = $(SUBDIRS)
sigc_configdir = $(libdir)/sigc++-2.0/include
sigc_config_DATA = sigc++config.h
echo "**********************************************************"; \
echo; echo \
cp libsigc++-2.0.spec $(distdir)
+
-*** libsigc++ 2.0:
+2.0.17:
+
+* slot::disconnect(): Make this work.
+ sigc::connection::disconnect() already worked.
+ (James Lin, Murray Cumming)
+* visit_each compilation problem fixed.
+ (Philipp Berndt)
+
+2.0.16:
+
+* Fixed build for SUN Forte C++ 5.5
+* Fixed build for MSVC++ 7.1
+* Fixed crash when using --no-inline with g++.
+
+2.0.15:
+
+* g++ 3.2 (and Mac OS X g++ 3.3) build fix.
+ (Paul Pogonyshev)
+* Compose: Fix slot lifetime regression introduced in
+ 2.0.9. (Philip Langdale)
+* tests: Small ISO C++ correctness fix (Marek Rouchal)
+* Don't specify unused function parameter names.
+ (Andris Pavenis)
+
+2.0.14:
+
+* SUN Forte 5.7 build fix for ambiguity when using
+ inner template class. However, you still need the
+ patch in bug #302098 to finish the build.
+
+2.0.13:
+
+* signal_emit::emit(): Ensure the correct order of
+ destruction of the member variables, to avoid a leak.
+ (Andreas Ames, bug #306249)
+* Allow recursive signal emission again.
+ (Neal E. Coombes, bug #303896)
+* SUN Forte CC 5.5 build fixes:
+ - test_compatibility minor fix.
+ - visit_each() template specializations:
+ Mention the bool I_derives_trackable template type,
+ (Friedemann Kleint, bug #305647)
+ - Check for the non-standard SUN reverse_iterator,
+ and use alternative code if necessary.
+ (Murray Cumming)
+
+2.0.12:
+
+* Fixes crashes when using virtual inheritance, particularly
+ with bound by-reference parameters, caused by casting
+ from derived to base when the derived destructor has run.
+ (Régis Duchesne)
+ This might affect non-g++ compilers, so do tell us about
+ any problems.
+
+2.0.11:
+
+* Build fixes for SUN Forte, Tru64
+ (Murray Cumming), and MSVC++ (Cedric Gustin).
+
+2.0.10:
+
+* tests: Include <new> to avoid unresolved symbols on Tru64.
+ (Tim Mooney)
+* When signal handlers are connected made during an emit
+ of the same signal, prevent them from being called in the
+ same emit, to prevent infinite loops.
+ (Neal E. Coombes)
+* Performance improvement in a corner case.
+ (Neal E. Coombes).
+
+2.0.9:
+
+* sigc::bind() now works with the AIX and Tru64 compilers.
+ See the comments in sigc++/visit_each.h: visit_each_type()
+ if you have compilation problems.
+ (Murray Cumming)
+* sigc::var() is now documented. (Roger Ferrer Ibáñez)
+
+2.0.8:
+
+* Maybe avoid (incorrect) warning with g++ 3.3.5.
+ (Murray Cumming)
+* Fix namespace ambiguity when using multiple
+ major versions of libsigc++. (Liza Klerck)
+
+2.0.7:
+
+* Now builds with the following compilers, in addition to
+the existing GNU g++, SUN Forte CC 5.5, MSVC++ .Net 2003,
+and Intel compilers:
+- IBM AIX xlC v7
+- Tru64 C++ V6.5-042
+- IRIX MIPSpro 7.4.2m
+ (Older versions of all these compilers might also work.)
+ (Murray Cumming, www.thewrittenword.com)
+* MSVC++ .Net 2003 build improvements.
+ (Cedric Gustin, Timothy M. Shead)
+* Replace C-style casts with reinterpret_cast<> and
+ static_cast<>. (e97_far at e.kth.se).
+* Documentation: Added manual, based on the manual in
+ libsigc++ 1.2, but updated for the new API.
+ (Murray Cumming)
-libsigc++ implements a typesafe callback system for standard C++. It
-allows you to define signals and to connect those signals to any
-callback function, either global or a member function, regardless of
-whether it is static or virtual.
-
-libsigc++ is used by gtkmm to wrap the GTK+ signal system. It does not depend
-on GTK or gtkmm.
-
-libsigc++ 2.0 uses modern C++ mechanisms to achieve a highly flexible,
-yet typesafe callback system. It supports all features of libsigc++ 1.2
-and improves upon it with a simpler and more powerful API.
-
-This version of libsigc++ needs GNU g++ 3.2 or higher to compile.
-
-
-*** ChangeLog summary:
2.0.6:
srcdir=`dirname $0`
test -z "$srcdir" && srcdir=.
-#echo "Adding libtools."
-#libtoolize --automake --copy --force
+PKG_NAME="sigc++"
+
+echo "Adding libtools."
+libtoolize --automake --copy --force
echo "Building macros."
aclocal -I "$srcdir/scripts" $ACLOCAL_FLAGS
+#echo "Building config header."
+#autoheader
+
echo "Building makefiles."
automake --add-missing --copy
dnl Source for generating compiler independent libraries.
dnl
-dnl INIT is required name a file which is unique to the package
+#We use pushdef here because we can't use shell variables before AC_INIT, but we want to use a variable with AC_INIT:
+dnl thus make format_package-0.0.1.tar.gz
+pushdef([FP_MAJOR_VERSION], [2])
+pushdef([FP_MINOR_VERSION], [0])
+pushdef([FP_MICRO_VERSION], [17])
+pushdef([FP_EXTRA_VERSION], [])
+pushdef([FP_VERSION], FP_MAJOR_VERSION.FP_MINOR_VERSION.FP_MICRO_VERSION[]FP_EXTRA_VERSION)
+# package name, version, support contact, tarball name.
+AC_INIT([libsigc++], FP_VERSION, [libsigc-list@gnome.org], [libsigc++])
+
+dnl AC_CONFIG_SRCDIR is required name a file which is unique to the package
dnl just to prevent someone from copying the configure to the wrong package.
-AC_INIT(sigc++)
+AC_CONFIG_SRCDIR([sigc++])
+
+AC_PREREQ(2.59)
-dnl This version stuff is just for the packaging section of the tool.
-dnl thus make format_package-0.0.1.tar.gz
-FP_MAJOR_VERSION=2
-FP_MINOR_VERSION=0
-FP_MICRO_VERSION=6
-FP_VERSION=$FP_MAJOR_VERSION.$FP_MINOR_VERSION.$FP_MICRO_VERSION
+#########################################################################
+# Version and initialization
+#########################################################################
+[FP_MAJOR_VERSION]=FP_MAJOR_VERSION
+[FP_MINOR_VERSION]=FP_MINOR_VERSION
+[FP_MICRO_VERSION]=FP_MICRO_VERSION
+[FP_EXTRA_VERSION]=FP_EXTRA_VERSION
+[FP_VERSION]=FP_VERSION
+popdef([FP_MAJOR_VERSION])
+popdef([FP_MINOR_VERSION])
+popdef([FP_MICRO_VERSION])
+popdef([FP_EXTRA_VERSION])
+popdef([FP_VERSION])
+FP_RELEASE=$FP_MAJOR_VERSION.$FP_MINOR_VERSION
+AC_DEFINE_UNQUOTED(FP_MAJOR_VERSION, $FP_MAJOR_VERSION, [Major version of libsigc++])
+AC_DEFINE_UNQUOTED(FP_MINOR_VERSION, $FP_MINOR_VERSION, [Minor version of libsigc++])
+AC_DEFINE_UNQUOTED(FP_MICRO_VERSION, $FP_MICRO_VERSION, [Micro version of libsigc++])
+AC_SUBST(FP_VERSION)
+AC_SUBST(FP_RELEASE)
+AC_SUBST(FP_MAJOR_VERSION)
+AC_SUBST(FP_MINOR_VERSION)
+AC_SUBST(FP_MICRO_VERSION)
dnl For automake.
VERSION=$FP_VERSION
PACKAGE=libsigc++
-dnl Initialize automake stuff
-AM_INIT_AUTOMAKE($PACKAGE, $VERSION)
+# Initialize automake stuff
+# tar-ustar asks it to use a sensible tar format that can handle long filenames.
+AM_INIT_AUTOMAKE([1.9 tar-ustar])
dnl Specify a configuration file:
AC_CONFIG_HEADER(sigc++config.h)
+dnl Macros to support windows platforms
+AC_CYGWIN
+#AC_MINGW32
+AC_EXEEXT
+
+dnl this package needs m4
+AC_CHECK_PROGS(M4, gm4 m4, m4)
+
dnl disable autoheader
AUTOHEADER=':'
AC_PROG_CC
AC_PROG_CPP
+dnl Used for enabling the "-no-undefined" flag while generating DLLs
+dnl Borrowed from the official gtk+-2 configure.in
+AC_MSG_CHECKING([for some Win32 platform])
+case "$host" in
+ *-*-mingw*|*-*-cygwin*)
+ platform_win32=yes
+ ;;
+ *)
+ platform_win32=no
+ ;;
+esac
+AC_MSG_RESULT([$platform_win32])
+AM_CONDITIONAL(PLATFORM_WIN32, test "$platform_win32" = "yes")
+
dnl Using libtool
AC_CONFIG_MACRO_DIR(scripts)
-dnl LT_INIT
-dnl AM_PROG_LIBTOOL
+AC_LIBTOOL_WIN32_DLL
+dnl: Use with libtool 1.5a instead of AM_PROG_LIBTOOL: LT_INIT
+AM_PROG_LIBTOOL
dnl Using C++ compiler
AC_PROG_CXX
AC_LANG_CPLUSPLUS
SIGC_CXX_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD()
+SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION()
+SIGC_CXX_HAS_NAMESPACE_STD()
+SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
if test "X$config_error" = "Xyes" ; then
AC_ERROR(
sigc++/Makefile
libsigc++-2.0.spec
+
])
AC_MSG_RESULT([$sigcm_cxx_gcc_template_specialization_operator_overload])
])
])
+
AC_DEFUN([SIGC_CXX_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD],[
AC_MSG_CHECKING([if C++ compiler supports the use of a particular specialization when calling operator() template methods omitting the template keyword.])
AC_TRY_COMPILE(
AC_MSG_RESULT([$sigcm_cxx_msvc_template_specialization_operator_overload])
])
])
+
+
+AC_DEFUN([SIGC_CXX_SELF_REFERENCE_IN_MEMBER_INITIALIZATION], [
+AC_MSG_CHECKING([if C++ compiler allows usage of member function in initialization of static member field.])
+AC_TRY_COMPILE(
+[
+ struct test
+ {
+ static char test_function();
+
+ // Doesn't work with e.g. GCC 3.2. However, if test_function()
+ // is wrapped in a nested structure, it works just fine.
+ static const bool test_value
+ = (sizeof(test_function()) == sizeof(char));
+ };
+],
+[],
+[
+ sigcm_cxx_self_reference_in_member_initialization=yes
+ AC_DEFINE([SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION],[1],
+ [does c++ compiler allows usage of member function in initialization of static member field.])
+ AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
+],[
+ sigcm_cxx_self_reference_in_member_initialization=no
+ AC_MSG_RESULT([$sigcm_cxx_self_reference_in_member_initialization])
+])
+])
--- /dev/null
+cv_cxx_has_namespace_std
+## SIGC_CXX_HAS_NAMESPACE_STD()
+##
+## Test whether libstdc++ declares namespace std. For safety,
+## also check whether several randomly selected STL symbols
+## are available in namespace std.
+##
+## On success, #define SIGC_HAVE_NAMESPACE_STD to 1.
+##
+AC_DEFUN([SIGC_CXX_HAS_NAMESPACE_STD],
+[
+ AC_CACHE_CHECK(
+ [whether C++ library symbols are declared in namespace std],
+ [sigc_cv_cxx_has_namespace_std],
+ [
+ AC_TRY_COMPILE(
+ [
+ #include <algorithm>
+ #include <iterator>
+ #include <iostream>
+ #include <string>
+ ],[
+ using std::min;
+ using std::find;
+ using std::copy;
+ using std::bidirectional_iterator_tag;
+ using std::string;
+ using std::istream;
+ using std::cout;
+ ],
+ [sigc_cv_cxx_has_namespace_std="yes"],
+ [sigc_cv_cxx_has_namespace_std="no"]
+ )
+ ])
+
+ if test "x${sigc_cv_cxx_has_namespace_std}" = "xyes"; then
+ {
+ AC_DEFINE([SIGC_HAVE_NAMESPACE_STD],[1], [Defined when the libstdc++ declares the std-namespace])
+ }
+ fi
+])
+
+## SIGC_CXX_HAS_SUN_REVERSE_ITERATOR()
+##
+## Check for Sun libCstd style std::reverse_iterator, which demands more than just one template parameter.
+## and #define SIGC_HAVE_SUN_REVERSE_ITERATOR if found.
+##
+AC_DEFUN([SIGC_CXX_HAS_SUN_REVERSE_ITERATOR],
+[
+ AC_REQUIRE([SIGC_CXX_HAS_NAMESPACE_STD])
+
+ AC_CACHE_CHECK(
+ [for non-standard Sun libCstd reverse_iterator],
+ [sigc_cv_cxx_has_sun_reverse_iterator],
+ [
+ AC_TRY_COMPILE(
+ [
+ #include <iterator>
+ #ifdef SIGC_HAVE_NAMESPACE_STD
+ using namespace std;
+ #endif
+ ],[
+ typedef reverse_iterator<char*,random_access_iterator_tag,char,char&,char*,int> ReverseIter;
+ ],
+ [sigc_cv_cxx_has_sun_reverse_iterator="yes"],
+ [sigc_cv_cxx_has_sun_reverse_iterator="no"]
+ )
+ ])
+
+ if test "x${sigc_cv_cxx_has_sun_reverse_iterator}" = "xyes"; then
+ {
+ AC_DEFINE([SIGC_HAVE_SUN_REVERSE_ITERATOR],[1])
+ }
+ fi
+])
+
+
+++ /dev/null
-# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
-
-m4_define([_LT_COPYING], [dnl
-# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
-# Free Software Foundation, Inc.
-#
-# This file is part of GNU Libtool:
-# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-])
-
-# serial 49 LT_INIT
-
-
-# LT_PREREQ(VERSION)
-# ------------------
-# Complain and exit if this libtool version is less that VERSION.
-m4_define([LT_PREREQ],
-[m4_if(m4_version_compare(m4_defn([LT_PACKAGE_VERSION]), [$1]), -1,
- [m4_default([$3],
- [m4_fatal([Libtool version $1 or higher is required],
- 63)])],
- [$2])])
-
-
-# LT_INIT([OPTIONS])
-# --------------------------
-AC_DEFUN([LT_INIT],
-[AC_PREREQ([2.58])dnl We use AC_INCLUDES_DEFAULT
-dnl Autoconf doesn't catch unexpanded LT_ macros by default:
-m4_pattern_forbid([^_?LT_[A-Z_]+$])dnl
-m4_pattern_allow([^(_LT_EOF|LT_DLGLOBAL|LT_DLLAZY_OR_NOW)$])dnl
-dnl aclocal doesn't pull ltoptions.m4, ltsugar.m4, or ltversion.m4
-dnl unless we require an AC_DEFUNed macro:
-AC_REQUIRE([LTOPTIONS_VERSION])dnl
-AC_REQUIRE([LTSUGAR_VERSION])dnl
-AC_REQUIRE([LTVERSION_VERSION])dnl
-AC_REQUIRE([_LT_PROG_LTMAIN])dnl
-AC_BEFORE([$0], [LT_LANG])dnl
-
-# This can be used to rebuild libtool when needed
-LIBTOOL_DEPS="$ltmain"
-
-# Always use our own libtool.
-LIBTOOL='$(SHELL) $(top_builddir)/libtool'
-AC_SUBST(LIBTOOL)dnl
-
-# Set options
-_LT_SET_OPTIONS([$1])dnl
-
-_LT_SETUP
-
-# Only expand once:
-m4_define([LT_INIT])
-])# _LT_INIT
-
-# Old names:
-AU_DEFUN([AC_PROG_LIBTOOL], [LT_INIT])
-AU_DEFUN([AM_PROG_LIBTOOL], [LT_INIT])
-
-
-# _LT_SETUP
-# ---------
-m4_define([_LT_SETUP],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-_LT_DECL([], [host_alias], [0], [The host system])dnl
-_LT_DECL([], [host], [0])dnl
-dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_PROG_LD])dnl
-AC_REQUIRE([AC_PROG_LD_RELOAD_FLAG])dnl
-AC_REQUIRE([AC_PROG_NM])dnl
-dnl
-AC_REQUIRE([AC_PROG_LN_S])dnl
-test -z "$LN_S" && LN_S="ln -s"
-_LT_DECL([], [LN_S], [1], [Whether we need soft or hard links])dnl
-dnl
-AC_REQUIRE([AC_DEPLIBS_CHECK_METHOD])dnl
-AC_REQUIRE([AC_LIBTOOL_SYS_OLD_ARCHIVE])dnl
-AC_REQUIRE([AC_LIBTOOL_SYS_MAX_CMD_LEN])dnl
-AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl
-AC_REQUIRE([AC_OBJEXT])dnl
-_LT_DECL([objext], [ac_objext], [0], [Object file suffix (normally "o")])dnl
-AC_REQUIRE([AC_EXEEXT])dnl
-_LT_DECL([], [exeext], [0], [Executable file suffix (normally "")])dnl
-dnl
-
-_LT_CONFIG_LIBTOOL_INIT([
-# See if we are running on zsh, and set the options which allow our
-# commands through without removal of \ escapes INIT.
-if test -n "\${ZSH_VERSION+set}" ; then
- setopt NO_GLOB_SUBST
-fi
-])
-if test -n "${ZSH_VERSION+set}" ; then
- setopt NO_GLOB_SUBST
-fi
-
-AC_LIBTOOL_OBJDIR
-
-AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
-_LT_AC_PROG_ECHO_BACKSLASH
-
-case $host_os in
-aix3*)
- # AIX sometimes has problems with the GCC collect2 program. For some
- # reason, if we set the COLLECT_NAMES environment variable, the problems
- # vanish in a puff of smoke.
- if test "X${COLLECT_NAMES+set}" != Xset; then
- COLLECT_NAMES=
- export COLLECT_NAMES
- fi
- ;;
-esac
-
-# Sed substitution that helps us do robust quoting. It backslashifies
-# metacharacters that are still active within double-quoted strings.
-Xsed='sed -e s/^X//'
-[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
-
-# Same as above, but do not quote variable references.
-[double_quote_subst='s/\([\\"\\`\\\\]\)/\\\1/g']
-
-# Sed substitution to delay expansion of an escaped shell variable in a
-# double_quote_subst'ed string.
-delay_variable_subst='s/\\\\\\\\\\\$/\\\\\\$/g'
-
-# Sed substitution to delay expansion of an escaped single quote.
-delay_single_quote_subst='s/'\''/'\'\\\\\\\'\''/g'
-
-# Sed substitution to avoid accidental globbing in evaled expressions
-no_glob_subst='s/\*/\\\*/g'
-
-# Constants:
-rm="rm -f"
-
-# Global variables:
-default_ofile=libtool
-ofile="$default_ofile"
-can_build_shared=yes
-
-# All known linkers require a `.a' archive for static linking (except M$VC,
-# which needs '.lib').
-libext=a
-
-with_gnu_ld="$lt_cv_prog_gnu_ld"
-
-old_CC="$CC"
-old_CFLAGS="$CFLAGS"
-
-# Set sane defaults for various variables
-test -z "$CC" && CC=cc
-test -z "$LTCC" && LTCC=$CC
-test -z "$LD" && LD=ld
-test -z "$ac_objext" && ac_objext=o
-
-cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
-
-# Only perform the check for file, if the check method requires it
-test -z "$MAGIC_CMD" && MAGIC_CMD=file
-case $deplibs_check_method in
-file_magic*)
- if test "$file_magic_cmd" = '$MAGIC_CMD'; then
- AC_PATH_MAGIC
- fi
- ;;
-esac
-
-AC_ARG_ENABLE([libtool-lock],
- [AC_HELP_STRING([--disable-libtool-lock],
- [avoid locking (might break parallel builds)])])
-test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
-
-# Use C for the default configuration in the libtool script
-_LT_LANG_C_CONFIG
-_LT_LANG_DEFAULT_CONFIG
-_LT_CONFIG_COMMANDS
-])# _LT_SETUP
-
-
-# _LT_PROG_LTMAIN
-# ---------------
-# In libtool itself `ltmain.sh' is in the build tree, but everything else
-# ships it in the source tree, for completeness, if we find a copy in the
-# build tree use that before falling back to auxdir.
-#
-# Note that this code is called both from `configure', and `config.status'
-# now that we use AC_CONFIG_COMMANDS to generate libtool. Notably,
-# `config.status' has no value for ac_aux_dir unless we are using Automake,
-# so we pass a copy along to make sure it has a sensible value anyway.
-AC_DEFUN([_LT_PROG_LTMAIN],
-[_LT_CONFIG_LIBTOOL_INIT([ac_aux_dir='$ac_aux_dir'])
-case $ac_aux_dir in
- $srcdir) ltmain=./ltmain.sh ;;
- $srcdir/*) ltmain=`expr "$ac_aux_dir" : "$srcdir/\(.*\)"`/ltmain.sh ;;
-esac
-test -f "$ltmain" || ltmain="$ac_aux_dir/ltmain.sh"
-])# _LT_PROG_LTMAIN
-
-
-
-## ------------------------------------- ##
-## Accumulate code for creating libtool. ##
-## ------------------------------------- ##
-
-# So that we can recreate a full libtool script including additional
-# tags, we accumulate the chunks of code to send to AC_CONFIG_COMMANDS
-# in macros and then make a single call at the end using the `libtool'
-# label.
-
-# _LT_CONFIG_LIBTOOL_INIT([INIT-COMMANDS])
-# ----------------------------------------
-# Register INIT-COMMANDS to be passed to AC_CONFIG_COMMANDS later.
-m4_define([_LT_CONFIG_LIBTOOL_INIT],
-[m4_ifval([$1],
- [m4_append([_LT_OUTPUT_LIBTOOL_INIT],
- [$1
-])])])
-
-# Initialize.
-m4_define([_LT_OUTPUT_LIBTOOL_INIT])
-
-# _LT_CONFIG_LIBTOOL([COMMANDS])
-# ------------------------------
-# Register COMMANDS to be passed to AC_CONFIG_COMMANDS later.
-m4_define([_LT_CONFIG_LIBTOOL],
-[m4_ifval([$1],
- [m4_append([_LT_OUTPUT_LIBTOOL_COMMANDS],
- [$1
-])])])
-
-# Initialize.
-m4_define([_LT_OUTPUT_LIBTOOL_COMMANDS])
-
-
-# _LT_CONFIG_SAVE_COMMANDS([COMMANDS], [INIT_COMMANDS])
-# ---------------------------------------------------
-m4_define([_LT_CONFIG_SAVE_COMMANDS],
-[_LT_CONFIG_LIBTOOL([$1])
-_LT_CONFIG_LIBTOOL_INIT([$2])
-])
-
-
-# _LT_FORMAT_COMMENT([COMMENT])
-# -----------------------------
-# Add leading comment marks to the start of each line, and a trailing
-# full-stop to the whole comment if one is not present already.
-m4_define([_LT_FORMAT_COMMENT],
-[m4_ifval([$1], [
-m4_bpatsubst([$1], [^ *], [# ])]m4_bmatch([$1], [[!?.]$], [], [.])
-)])
-
-
-
-## ------------------------ ##
-## FIXME: Eliminate VARNAME ##
-## ------------------------ ##
-
-# _LT_DECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION], [IS-TAGGED?])
-# -------------------------------------------------------------------
-# CONFIGNAME is the name given to the value in the libtool script.
-# VARNAME is the (base) name used in the configure script.
-# VALUE may be 0, 1 or 2 for a computed quote escaped value based on
-# VARNAME. Any other value will be used directly.
-m4_define([_LT_DECL],
-[lt_if_append_uniq([lt_decl_varnames], [$2], [[, ]],
- [lt_dict_add_subkey([lt_decl_dict], [$2], [libtool_name],
- [m4_ifval([$1], [$1], [$2])])
- lt_dict_add_subkey([lt_decl_dict], [$2], [value], [$3])
- m4_ifval([$4],
- [lt_dict_add_subkey([lt_decl_dict], [$2], [description], [$4])])
- lt_dict_add_subkey([lt_decl_dict], [$2],
- [tagged?], [m4_ifval([$5], [yes], [no])])])
-])
-
-
-# _LT_TAGDECL([CONFIGNAME], VARNAME, VALUE, [DESCRIPTION])
-# --------------------------------------------------------
-m4_define([_LT_TAGDECL], [_LT_DECL([$1], [$2], [$3], [$4], [yes])])
-
-
-# lt_decl_tag_varnames([SEPARATOR], [VARNAME1...])
-# -------------------------------------------------
-m4_define([lt_decl_tag_varnames],
-[_lt_decl_filter([tagged?], [yes], $@)])
-m4_define([_lt_decl_filter],
-[m4_case([$#],
- [0], [m4_fatal([$0: too few arguments: $#])],
- [1], [m4_fatal([$0: too few arguments: $#: $1])],
- [2], [lt_dict_filter([lt_decl_dict], [$1], [$2], [], lt_decl_varnames)],
- [3], [lt_dict_filter([lt_decl_dict], [$1], [$2], [$3], lt_decl_varnames)],
- [lt_dict_filter([lt_decl_dict], $@)])[]dnl
-])
-
-
-# lt_decl_quote_varnames([SEPARATOR], [VARNAME1...])
-# ---------------------------------------------------
-m4_define([lt_decl_quote_varnames],
-[_lt_decl_filter([value], [1], $@)])
-
-# lt_decl_dquote_varnames([SEPARATOR], [VARNAME1...])
-# ----------------------------------------------------
-m4_define([lt_decl_dquote_varnames],
-[_lt_decl_filter([value], [2], $@)])
-
-
-# lt_decl_varnames_tagged([SEPARATOR], [VARNAME1...])
-# ----------------------------------------------------
-m4_define([lt_decl_varnames_tagged],
-[_$0(m4_quote(m4_default([$1], [[, ]])),
- m4_quote(m4_if([$2], [],
- m4_quote(lt_decl_tag_varnames),
- m4_quote(m4_shift($@)))),
- m4_split(m4_normalize(m4_quote(_LT_TAGS))))])
-m4_define([_lt_decl_varnames_tagged], [lt_combine([$1], [$2], [_], $3)])
-
-
-# lt_decl_all_varnames([SEPARATOR], [VARNAME1...])
-# ------------------------------------------------
-m4_define([lt_decl_all_varnames],
-[_$0(m4_quote(m4_default([$1], [[, ]])),
- m4_if([$2], [],
- m4_quote(lt_decl_varnames),
- m4_quote(m4_shift($@))))[]dnl
-])
-m4_define([_lt_decl_all_varnames],
-[lt_join($@, lt_decl_varnames_tagged([$1],
- lt_decl_tag_varnames([[, ]], m4_shift($@))))dnl
-])
-
-
-# _LT_CONFIG_STATUS_DECLARE([VARNAME])
-# ------------------------------------
-# Quote a variable value, and forward it to `config.status' so that its
-# declaration there will have the same value as in `configure'. VARNAME
-# must have a single quote delimited value for this to work.
-m4_define([_LT_CONFIG_STATUS_DECLARE],
-[$1='`$echo "X$][$1" | $Xsed -e "$delay_single_quote_subst"`'])
-
-
-# _LT_CONFIG_STATUS_DECLARATIONS
-# ------------------------------
-# We delimit libtool config variables with single quotes, so when
-# we write them to config.status, we have to be sure to quote all
-# embedded single quotes properly. In configure, this macro expands
-# each variable declared with _LT_DECL (and _LT_TAGDECL) into:
-#
-# <var>='`$echo "X$<var>" | $Xsed -e "$delay_single_quote_subst"`'
-m4_define([_LT_CONFIG_STATUS_DECLARATIONS],
-[m4_foreach([_lt_var], m4_quote(lt_decl_all_varnames),
- [m4_n([_LT_CONFIG_STATUS_DECLARE(_lt_var)])])])
-
-
-# _LT_LIBTOOL_TAGS
-# ----------------
-# Output comment and list of tags supported by the script
-m4_define([_LT_LIBTOOL_TAGS],
-[_LT_FORMAT_COMMENT([The names of the tagged configurations supported by this script])dnl
-available_tags="[]_LT_TAGS[]"dnl
-])
-
-# _LT_LIBTOOL_DECLARE(VARNAME, [TAG])
-# -----------------------------------
-# Extract the dictionary values for VARNAME (optionally with TAG) and
-# expand to a commented shell variable setting:
-#
-# # Some comment about what VAR is for.
-# visible_name=$lt_internal_name
-m4_define([_LT_LIBTOOL_DECLARE],
-[_LT_FORMAT_COMMENT(m4_quote(lt_dict_fetch([lt_decl_dict], [$1],
- [description])))[]dnl
-m4_pushdef([_libtool_name],
- m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [libtool_name])))[]dnl
-m4_case(m4_quote(lt_dict_fetch([lt_decl_dict], [$1], [value])),
- [0], [_libtool_name=[$]$1],
- [1], [_libtool_name=$lt_[]$1],
- [2], [_libtool_name=$lt_[]$1],
- [_libtool_name=lt_dict_fetch([lt_decl_dict], [$1], [value])])[]dnl
-m4_ifval([$2], [_$2])[]m4_popdef([_libtool_name])[]dnl
-])
-
-# _LT_LIBTOOL_CONFIG_VARS
-# -----------------------
-# Produce commented declarations of non-tagged libtool config variables
-# suitable for insertion in the LIBTOOL CONFIG section of the `libtool'
-# script. Tagged libtool config variables (even for the LIBTOOL CONFIG
-# section) are produced by _LT_LIBTOOL_TAG_VARS.
-m4_define([_LT_LIBTOOL_CONFIG_VARS],
-[m4_foreach([_lt_var],
- m4_quote(_lt_decl_filter([tagged?], [no], [], lt_decl_varnames)),
- [m4_n([_LT_LIBTOOL_DECLARE(_lt_var)])])])
-
-# _LT_LIBTOOL_TAG_VARS(TAG)
-# -------------------------
-m4_define([_LT_LIBTOOL_TAG_VARS],
-[m4_foreach([_lt_var], m4_quote(lt_decl_tag_varnames),
- [m4_n([_LT_LIBTOOL_DECLARE(_lt_var, [$1])])])])
-
-
-# _LT_AC_TAGVAR(VARNAME, [TAGNAME])
-# ---------------------------------
-m4_define([_LT_AC_TAGVAR], [m4_ifval([$2], [$1_$2], [$1])])
-
-
-# _LT_CONFIG_COMMANDS
-# -------------------
-# Send accumulated output to $CONFIG_STATUS. Thanks to the lists of
-# variables for single and double quote escaping we saved from calls
-# to _LT_DECL, we can put quote escaped variables declarations
-# into `config.status', and then the shell code to quote escape them in
-# for loops in `config.status'. Finally, any additional code accumulated
-# from calls to _LT_CONFIG_LIBTOOL_INIT is expanded.
-m4_define([_LT_CONFIG_COMMANDS],
-[AC_CONFIG_COMMANDS([libtool], [_LT_OUTPUT_LIBTOOL_COMMANDS], [
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-if test "X${CDPATH+set}" = Xset; then CDPATH=${ZSH_VERSION+.}:; export CDPATH; fi
-
-sed_quote_subst='$sed_quote_subst'
-double_quote_subst='$double_quote_subst'
-delay_variable_subst='$delay_variable_subst'
-_LT_CONFIG_STATUS_DECLARATIONS
-LTCC='$LTCC'
-compiler='$compiler_DEFAULT'
-
-# Quote evaled strings.
-for var in lt_decl_all_varnames([[ ]], lt_decl_quote_varnames); do
- eval "lt_\$var=\\\\\\"\\\`\\\$echo \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$sed_quote_subst\\"\\\`\\\\\\""
-done
-
-# Double-quote double-evaled strings.
-for var in lt_decl_all_varnames([[ ]], lt_decl_dquote_varnames); do
- eval "lt_\$var=\\\\\\"\\\`\\\$echo \\"X\\\$\$var\\" | \\\$Xsed -e \\"\\\$double_quote_subst\\" -e \\"\\\$sed_quote_subst\\" -e \\"\\\$delay_variable_subst\\"\\\`\\\\\\""
-done
-
-# Fix-up fallback echo if it was mangled by the above quoting rules.
-case \$lt_echo in
-*'\\\[$]0 --fallback-echo"')dnl "
- lt_echo=\`\$echo "X\$lt_echo" | \$Xsed -e 's/\\\\\\\\\\\\\\\[$]0 --fallback-echo"\[$]/\[$]0 --fallback-echo"/'\`
- ;;
-esac
-
-_LT_OUTPUT_LIBTOOL_INIT
-])
-])#_LT_CONFIG_COMMANDS
-
-
-# _LT_CONFIG(TAG)
-# ----------------------------
-# If TAG is the built-in tag, create an initial libtool script with a
-# default configuration from the untagged config vars. Otherwise add code
-# to config.status for appending the configuration named by TAG from the
-# matching tagged config vars.
-m4_define([_LT_CONFIG],
-[_LT_CONFIG_SAVE_COMMANDS([
- m4_define([_LT_TAG], m4_if([$1], [], [C], [$1]))dnl
- m4_if(_LT_TAG, [C], [
- # See if we are running on zsh, and set the options which allow our
- # commands through without removal of \ escapes.
- if test -n "${ZSH_VERSION+set}" ; then
- setopt NO_GLOB_SUBST
- fi
-
- cfgfile="${ofile}T"
- trap "$rm \"$cfgfile\"; exit 1" 1 2 15
- $rm -f "$cfgfile"
-
- cat <<_LT_EOF >> "$cfgfile"
-#! $SHELL
-
-# `$echo "$ofile" | sed 's%^.*/%%'` - Provide generalized library-building support services.
-# Generated automatically by config.status (GNU $PACKAGE$TIMESTAMP) $VERSION
-# Libtool was configured on host `(hostname || uname -n) 2>/dev/null | sed 1q`:
-# NOTE: Changes made to this file will be lost: look at ltmain.sh.
-#
-_LT_COPYING
-
-_LT_LIBTOOL_TAGS
-
-# ### BEGIN LIBTOOL CONFIG
-_LT_LIBTOOL_CONFIG_VARS
-_LT_LIBTOOL_TAG_VARS
-# ### END LIBTOOL CONFIG
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
-
-_LT_EOF
-
- case $host_os in
- aix3*)
- cat <<\_LT_EOF >> "$cfgfile"
-# AIX sometimes has problems with the GCC collect2 program. For some
-# reason, if we set the COLLECT_NAMES environment variable, the problems
-# vanish in a puff of smoke.
-if test "X${COLLECT_NAMES+set}" != Xset; then
- COLLECT_NAMES=
- export COLLECT_NAMES
-fi
-_LT_EOF
- ;;
- esac
-
- _LT_PROG_LTMAIN
-
- # We use sed instead of cat because bash on DJGPP gets confused if
- # if finds mixed CR/LF and LF-only lines. Since sed operates in
- # text mode, it properly converts lines to CR/LF. This bash problem
- # is reportedly fixed, but why not run on old versions too?
- sed '$q' "$ltmain" >> "$cfgfile" || (rm -f "$cfgfile"; exit 1)
-
- mv -f "$cfgfile" "$ofile" ||
- (rm -f "$ofile" && cp "$cfgfile" "$ofile" && rm -f "$cfgfile")
- chmod +x "$ofile"
-],
-[cat <<_LT_EOF >> "$ofile"
-
-dnl Unfortunately we have to use $1 here, since _LT_TAG is not expanded
-dnl in a comment (ie after a #).
-# ### BEGIN LIBTOOL TAG CONFIG: $1
-_LT_LIBTOOL_TAG_VARS(_LT_TAG)
-# ### END LIBTOOL TAG CONFIG: $1
-_LT_EOF
-])dnl /m4_if
-],
-[m4_if([$1], [], [
- PACKAGE='$PACKAGE'
- VERSION='$VERSION'
- TIMESTAMP='$TIMESTAMP'
- rm='$rm'
- ofile='$ofile'], [])
-])dnl /_LT_CONFIG_SAVE_COMMANDS
-])# _LT_CONFIG
-
-
-# C support is built-in for now
-m4_define([_LT_LANG_C_enabled], [])
-m4_define([_LT_TAGS], [])
-
-# LT_LANG(LANG)
-# -------------
-# Enable libtool support for the given language if not already enabled.
-AC_DEFUN([LT_LANG],
-[m4_case([$1],
- [C], [_LT_LANG(C)],
- [C++], [_LT_LANG(CXX)],
- [Java], [_LT_LANG(GCJ)],
- [Fortran 77], [_LT_LANG(F77)],
- [Windows Resource], [_LT_LANG(RC)],
- [m4_ifdef([_LT_LANG_]$1[_CONFIG],
- [_LT_LANG($1)],
- [m4_fatal([$0: unsupported language: "$1"])])])dnl
-])# LT_LANG
-
-# _LT_LANG(LANGNAME)
-# ------------------
-m4_define([_LT_LANG],
-[m4_ifdef([_LT_LANG_]$1[_enabled], [],
- [m4_append([_LT_TAGS], [$1 ])dnl
- m4_define([_LT_LANG_]$1[_enabled], [])dnl
- _LT_LANG_$1_CONFIG($1)])dnl
-])# _LT_LANG
-
-# _LT_LANG_DEFAULT_CONFIG
-# -----------------------
-m4_define([_LT_LANG_DEFAULT_CONFIG],
-[AC_PROVIDE_IFELSE([AC_PROG_CXX],
- [LT_LANG(CXX)],
- [m4_define([AC_PROG_CXX], defn([AC_PROG_CXX])[LT_LANG(CXX)])])
-
-AC_PROVIDE_IFELSE([AC_PROG_F77],
- [LT_LANG(F77)],
- [m4_define([AC_PROG_F77], defn([AC_PROG_F77])[LT_LANG(F77)])])
-
-dnl The call to [A][M_PROG_GCJ] is quoted like that to stop aclocal
-dnl pulling things in needlessly.
-AC_PROVIDE_IFELSE([AC_PROG_GCJ],
- [LT_LANG(GCJ)],
- [AC_PROVIDE_IFELSE([A][M_PROG_GCJ],
- [LT_LANG(GCJ)],
- [AC_PROVIDE_IFELSE([LT_PROG_GCJ],
- [LT_LANG(GCJ)],
- [m4_ifdef([AC_PROG_GCJ],
- [m4_define([AC_PROG_GCJ], defn([AC_PROG_GCJ])[LT_LANG(GCJ)])])
- m4_ifdef([A][M_PROG_GCJ],
- [m4_define([A][M_PROG_GCJ], defn([A][M_PROG_GCJ])[LT_LANG(GCJ)])])
- m4_ifdef([LT_PROG_GCJ],
- [m4_define([LT_PROG_GCJ], defn([LT_PROG_GCJ])[LT_LANG(GCJ)])])])])])
-
-AC_PROVIDE_IFELSE([LT_PROG_RC],
- [LT_LANG(RC)],
- [m4_define([LT_PROG_RC], defn([LT_PROG_RC])[LT_LANG(RC)])])
-])# _LT_LANG_DEFAULT_CONFIG
-
-# Obsolete macros
-AU_DEFUN([AC_LIBTOOL_CXX], [LT_LANG(C++)])
-AU_DEFUN([AC_LIBTOOL_F77], [LT_LANG(Fortran 77)])
-AU_DEFUN([AC_LIBTOOL_GCJ], [LT_LANG(Java])])
-
-
-# _LT_AC_SYS_COMPILER
-# -------------------
-AC_DEFUN([_LT_AC_SYS_COMPILER],
-[AC_REQUIRE([AC_PROG_CC])dnl
-
-_LT_DECL([LTCC], [CC], [1], [A C compiler])
-_LT_TAGDECL([CC], [compiler], [1], [A language specific compiler])dnl
-_LT_TAGDECL([with_gcc], [GCC], [0], [Is the compiler the GNU C compiler?])
-
-# If no C compiler was specified, use CC.
-LTCC=${LTCC-"$CC"}
-
-# Allow CC to be a program name with arguments.
-compiler=$CC
-])# _LT_AC_SYS_COMPILER
-
-
-# _LT_AC_SYS_LIBPATH_AIX
-# ----------------------
-# Links a minimal program and checks the executable
-# for the system default hardcoded library path. In most cases,
-# this is /usr/lib:/lib, but when the MPI compilers are used
-# the location of the communication and MPI libs are included too.
-# If we don't find anything, use the default library path according
-# to the aix ld manual.
-m4_define([_LT_AC_SYS_LIBPATH_AIX],
-[AC_LINK_IFELSE(AC_LANG_PROGRAM,[
-aix_libpath=`dump -H conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; }
-}'`
-# Check for a 64-bit object if we didn't find anything.
-if test -z "$aix_libpath"; then aix_libpath=`dump -HX64 conftest$ac_exeext 2>/dev/null | $SED -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; }
-}'`; fi],[])
-if test -z "$aix_libpath"; then aix_libpath="/usr/lib:/lib"; fi
-])# _LT_AC_SYS_LIBPATH_AIX
-
-
-# _LT_AC_SHELL_INIT(ARG)
-# ----------------------
-m4_define([_LT_AC_SHELL_INIT],
-[ifdef([AC_DIVERSION_NOTICE],
- [AC_DIVERT_PUSH(AC_DIVERSION_NOTICE)],
- [AC_DIVERT_PUSH(NOTICE)])
-$1
-AC_DIVERT_POP
-])# _LT_AC_SHELL_INIT
-
-
-# _LT_AC_PROG_ECHO_BACKSLASH
-# --------------------------
-# Add some code to the start of the generated configure script which
-# will find an echo command which doesn't interpret backslashes.
-m4_define([_LT_AC_PROG_ECHO_BACKSLASH],
-[_LT_AC_SHELL_INIT([
-# Check that we are running under the correct shell.
-SHELL=${CONFIG_SHELL-/bin/sh}
-
-case X$ECHO in
-X*--fallback-echo)
- # Remove one level of quotation (which was required for Make).
- ECHO=`echo "$ECHO" | sed 's,\\\\\[$]\\[$]0,'[$]0','`
- ;;
-esac
-
-echo=${ECHO-echo}
-if test "X[$]1" = X--no-reexec; then
- # Discard the --no-reexec flag, and continue.
- shift
-elif test "X[$]1" = X--fallback-echo; then
- # Avoid inline document here, it may be left over
- :
-elif test "X`($echo '\t') 2>/dev/null`" = 'X\t' ; then
- # Yippee, $echo works!
- :
-else
- # Restart under the correct shell.
- exec $SHELL "[$]0" --no-reexec ${1+"[$]@"}
-fi
-
-if test "X[$]1" = X--fallback-echo; then
- # used as fallback echo
- shift
- cat <<_LT_EOF
-[$]*
-_LT_EOF
- exit 0
-fi
-
-# The HP-UX ksh and POSIX shell print the target directory to stdout
-# if CDPATH is set.
-if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
-
-if test -z "$ECHO"; then
-if test "X${echo_test_string+set}" != Xset; then
-# find a string as large as possible, as long as the shell can cope with it
- for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
- # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
- if (echo_test_string="`eval $cmd`") 2>/dev/null &&
- echo_test_string="`eval $cmd`" &&
- (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
- then
- break
- fi
- done
-fi
-
-if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
- echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- :
-else
- # The Solaris, AIX, and Digital Unix default echo programs unquote
- # backslashes. This makes it impossible to quote backslashes using
- # echo "$something" | sed 's/\\/\\\\/g'
- #
- # So, first we look for a working echo in the user's PATH.
-
- lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
- for dir in $PATH /usr/ucb; do
- IFS="$lt_save_ifs"
- if (test -f $dir/echo || test -f $dir/echo$ac_exeext) &&
- test "X`($dir/echo '\t') 2>/dev/null`" = 'X\t' &&
- echo_testing_string=`($dir/echo "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- echo="$dir/echo"
- break
- fi
- done
- IFS="$lt_save_ifs"
-
- if test "X$echo" = Xecho; then
- # We didn't find a better echo, so look for alternatives.
- if test "X`(print -r '\t') 2>/dev/null`" = 'X\t' &&
- echo_testing_string=`(print -r "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- # This shell has a builtin print -r that does the trick.
- echo='print -r'
- elif (test -f /bin/ksh || test -f /bin/ksh$ac_exeext) &&
- test "X$CONFIG_SHELL" != X/bin/ksh; then
- # If we have ksh, try running configure again with it.
- ORIGINAL_CONFIG_SHELL=${CONFIG_SHELL-/bin/sh}
- export ORIGINAL_CONFIG_SHELL
- CONFIG_SHELL=/bin/ksh
- export CONFIG_SHELL
- exec $CONFIG_SHELL "[$]0" --no-reexec ${1+"[$]@"}
- else
- # Try using printf.
- echo='printf %s\n'
- if test "X`($echo '\t') 2>/dev/null`" = 'X\t' &&
- echo_testing_string=`($echo "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- # Cool, printf works
- :
- elif echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
- test "X$echo_testing_string" = 'X\t' &&
- echo_testing_string=`($ORIGINAL_CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- CONFIG_SHELL=$ORIGINAL_CONFIG_SHELL
- export CONFIG_SHELL
- SHELL="$CONFIG_SHELL"
- export SHELL
- echo="$CONFIG_SHELL [$]0 --fallback-echo"
- elif echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo '\t') 2>/dev/null` &&
- test "X$echo_testing_string" = 'X\t' &&
- echo_testing_string=`($CONFIG_SHELL "[$]0" --fallback-echo "$echo_test_string") 2>/dev/null` &&
- test "X$echo_testing_string" = "X$echo_test_string"; then
- echo="$CONFIG_SHELL [$]0 --fallback-echo"
- else
- # maybe with a smaller string...
- prev=:
-
- for cmd in 'echo test' 'sed 2q "[$]0"' 'sed 10q "[$]0"' 'sed 20q "[$]0"' 'sed 50q "[$]0"'; do
- if (test "X$echo_test_string" = "X`eval $cmd`") 2>/dev/null
- then
- break
- fi
- prev="$cmd"
- done
-
- if test "$prev" != 'sed 50q "[$]0"'; then
- echo_test_string=`eval $prev`
- export echo_test_string
- exec ${ORIGINAL_CONFIG_SHELL-${CONFIG_SHELL-/bin/sh}} "[$]0" ${1+"[$]@"}
- else
- # Oops. We lost completely, so just stick with echo.
- echo=echo
- fi
- fi
- fi
- fi
-fi
-fi
-
-# Copy echo and quote the copy suitably for passing to libtool from
-# the Makefile, instead of quoting the original, which is used later.
-ECHO=$echo
-if test "X$ECHO" = "X$CONFIG_SHELL [$]0 --fallback-echo"; then
- ECHO="$CONFIG_SHELL \\\$\[$]0 --fallback-echo"
-fi
-
-AC_SUBST(ECHO)
-])
-_LT_DECL([], [SHELL], [1], [Shell to use when invoking shell scripts])
-_LT_DECL([], [echo], [1],
- [An echo program that does not interpret backslashes])
-])# _LT_AC_PROG_ECHO_BACKSLASH
-
-
-# _LT_AC_LOCK
-# -----------
-AC_DEFUN([_LT_AC_LOCK],
-[AC_REQUIRE([AC_OBJEXT])dnl
-AC_ARG_ENABLE([libtool-lock],
- [AC_HELP_STRING([--disable-libtool-lock],
- [avoid locking (might break parallel builds)])])
-test "x$enable_libtool_lock" != xno && enable_libtool_lock=yes
-
-# Some flags need to be propagated to the compiler or linker for good
-# libtool support.
-case $host in
-ia64-*-hpux*)
- # Find out which ABI we are using.
- echo 'int i;' > conftest.$ac_ext
- if AC_TRY_EVAL(ac_compile); then
- case `/usr/bin/file conftest.$ac_objext` in
- *ELF-32*)
- HPUX_IA64_MODE="32"
- ;;
- *ELF-64*)
- HPUX_IA64_MODE="64"
- ;;
- esac
- fi
- rm -rf conftest*
- ;;
-*-*-irix6*)
- # Find out which ABI we are using.
- echo '[#]line __oline__ "configure"' > conftest.$ac_ext
- if AC_TRY_EVAL(ac_compile); then
- if test "$lt_cv_prog_gnu_ld" = yes; then
- case `/usr/bin/file conftest.$ac_objext` in
- *32-bit*)
- LD="${LD-ld} -melf32bsmip"
- ;;
- *N32*)
- LD="${LD-ld} -melf32bmipn32"
- ;;
- *64-bit*)
- LD="${LD-ld} -melf64bmip"
- ;;
- esac
- else
- case `/usr/bin/file conftest.$ac_objext` in
- *32-bit*)
- LD="${LD-ld} -32"
- ;;
- *N32*)
- LD="${LD-ld} -n32"
- ;;
- *64-bit*)
- LD="${LD-ld} -64"
- ;;
- esac
- fi
- fi
- rm -rf conftest*
- ;;
-
-x86_64-*linux*|ppc*-*linux*|powerpc*-*linux*|s390*-*linux*|sparc*-*linux*)
- # Find out which ABI we are using.
- echo 'int i;' > conftest.$ac_ext
- if AC_TRY_EVAL(ac_compile); then
- case "`/usr/bin/file conftest.o`" in
- *32-bit*)
- case $host in
- x86_64-*linux*)
- LD="${LD-ld} -m elf_i386"
- ;;
- ppc64-*linux*|powerpc64-*linux*)
- LD="${LD-ld} -m elf32ppclinux"
- ;;
- s390x-*linux*)
- LD="${LD-ld} -m elf_s390"
- ;;
- sparc64-*linux*)
- LD="${LD-ld} -m elf32_sparc"
- ;;
- esac
- ;;
- *64-bit*)
- case $host in
- x86_64-*linux*)
- LD="${LD-ld} -m elf_x86_64"
- ;;
- ppc*-*linux*|powerpc*-*linux*)
- LD="${LD-ld} -m elf64ppc"
- ;;
- s390*-*linux*)
- LD="${LD-ld} -m elf64_s390"
- ;;
- sparc*-*linux*)
- LD="${LD-ld} -m elf64_sparc"
- ;;
- esac
- ;;
- esac
- fi
- rm -rf conftest*
- ;;
-
-*-*-sco3.2v5*)
- # On SCO OpenServer 5, we need -belf to get full-featured binaries.
- SAVE_CFLAGS="$CFLAGS"
- CFLAGS="$CFLAGS -belf"
- AC_CACHE_CHECK([whether the C compiler needs -belf], lt_cv_cc_needs_belf,
- [AC_LANG_PUSH(C)
- AC_TRY_LINK([],[],[lt_cv_cc_needs_belf=yes],[lt_cv_cc_needs_belf=no])
- AC_LANG_POP])
- if test x"$lt_cv_cc_needs_belf" != x"yes"; then
- # this is probably gcc 2.8.0, egcs 1.0 or newer; no need for -belf
- CFLAGS="$SAVE_CFLAGS"
- fi
- ;;
-esac
-
-need_locks="$enable_libtool_lock"
-])# _LT_AC_LOCK
-
-
-# AC_LIBTOOL_SYS_OLD_ARCHIVE
-# --------------------------
-AC_DEFUN([AC_LIBTOOL_SYS_OLD_ARCHIVE],
-[AC_CHECK_TOOL(AR, ar, false)
-test -z "$AR" && AR=ar
-test -z "$AR_FLAGS" && AR_FLAGS=cru
-_LT_DECL([], [AR], [1], [The archiver])
-_LT_DECL([], [AR_FLAGS], [1])
-
-AC_CHECK_TOOL(STRIP, strip, :)
-test -z "$STRIP" && STRIP=:
-_LT_DECL([], [STRIP], [1], [A symbol stripping program])
-
-AC_CHECK_TOOL(RANLIB, ranlib, :)
-test -z "$RANLIB" && RANLIB=:
-_LT_DECL([], [RANLIB], [1],
- [Commands used to install an old-style archive])
-
-# Determine commands to create old-style static archives.
-old_archive_cmds='$AR $AR_FLAGS $oldlib$oldobjs$old_deplibs'
-old_postinstall_cmds='chmod 644 $oldlib'
-old_postuninstall_cmds=
-
-if test -n "$RANLIB"; then
- case $host_os in
- openbsd*)
- old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
- ;;
- *)
- old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
- ;;
- esac
- old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
-fi
-_LT_DECL([], [old_postinstall_cmds], [2])
-_LT_DECL([], [old_postuninstall_cmds], [2])
-_LT_TAGDECL([], [old_archive_cmds], [2],
- [Commands used to build an old-style archive])
-])# AC_LIBTOOL_SYS_OLD_ARCHIVE
-
-
-# AC_LIBTOOL_COMPILER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
-# [OUTPUT-FILE], [ACTION-SUCCESS], [ACTION-FAILURE])
-# ----------------------------------------------------------------
-# Check whether the given compiler option works
-AC_DEFUN([AC_LIBTOOL_COMPILER_OPTION],
-[AC_REQUIRE([AC_OBJEXT])dnl
-AC_REQUIRE([LT_AC_PROG_SED])dnl
-AC_CACHE_CHECK([$1], [$2],
- [$2=no
- m4_if([$4], , [ac_outfile=conftest.$ac_objext], [ac_outfile=$4])
- printf "$lt_simple_compile_test_code" > conftest.$ac_ext
- lt_compiler_flag="$3"
- # Insert the option either (1) after the last *FLAGS variable, or
- # (2) before a word containing "conftest.", or (3) at the end.
- # Note that $ac_compile itself does not contain backslashes and begins
- # with a dollar sign (not a hyphen), so the echo should work correctly.
- # The option is referenced via a variable to avoid confusing sed.
- lt_compile=`echo "$ac_compile" | $SED \
- -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
- -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
- -e 's:$: $lt_compiler_flag:'`
- (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
- (eval "$lt_compile" 2>conftest.err)
- ac_status=$?
- cat conftest.err >&AS_MESSAGE_LOG_FD
- echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
- if (exit $ac_status) && test -s "$ac_outfile"; then
- # The compiler can only warn and ignore the option if not recognized
- # So say no if there are warnings
- if test ! -s conftest.err; then
- $2=yes
- fi
- fi
- $rm conftest*
-])
-
-if test x"[$]$2" = xyes; then
- m4_if([$5], , :, [$5])
-else
- m4_if([$6], , :, [$6])
-fi
-])# AC_LIBTOOL_COMPILER_OPTION
-
-
-# AC_LIBTOOL_LINKER_OPTION(MESSAGE, VARIABLE-NAME, FLAGS,
-# [ACTION-SUCCESS], [ACTION-FAILURE])
-# ------------------------------------------------------------
-# Check whether the given compiler option works
-m4_define([AC_LIBTOOL_LINKER_OPTION],
-[AC_CACHE_CHECK([$1], [$2],
- [$2=no
- save_LDFLAGS="$LDFLAGS"
- LDFLAGS="$LDFLAGS $3"
- printf "$lt_simple_link_test_code" > conftest.$ac_ext
- if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
- # The compiler can only warn and ignore the option if not recognized
- # So say no if there are warnings
- if test -s conftest.err; then
- # Append any errors to the config.log.
- cat conftest.err 1>&AS_MESSAGE_LOG_FD
- else
- $2=yes
- fi
- fi
- $rm conftest*
- LDFLAGS="$save_LDFLAGS"
-])
-
-if test x"[$]$2" = xyes; then
- m4_if([$4], , :, [$4])
-else
- m4_if([$5], , :, [$5])
-fi
-])# AC_LIBTOOL_LINKER_OPTION
-
-
-# AC_LIBTOOL_SYS_MAX_CMD_LEN
-# --------------------------
-AC_DEFUN([AC_LIBTOOL_SYS_MAX_CMD_LEN],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-# find the maximum length of command line arguments
-AC_MSG_CHECKING([the maximum length of command line arguments])
-AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
- i=0
- teststring="ABCD"
-
- case $build_os in
- msdosdjgpp*)
- # On DJGPP, this test can blow up pretty badly due to problems in libc
- # (any single argument exceeding 2000 bytes causes a buffer overrun
- # during glob expansion). Even if it were fixed, the result of this
- # check would be larger than it should be.
- lt_cv_sys_max_cmd_len=12288; # 12K is about right
- ;;
-
- gnu*)
- # Under GNU Hurd, this test is not required because there is
- # no limit to the length of command line arguments.
- # Libtool will interpret -1 as no limit whatsoever
- lt_cv_sys_max_cmd_len=-1;
- ;;
-
- cygwin* | mingw*)
- # On Win9x/ME, this test blows up -- it succeeds, but takes
- # about 5 minutes as the teststring grows exponentially.
- # Worse, since 9x/ME are not pre-emptively multitasking,
- # you end up with a "frozen" computer, even though with patience
- # the test eventually succeeds (with a max line length of 256k).
- # Instead, let's just punt: use the minimum linelength reported by
- # all of the supported platforms: 8192 (on NT/2K/XP).
- lt_cv_sys_max_cmd_len=8192;
- ;;
-
- amigaos*)
- # On AmigaOS with pdksh, this test takes hours, literally.
- # So we just punt and use a minimum line length of 8192.
- lt_cv_sys_max_cmd_len=8192;
- ;;
-
- *)
- # Make teststring a little bigger before we do anything with it.
- # a 1K string should be a reasonable start.
- for i in 1 2 3 4 5 6 7 8 ; do
- teststring=$teststring$teststring
- done
- # If test is not a shell built-in, we'll probably end up computing a
- # maximum length that is only half of the actual maximum length, but
- # we can't tell.
- while (test "X"`$CONFIG_SHELL [$]0 --fallback-echo "X$teststring$teststring" 2>/dev/null` \
- = "XX$teststring$teststring") >/dev/null 2>&1 &&
- test $i != 17 # 1/2 MB should be enough
- do
- i=`expr $i + 1`
- teststring=$teststring$teststring
- done
- # Only check the string length outside the loop.
- lt_cv_sys_max_cmd_len=`expr "X$teststring" : ".*" 2>&1`
- teststring=
- # Add a significant safety factor because C++ compilers can tack on massive
- # amounts of additional arguments before passing them to the linker.
- # It appears as though 1/2 is a usable value.
- lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 2`
- ;;
- esac
-])
-if test -n $lt_cv_sys_max_cmd_len ; then
- AC_MSG_RESULT($lt_cv_sys_max_cmd_len)
-else
- AC_MSG_RESULT(none)
-fi
-_LT_DECL([max_cmd_len], [lt_cv_sys_max_cmd_len], [0],
- [What is the maximum length of a command?])
-])# AC_LIBTOOL_SYS_MAX_CMD_LEN
-
-
-# _LT_AC_CHECK_DLFCN
-# --------------------
-AC_DEFUN([_LT_AC_CHECK_DLFCN],
-[AC_CHECK_HEADERS([dlfcn.h], [], [], [AC_INCLUDES_DEFAULT])dnl
-])# _LT_AC_CHECK_DLFCN
-
-
-# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
-# ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
-# ------------------------------------------------------------------
-AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
-[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
-if test "$cross_compiling" = yes; then :
- [$4]
-else
- lt_dlunknown=0; lt_dlno_uscore=1; lt_dlneed_uscore=2
- lt_status=$lt_dlunknown
- cat > conftest.$ac_ext <<_LT_EOF
-[#line __oline__ "configure"
-#include "confdefs.h"
-
-#if HAVE_DLFCN_H
-#include <dlfcn.h>
-#endif
-
-#include <stdio.h>
-
-#ifdef RTLD_GLOBAL
-# define LT_DLGLOBAL RTLD_GLOBAL
-#else
-# ifdef DL_GLOBAL
-# define LT_DLGLOBAL DL_GLOBAL
-# else
-# define LT_DLGLOBAL 0
-# endif
-#endif
-
-/* We may have to define LT_DLLAZY_OR_NOW in the command line if we
- find out it does not work in some platform. */
-#ifndef LT_DLLAZY_OR_NOW
-# ifdef RTLD_LAZY
-# define LT_DLLAZY_OR_NOW RTLD_LAZY
-# else
-# ifdef DL_LAZY
-# define LT_DLLAZY_OR_NOW DL_LAZY
-# else
-# ifdef RTLD_NOW
-# define LT_DLLAZY_OR_NOW RTLD_NOW
-# else
-# ifdef DL_NOW
-# define LT_DLLAZY_OR_NOW DL_NOW
-# else
-# define LT_DLLAZY_OR_NOW 0
-# endif
-# endif
-# endif
-# endif
-#endif
-
-#ifdef __cplusplus
-extern "C" void exit (int);
-#endif
-
-void fnord() { int i=42;}
-int main ()
-{
- void *self = dlopen (0, LT_DLGLOBAL|LT_DLLAZY_OR_NOW);
- int status = $lt_dlunknown;
-
- if (self)
- {
- if (dlsym (self,"fnord")) status = $lt_dlno_uscore;
- else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
- /* dlclose (self); */
- }
-
- exit (status);
-}]
-_LT_EOF
- if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
- (./conftest; exit; ) 2>/dev/null
- lt_status=$?
- case x$lt_status in
- x$lt_dlno_uscore) $1 ;;
- x$lt_dlneed_uscore) $2 ;;
- x$lt_unknown|x*) $3 ;;
- esac
- else :
- # compilation failed
- $3
- fi
-fi
-rm -fr conftest*
-])# _LT_AC_TRY_DLOPEN_SELF
-
-
-# AC_LIBTOOL_DLOPEN_SELF
-# -------------------
-AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
-[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
-if test "x$enable_dlopen" != xyes; then
- enable_dlopen=unknown
- enable_dlopen_self=unknown
- enable_dlopen_self_static=unknown
-else
- lt_cv_dlopen=no
- lt_cv_dlopen_libs=
-
- case $host_os in
- beos*)
- lt_cv_dlopen="load_add_on"
- lt_cv_dlopen_libs=
- lt_cv_dlopen_self=yes
- ;;
-
- mingw* | pw32*)
- lt_cv_dlopen="LoadLibrary"
- lt_cv_dlopen_libs=
- ;;
-
- cygwin*)
- lt_cv_dlopen="dlopen"
- lt_cv_dlopen_libs=
- ;;
-
- darwin*)
- # if libdl is installed we need to link against it
- AC_CHECK_LIB([dl], [dlopen],
- [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],[
- lt_cv_dlopen="dyld"
- lt_cv_dlopen_libs=
- lt_cv_dlopen_self=yes
- ])
- ;;
-
- *)
- AC_CHECK_FUNC([shl_load],
- [lt_cv_dlopen="shl_load"],
- [AC_CHECK_LIB([dld], [shl_load],
- [lt_cv_dlopen="shl_load" lt_cv_dlopen_libs="-dld"],
- [AC_CHECK_FUNC([dlopen],
- [lt_cv_dlopen="dlopen"],
- [AC_CHECK_LIB([dl], [dlopen],
- [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-ldl"],
- [AC_CHECK_LIB([svld], [dlopen],
- [lt_cv_dlopen="dlopen" lt_cv_dlopen_libs="-lsvld"],
- [AC_CHECK_LIB([dld], [dld_link],
- [lt_cv_dlopen="dld_link" lt_cv_dlopen_libs="-dld"])
- ])
- ])
- ])
- ])
- ])
- ;;
- esac
-
- if test "x$lt_cv_dlopen" != xno; then
- enable_dlopen=yes
- else
- enable_dlopen=no
- fi
-
- case $lt_cv_dlopen in
- dlopen)
- save_CPPFLAGS="$CPPFLAGS"
- test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
-
- save_LDFLAGS="$LDFLAGS"
- eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
-
- save_LIBS="$LIBS"
- LIBS="$lt_cv_dlopen_libs $LIBS"
-
- AC_CACHE_CHECK([whether a program can dlopen itself],
- lt_cv_dlopen_self, [dnl
- _LT_AC_TRY_DLOPEN_SELF(
- lt_cv_dlopen_self=yes, lt_cv_dlopen_self=yes,
- lt_cv_dlopen_self=no, lt_cv_dlopen_self=cross)
- ])
-
- if test "x$lt_cv_dlopen_self" = xyes; then
- LDFLAGS="$LDFLAGS $link_static_flag"
- AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
- lt_cv_dlopen_self_static, [dnl
- _LT_AC_TRY_DLOPEN_SELF(
- lt_cv_dlopen_self_static=yes, lt_cv_dlopen_self_static=yes,
- lt_cv_dlopen_self_static=no, lt_cv_dlopen_self_static=cross)
- ])
- fi
-
- CPPFLAGS="$save_CPPFLAGS"
- LDFLAGS="$save_LDFLAGS"
- LIBS="$save_LIBS"
- ;;
- esac
-
- case $lt_cv_dlopen_self in
- yes|no) enable_dlopen_self=$lt_cv_dlopen_self ;;
- *) enable_dlopen_self=unknown ;;
- esac
-
- case $lt_cv_dlopen_self_static in
- yes|no) enable_dlopen_self_static=$lt_cv_dlopen_self_static ;;
- *) enable_dlopen_self_static=unknown ;;
- esac
-fi
-_LT_DECL([dlopen_support], [enable_dlopen], [0],
- [Whether dlopen is supported])
-_LT_DECL([dlopen_self], [enable_dlopen_self], [0],
- [Whether dlopen of programs is supported])
-_LT_DECL([dlopen_self_static], [enable_dlopen_self_static], [0],
- [Whether dlopen of statically linked programs is supported])
-])# AC_LIBTOOL_DLOPEN_SELF
-
-
-# AC_LIBTOOL_PROG_CC_C_O([TAGNAME])
-# ---------------------------------
-# Check to see if options -c and -o are simultaneously supported by compiler
-AC_DEFUN([AC_LIBTOOL_PROG_CC_C_O],
-[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
-AC_REQUIRE([AC_OBJEXT])dnl
-AC_CACHE_CHECK([if $compiler supports -c -o file.$ac_objext],
- [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)],
- [_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=no
- $rm -r conftest 2>/dev/null
- mkdir conftest
- cd conftest
- mkdir out
- printf "$lt_simple_compile_test_code" > conftest.$ac_ext
-
- lt_compiler_flag="-o out/conftest2.$ac_objext"
- # Insert the option either (1) after the last *FLAGS variable, or
- # (2) before a word containing "conftest.", or (3) at the end.
- # Note that $ac_compile itself does not contain backslashes and begins
- # with a dollar sign (not a hyphen), so the echo should work correctly.
- lt_compile=`echo "$ac_compile" | $SED \
- -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
- -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
- -e 's:$: $lt_compiler_flag:'`
- (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
- (eval "$lt_compile" 2>out/conftest.err)
- ac_status=$?
- cat out/conftest.err >&AS_MESSAGE_LOG_FD
- echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
- if (exit $ac_status) && test -s out/conftest2.$ac_objext
- then
- # The compiler can only warn and ignore the option if not recognized
- # So say no if there are warnings
- if test ! -s out/conftest.err; then
- _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
- fi
- fi
- chmod u+w .
- $rm conftest*
- # SGI C++ compiler will create directory out/ii_files/ for
- # template instantiation
- test -d out/ii_files && $rm out/ii_files/* && rmdir out/ii_files
- $rm out/* && rmdir out
- cd ..
- rmdir conftest
- $rm conftest*
-])
-_LT_DECL([compiler_c_o], [lt_cv_prog_compiler_c_o], [1],
- [Does compiler simultaneously support -c and -o options?])
-])# AC_LIBTOOL_PROG_CC_C_O
-
-
-# AC_LIBTOOL_SYS_HARD_LINK_LOCKS([TAGNAME])
-# -----------------------------------------
-# Check to see if we can do hard links to lock some files if needed
-AC_DEFUN([AC_LIBTOOL_SYS_HARD_LINK_LOCKS],
-[AC_REQUIRE([AC_LIBTOOL_PROG_CC_C_O])dnl
-AC_REQUIRE([_LT_AC_LOCK])dnl
-
-hard_links="nottested"
-if test "$_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)" = no && test "$need_locks" != no; then
- # do not overwrite the value of need_locks provided by the user
- AC_MSG_CHECKING([if we can lock with hard links])
- hard_links=yes
- $rm conftest*
- ln conftest.a conftest.b 2>/dev/null && hard_links=no
- touch conftest.a
- ln conftest.a conftest.b 2>&5 || hard_links=no
- ln conftest.a conftest.b 2>/dev/null && hard_links=no
- AC_MSG_RESULT([$hard_links])
- if test "$hard_links" = no; then
- AC_MSG_WARN([`$CC' does not support `-c -o', so `make -j' may be unsafe])
- need_locks=warn
- fi
-else
- need_locks=no
-fi
-_LT_DECL([], [need_locks], [1], [Must we lock files when doing compilation?])
-])# AC_LIBTOOL_SYS_HARD_LINK_LOCKS
-
-
-# AC_LIBTOOL_OBJDIR
-# -----------------
-AC_DEFUN([AC_LIBTOOL_OBJDIR],
-[AC_CACHE_CHECK([for objdir], [lt_cv_objdir],
-[rm -f .libs 2>/dev/null
-mkdir .libs 2>/dev/null
-if test -d .libs; then
- lt_cv_objdir=.libs
-else
- # MS-DOS does not allow filenames that begin with a dot.
- lt_cv_objdir=_libs
-fi
-rmdir .libs 2>/dev/null])
-objdir=$lt_cv_objdir
-_LT_DECL([], [objdir], [0],
- [The name of the directory that contains temporary libtool files])dnl
-])# AC_LIBTOOL_OBJDIR
-
-
-# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH([TAGNAME])
-# ----------------------------------------------
-# Check hardcoding attributes.
-AC_DEFUN([AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH],
-[AC_MSG_CHECKING([how to hardcode library paths into programs])
-_LT_AC_TAGVAR(hardcode_action, $1)=
-if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" ||
- test -n "$_LT_AC_TAGVAR(runpath_var $1)" ||
- test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then
-
- # We can hardcode non-existant directories.
- if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&
- # If the only mechanism to avoid hardcoding is shlibpath_var, we
- # have to relink, otherwise we might link with an installed library
- # when we should be linking with a yet-to-be-installed one
- ## test "$_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)" != no &&
- test "$_LT_AC_TAGVAR(hardcode_minus_L, $1)" != no; then
- # Linking always hardcodes the temporary library directory.
- _LT_AC_TAGVAR(hardcode_action, $1)=relink
- else
- # We can link without hardcoding, and we can hardcode nonexisting dirs.
- _LT_AC_TAGVAR(hardcode_action, $1)=immediate
- fi
-else
- # We cannot hardcode anything, or else we can only hardcode existing
- # directories.
- _LT_AC_TAGVAR(hardcode_action, $1)=unsupported
-fi
-AC_MSG_RESULT([$_LT_AC_TAGVAR(hardcode_action, $1)])
-
-if test "$_LT_AC_TAGVAR(hardcode_action, $1)" = relink ||
- test "$_LT_AC_TAGVAR(inherit_rpath, $1)" = yes; then
- # Fast installation is not supported
- enable_fast_install=no
-elif test "$shlibpath_overrides_runpath" = yes ||
- test "$enable_shared" = no; then
- # Fast installation is not necessary
- enable_fast_install=needless
-fi
-_LT_TAGDECL([], [hardcode_action], [0],
- [How to hardcode a shared library path into an executable])
-])# AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH
-
-
-# AC_LIBTOOL_SYS_LIB_STRIP
-# ------------------------
-AC_DEFUN([AC_LIBTOOL_SYS_LIB_STRIP],
-[AC_REQUIRE([LT_AC_PROG_EGREP])
-striplib=
-old_striplib=
-AC_MSG_CHECKING([whether stripping libraries is possible])
-if test -n "$STRIP" && $STRIP -V 2>&1 | $GREP "GNU strip" >/dev/null; then
- test -z "$old_striplib" && old_striplib="$STRIP --strip-debug"
- test -z "$striplib" && striplib="$STRIP --strip-unneeded"
- AC_MSG_RESULT([yes])
-else
-# FIXME - insert some real tests, host_os isn't really good enough
- case $host_os in
- darwin*)
- if test -n "$STRIP" ; then
- striplib="$STRIP -x"
- AC_MSG_RESULT([yes])
- else
- AC_MSG_RESULT([no])
-fi
- ;;
- *)
- AC_MSG_RESULT([no])
- ;;
- esac
-fi
-_LT_DECL([], [old_striplib], [1], [Commands to strip libraries])
-_LT_DECL([], [striplib], [1])
-])# AC_LIBTOOL_SYS_LIB_STRIP
-
-
-# AC_LIBTOOL_SYS_DYNAMIC_LINKER
-# -----------------------------
-# PORTME Fill in your ld.so characteristics
-AC_DEFUN([AC_LIBTOOL_SYS_DYNAMIC_LINKER],
-[AC_REQUIRE([LT_AC_PROG_EGREP])
-AC_MSG_CHECKING([dynamic linker characteristics])
-library_names_spec=
-libname_spec='lib$name'
-soname_spec=
-shrext_cmds=".so"
-postinstall_cmds=
-postuninstall_cmds=
-finish_cmds=
-finish_eval=
-shlibpath_var=
-shlibpath_overrides_runpath=unknown
-version_type=none
-dynamic_linker="$host_os ld.so"
-sys_lib_dlsearch_path_spec="/lib /usr/lib"
-if test "$GCC" = yes; then
- sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
- if echo "$sys_lib_search_path_spec" | $GREP ';' >/dev/null ; then
- # if the path contains ";" then we assume it to be the separator
- # otherwise default to the standard path separator (i.e. ":") - it is
- # assumed that no part of a normal pathname contains ";" but that should
- # okay in the real world where ";" in dirpaths is itself problematic.
- sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
- else
- sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
- fi
-else
- sys_lib_search_path_spec="/lib /usr/lib /usr/local/lib"
-fi
-need_lib_prefix=unknown
-hardcode_into_libs=no
-
-# when you set need_version to no, make sure it does not cause -set_version
-# flags to be left without arguments
-need_version=unknown
-
-case $host_os in
-aix3*)
- version_type=linux
- library_names_spec='${libname}${release}${shared_ext}$versuffix $libname.a'
- shlibpath_var=LIBPATH
-
- # AIX 3 has no versioning support, so we append a major version to the name.
- soname_spec='${libname}${release}${shared_ext}$major'
- ;;
-
-aix4* | aix5*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- hardcode_into_libs=yes
- if test "$host_cpu" = ia64; then
- # AIX 5 supports IA64
- library_names_spec='${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext}$versuffix $libname${shared_ext}'
- shlibpath_var=LD_LIBRARY_PATH
- else
- # With GCC up to 2.95.x, collect2 would create an import file
- # for dependence libraries. The import file would start with
- # the line `#! .'. This would cause the generated library to
- # depend on `.', always an invalid library. This was fixed in
- # development snapshots of GCC prior to 3.0.
- case $host_os in
- aix4 | aix4.[[01]] | aix4.[[01]].*)
- if { echo '#if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 97)'
- echo ' yes '
- echo '#endif'; } | ${CC} -E - | $GREP yes > /dev/null; then
- :
- else
- can_build_shared=no
- fi
- ;;
- esac
- # AIX (on Power*) has no versioning support, so currently we can not hardcode correct
- # soname into executable. Probably we can add versioning support to
- # collect2, so additional links can be useful in future.
- if test "$aix_use_runtimelinking" = yes; then
- # If using run time linking (on AIX 4.2 or later) use lib<name>.so
- # instead of lib<name>.a to let people know that these are not
- # typical AIX shared libraries.
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- else
- # We preserve .a as extension for shared libraries through AIX4.2
- # and later when we are not doing run time linking.
- library_names_spec='${libname}${release}.a $libname.a'
- soname_spec='${libname}${release}${shared_ext}$major'
- fi
- shlibpath_var=LIBPATH
- fi
- ;;
-
-amigaos*)
- if test "$host_cpu" = m68k; then
- library_names_spec='$libname.ixlibrary $libname.a'
- # Create ${libname}_ixlibrary.a entries in /sys/libs.
- finish_eval='for lib in `ls $libdir/*.ixlibrary 2>/dev/null`; do libname=`$echo "X$lib" | $Xsed -e '\''s%^.*/\([[^/]]*\)\.ixlibrary$%\1%'\''`; test $rm /sys/libs/${libname}_ixlibrary.a; $show "cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a"; cd /sys/libs && $LN_S $lib ${libname}_ixlibrary.a || exit 1; done'
- else
- dynamic_linker=no
- fi
- ;;
-
-beos*)
- library_names_spec='${libname}${shared_ext}'
- dynamic_linker="$host_os ld.so"
- shlibpath_var=LIBRARY_PATH
- ;;
-
-bsdi4*)
- version_type=linux
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- finish_cmds='PATH="\$PATH:/sbin" ldconfig $libdir'
- shlibpath_var=LD_LIBRARY_PATH
- sys_lib_search_path_spec="/shlib /usr/lib /usr/X11/lib /usr/contrib/lib /lib /usr/local/lib"
- sys_lib_dlsearch_path_spec="/shlib /usr/lib /usr/local/lib"
- # the default ld.so.conf also contains /usr/contrib/lib and
- # /usr/X11R6/lib (/usr/X11 is a link to /usr/X11R6), but let us allow
- # libtool to hard-code these into programs
- ;;
-
-cygwin* | mingw* | pw32*)
- version_type=windows
- shrext_cmds=".dll"
- need_version=no
- need_lib_prefix=no
-
- case $GCC,$host_os in
- yes,cygwin* | yes,mingw* | yes,pw32*)
- library_names_spec='$libname.dll.a'
- # DLL is installed to $(libdir)/../bin by postinstall_cmds
- postinstall_cmds='base_file=`basename \${file}`~
- dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
- dldir=$destdir/`dirname \$dlpath`~
- test -d \$dldir || mkdir -p \$dldir~
- $install_prog $dir/$dlname \$dldir/$dlname'
- postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
- dlpath=$dir/\$dldll~
- $rm \$dlpath'
- shlibpath_overrides_runpath=yes
-
- case $host_os in
- cygwin*)
- # Cygwin DLLs use 'cyg' prefix rather than 'lib'
- soname_spec='`echo ${libname} | sed -e 's/^lib/cyg/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
- sys_lib_search_path_spec="/usr/lib /lib/w32api /lib /usr/local/lib"
- ;;
- mingw*)
- # MinGW DLLs use traditional 'lib' prefix
- soname_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
- sys_lib_search_path_spec=`$CC -print-search-dirs | $GREP "^libraries:" | $SED -e "s/^libraries://" -e "s,=/,/,g"`
- if echo "$sys_lib_search_path_spec" | [$GREP ';[c-zC-Z]:/' >/dev/null]; then
- # It is most probably a Windows format PATH printed by
- # mingw gcc, but we are running on Cygwin. Gcc prints its search
- # path with ; separators, and with drive letters. We can handle the
- # drive letters (cygwin fileutils understands them), so leave them,
- # especially as we might pass files found there to a mingw objdump,
- # which wouldn't understand a cygwinified path. Ahh.
- sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e 's/;/ /g'`
- else
- sys_lib_search_path_spec=`echo "$sys_lib_search_path_spec" | $SED -e "s/$PATH_SEPARATOR/ /g"`
- fi
- ;;
- pw32*)
- # pw32 DLLs use 'pw' prefix rather than 'lib'
- library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
- ;;
- esac
- ;;
-
- *)
- library_names_spec='${libname}`echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext} $libname.lib'
- ;;
- esac
- dynamic_linker='Win32 ld.exe'
- # FIXME: first we should search . and the directory the executable is in
- shlibpath_var=PATH
- ;;
-
-darwin* | rhapsody*)
- dynamic_linker="$host_os dyld"
- version_type=darwin
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${versuffix}$shared_ext ${libname}${release}${major}$shared_ext ${libname}$shared_ext'
- soname_spec='${libname}${release}${major}$shared_ext'
- shlibpath_overrides_runpath=yes
- shlibpath_var=DYLD_LIBRARY_PATH
- shrext_cmds='$(test .$module = .yes && echo .so || echo .dylib)'
- # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
- if test "$GCC" = yes; then
- sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | $GREP "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
- else
- sys_lib_search_path_spec='/lib /usr/lib /usr/local/lib'
- fi
- sys_lib_dlsearch_path_spec='/usr/local/lib /lib /usr/lib'
- ;;
-
-dgux*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname$shared_ext'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- ;;
-
-freebsd1*)
- dynamic_linker=no
- ;;
-
-kfreebsd*-gnu)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=no
- hardcode_into_libs=yes
- dynamic_linker='GNU ld.so'
- ;;
-
-freebsd*)
- objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
- version_type=freebsd-$objformat
- case $version_type in
- freebsd-elf*)
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
- need_version=no
- need_lib_prefix=no
- ;;
- freebsd-*)
- library_names_spec='${libname}${release}${shared_ext}$versuffix $libname${shared_ext}$versuffix'
- need_version=yes
- ;;
- esac
- shlibpath_var=LD_LIBRARY_PATH
- case $host_os in
- freebsd2*)
- shlibpath_overrides_runpath=yes
- ;;
- freebsd3.[01]* | freebsdelf3.[01]*)
- shlibpath_overrides_runpath=yes
- hardcode_into_libs=yes
- ;;
- *) # from 3.2 on
- shlibpath_overrides_runpath=no
- hardcode_into_libs=yes
- ;;
- esac
- ;;
-
-gnu*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}${major} ${libname}${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- hardcode_into_libs=yes
- ;;
-
-hpux9* | hpux10* | hpux11*)
- # Give a soname corresponding to the major version so that dld.sl refuses to
- # link against other versions.
- version_type=sunos
- need_lib_prefix=no
- need_version=no
- case "$host_cpu" in
- ia64*)
- shrext_cmds='.so'
- hardcode_into_libs=yes
- dynamic_linker="$host_os dld.so"
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- if test "X$HPUX_IA64_MODE" = X32; then
- sys_lib_search_path_spec="/usr/lib/hpux32 /usr/local/lib/hpux32 /usr/local/lib"
- else
- sys_lib_search_path_spec="/usr/lib/hpux64 /usr/local/lib/hpux64"
- fi
- sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
- ;;
- hppa*64*)
- shrext_cmds='.sl'
- hardcode_into_libs=yes
- dynamic_linker="$host_os dld.sl"
- shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
- shlibpath_overrides_runpath=yes # Unless +noenvvar is specified.
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- sys_lib_search_path_spec="/usr/lib/pa20_64 /usr/ccs/lib/pa20_64"
- sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
- ;;
- *)
- shrext_cmds='.sl'
- dynamic_linker="$host_os dld.sl"
- shlibpath_var=SHLIB_PATH
- shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- ;;
- esac
- # HP-UX runs *really* slowly unless shared libraries are mode 555.
- postinstall_cmds='chmod 555 $lib'
- ;;
-
-irix5* | irix6* | nonstopux*)
- case $host_os in
- nonstopux*) version_type=nonstopux ;;
- *)
- if test "$lt_cv_prog_gnu_ld" = yes; then
- version_type=linux
- else
- version_type=irix
- fi ;;
- esac
- need_lib_prefix=no
- need_version=no
- soname_spec='${libname}${release}${shared_ext}$major'
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} $libname${shared_ext}'
- case $host_os in
- irix5* | nonstopux*)
- libsuff= shlibsuff=
- ;;
- *)
- case $LD in # libtool.m4 will add one of these switches to LD
- *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ")
- libsuff= shlibsuff= libmagic=32-bit;;
- *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ")
- libsuff=32 shlibsuff=N32 libmagic=N32;;
- *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ")
- libsuff=64 shlibsuff=64 libmagic=64-bit;;
- *) libsuff= shlibsuff= libmagic=never-match;;
- esac
- ;;
- esac
- shlibpath_var=LD_LIBRARY${shlibsuff}_PATH
- shlibpath_overrides_runpath=no
- sys_lib_search_path_spec="/usr/lib${libsuff} /lib${libsuff} /usr/local/lib${libsuff}"
- sys_lib_dlsearch_path_spec="/usr/lib${libsuff} /lib${libsuff}"
- hardcode_into_libs=yes
- ;;
-
-# No shared lib support for Linux oldld, aout, or coff.
-linux*oldld* | linux*aout* | linux*coff*)
- dynamic_linker=no
- ;;
-
-# This must be Linux ELF.
-linux*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- finish_cmds='PATH="\$PATH:/sbin" ldconfig -n $libdir'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=no
- # This implies no fast_install, which is unacceptable.
- # Some rework will be needed to allow for fast_install
- # before this can be enabled.
- hardcode_into_libs=yes
-
- # Append ld.so.conf contents to the search path
- if test -f /etc/ld.so.conf; then
- lt_ld_extra=`$SED -e 's/[:,\t]/ /g;s/=[^=]*$//;s/=[^= ]* / /g' /etc/ld.so.conf | tr '\n' ' '`
- sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
- fi
-
- # We used to test for /lib/ld.so.1 and disable shared libraries on
- # powerpc, because MkLinux only supported shared libraries with the
- # GNU dynamic linker. Since this was broken with cross compilers,
- # most powerpc-linux boxes support dynamic linking these days and
- # people can always --disable-shared, the test was removed, and we
- # assume the GNU/Linux dynamic linker is in use.
- dynamic_linker='GNU/Linux ld.so'
- ;;
-
-knetbsd*-gnu)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=no
- hardcode_into_libs=yes
- dynamic_linker='GNU ld.so'
- ;;
-
-netbsd*)
- version_type=sunos
- need_lib_prefix=no
- need_version=no
- if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
- finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
- dynamic_linker='NetBSD (a.out) ld.so'
- else
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- dynamic_linker='NetBSD ld.elf_so'
- fi
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes
- hardcode_into_libs=yes
- ;;
-
-newsos6)
- version_type=linux
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes
- ;;
-
-nto-qnx*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes
- ;;
-
-openbsd*)
- version_type=sunos
- need_lib_prefix=no
- need_version=yes
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
- finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
- shlibpath_var=LD_LIBRARY_PATH
- if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
- case $host_os in
- openbsd2.[[89]] | openbsd2.[[89]].*)
- shlibpath_overrides_runpath=no
- ;;
- *)
- shlibpath_overrides_runpath=yes
- ;;
- esac
- else
- shlibpath_overrides_runpath=yes
- fi
- ;;
-
-os2*)
- libname_spec='$name'
- shrext_cmds=".dll"
- need_lib_prefix=no
- library_names_spec='$libname${shared_ext} $libname.a'
- dynamic_linker='OS/2 ld.exe'
- shlibpath_var=LIBPATH
- ;;
-
-osf3* | osf4* | osf5*)
- version_type=osf
- need_lib_prefix=no
- need_version=no
- soname_spec='${libname}${release}${shared_ext}$major'
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- shlibpath_var=LD_LIBRARY_PATH
- sys_lib_search_path_spec="/usr/shlib /usr/ccs/lib /usr/lib/cmplrs/cc /usr/lib /usr/local/lib /var/shlib"
- sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
- ;;
-
-sco3.2v5*)
- version_type=osf
- soname_spec='${libname}${release}${shared_ext}$major'
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- shlibpath_var=LD_LIBRARY_PATH
- ;;
-
-solaris*)
- version_type=linux
- need_lib_prefix=no
- need_version=no
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes
- hardcode_into_libs=yes
- # ldd complains unless libraries are executable
- postinstall_cmds='chmod +x $lib'
- ;;
-
-sunos4*)
- version_type=sunos
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
- finish_cmds='PATH="\$PATH:/usr/etc" ldconfig $libdir'
- shlibpath_var=LD_LIBRARY_PATH
- shlibpath_overrides_runpath=yes
- if test "$with_gnu_ld" = yes; then
- need_lib_prefix=no
- fi
- need_version=yes
- ;;
-
-sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
- version_type=linux
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- case $host_vendor in
- sni)
- shlibpath_overrides_runpath=no
- need_lib_prefix=no
- runpath_var=LD_RUN_PATH
- ;;
- siemens)
- need_lib_prefix=no
- ;;
- motorola)
- need_lib_prefix=no
- need_version=no
- shlibpath_overrides_runpath=no
- sys_lib_search_path_spec='/lib /usr/lib /usr/ccs/lib'
- ;;
- esac
- ;;
-
-sysv4*MP*)
- if test -d /usr/nec ;then
- version_type=linux
- library_names_spec='$libname${shared_ext}.$versuffix $libname${shared_ext}.$major $libname${shared_ext}'
- soname_spec='$libname${shared_ext}.$major'
- shlibpath_var=LD_LIBRARY_PATH
- fi
- ;;
-
-uts4*)
- version_type=linux
- library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
- soname_spec='${libname}${release}${shared_ext}$major'
- shlibpath_var=LD_LIBRARY_PATH
- ;;
-
-*)
- dynamic_linker=no
- ;;
-esac
-AC_MSG_RESULT([$dynamic_linker])
-test "$dynamic_linker" = no && can_build_shared=no
-_LT_DECL([], [need_lib_prefix], [0],
- [Do we need the "lib" prefix for modules?])
-_LT_DECL([], [need_version], [0], [Do we need a version for libraries?])
-_LT_DECL([], [version_type], [0], [Library versioning type])
-_LT_DECL([], [runpath_var], [0], [Shared library runtime path variable])
-_LT_DECL([], [shlibpath_var], [0],[Shared library path variable])
-_LT_DECL([], [shlibpath_overrides_runpath], [0],
- [Is shibpath searched before the hard-coded library search path?])
-_LT_DECL([], [libname_spec], [1], [Format of library name prefix])
-_LT_DECL([], [library_names_spec], [1],
- [List of archive names. First name is the real one, the rest are links.
- The last name is the one that the linker finds with -lNAME])
-_LT_DECL([], [soname_spec], [1],
- [The coded name of the library, if different from the real name])
-_LT_DECL([], [postinstall_cmds], [2],
- [Command to use after installation of a shared archive])
-_LT_DECL([], [postuninstall_cmds], [2],
- [Command to use after uninstallation of a shared archive])
-_LT_DECL([], [finish_cmds], [2],
- [Commands used to finish a libtool library installation in a directory])
-_LT_DECL([], [finish_eval], [1],
- [As "finish_cmds", except a single script fragment to be evaled but
- not shown])
-_LT_DECL([], [hardcode_into_libs], [0],
- [Whether we should hardcode library paths into libraries])
-_LT_DECL([], [sys_lib_search_path_spec], [2],
- [Compile-time system search path for libraries])
-_LT_DECL([], [sys_lib_dlsearch_path_spec], [2],
- [Run-time system search path for libraries])
-])# AC_LIBTOOL_SYS_DYNAMIC_LINKER
-
-
-# AC_PATH_TOOL_PREFIX
-# -------------------
-# find a file program which can recognise shared library
-AC_DEFUN([AC_PATH_TOOL_PREFIX],
-[AC_REQUIRE([LT_AC_PROG_EGREP])dnl
-AC_MSG_CHECKING([for $1])
-AC_CACHE_VAL(lt_cv_path_MAGIC_CMD,
-[case $MAGIC_CMD in
-[[\\/*] | ?:[\\/]*])
- lt_cv_path_MAGIC_CMD="$MAGIC_CMD" # Let the user override the test with a path.
- ;;
-*)
- lt_save_MAGIC_CMD="$MAGIC_CMD"
- lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
-dnl $ac_dummy forces splitting on constant user-supplied paths.
-dnl POSIX.2 word splitting is done only on the output of word expansions,
-dnl not every word. This closes a longstanding sh security hole.
- ac_dummy="m4_if([$2], , $PATH, [$2])"
- for ac_dir in $ac_dummy; do
- IFS="$lt_save_ifs"
- test -z "$ac_dir" && ac_dir=.
- if test -f $ac_dir/$1; then
- lt_cv_path_MAGIC_CMD="$ac_dir/$1"
- if test -n "$file_magic_test_file"; then
- case $deplibs_check_method in
- "file_magic "*)
- file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
- MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
- if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
- $EGREP "$file_magic_regex" > /dev/null; then
- :
- else
- cat <<_LT_EOF 1>&2
-
-*** Warning: the command libtool uses to detect shared libraries,
-*** $file_magic_cmd, produces output that libtool cannot recognize.
-*** The result is that libtool may fail to recognize shared libraries
-*** as such. This will affect the creation of libtool libraries that
-*** depend on shared libraries, but programs linked with such libtool
-*** libraries will work regardless of this problem. Nevertheless, you
-*** may want to report the problem to your system manager and/or to
-*** bug-libtool@gnu.org
-
-_LT_EOF
- fi ;;
- esac
- fi
- break
- fi
- done
- IFS="$lt_save_ifs"
- MAGIC_CMD="$lt_save_MAGIC_CMD"
- ;;
-esac])
-MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
-if test -n "$MAGIC_CMD"; then
- AC_MSG_RESULT($MAGIC_CMD)
-else
- AC_MSG_RESULT(no)
-fi
-_LT_DECL([], [MAGIC_CMD], [0],
- [Used to examine libraries when file_magic_cmd begins "file"])dnl
-])# AC_PATH_TOOL_PREFIX
-
-
-# AC_PATH_MAGIC
-# -------------
-# find a file program which can recognise a shared library
-AC_DEFUN([AC_PATH_MAGIC],
-[AC_PATH_TOOL_PREFIX(${ac_tool_prefix}file, /usr/bin$PATH_SEPARATOR$PATH)
-if test -z "$lt_cv_path_MAGIC_CMD"; then
- if test -n "$ac_tool_prefix"; then
- AC_PATH_TOOL_PREFIX(file, /usr/bin$PATH_SEPARATOR$PATH)
- else
- MAGIC_CMD=:
- fi
-fi
-])# AC_PATH_MAGIC
-
-
-# AC_PROG_LD
-# ----------
-# find the pathname to the GNU or non-GNU linker
-AC_DEFUN([AC_PROG_LD],
-[AC_ARG_WITH([gnu-ld],
- [AC_HELP_STRING([--with-gnu-ld],
- [assume the C compiler uses GNU ld @<:@default=no@:>@])],
- [test "$withval" = no || with_gnu_ld=yes],
- [with_gnu_ld=no])
-AC_REQUIRE([LT_AC_PROG_SED])dnl
-AC_REQUIRE([LT_AC_PROG_EGREP])dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([AC_CANONICAL_BUILD])dnl
-
-ac_prog=ld
-if test "$GCC" = yes; then
- # Check if gcc -print-prog-name=ld gives a path.
- AC_MSG_CHECKING([for ld used by $CC])
- case $host in
- *-*-mingw*)
- # gcc leaves a trailing carriage return which upsets mingw
- ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
- *)
- ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
- esac
- case $ac_prog in
- # Accept absolute paths.
- [[\\/]]* | ?:[[\\/]]*)
- re_direlt='/[[^/]][[^/]]*/\.\./'
- # Canonicalize the pathname of ld
- ac_prog=`echo $ac_prog| $SED 's%\\\\%/%g'`
- while echo $ac_prog | $GREP "$re_direlt" > /dev/null 2>&1; do
- ac_prog=`echo $ac_prog| $SED "s%$re_direlt%/%"`
- done
- test -z "$LD" && LD="$ac_prog"
- ;;
- "")
- # If it fails, then pretend we aren't using GCC.
- ac_prog=ld
- ;;
- *)
- # If it is relative, then search for the first ld in PATH.
- with_gnu_ld=unknown
- ;;
- esac
-elif test "$with_gnu_ld" = yes; then
- AC_MSG_CHECKING([for GNU ld])
-else
- AC_MSG_CHECKING([for non-GNU ld])
-fi
-AC_CACHE_VAL(lt_cv_path_LD,
-[if test -z "$LD"; then
- lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
- for ac_dir in $PATH; do
- IFS="$lt_save_ifs"
- test -z "$ac_dir" && ac_dir=.
- if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
- lt_cv_path_LD="$ac_dir/$ac_prog"
- # Check to see if the program is GNU ld. I'd rather use --version,
- # but apparently some GNU ld's only accept -v.
- # Break only if it was the GNU/non-GNU ld that we prefer.
- case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
- *GNU* | *'with BFD'*)
- test "$with_gnu_ld" != no && break
- ;;
- *)
- test "$with_gnu_ld" != yes && break
- ;;
- esac
- fi
- done
- IFS="$lt_save_ifs"
-else
- lt_cv_path_LD="$LD" # Let the user override the test with a path.
-fi])
-LD="$lt_cv_path_LD"
-if test -n "$LD"; then
- AC_MSG_RESULT($LD)
-else
- AC_MSG_RESULT(no)
-fi
-test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
-AC_PROG_LD_GNU
-AC_SUBST([LD])
-
-_LT_TAGDECL([], [LD], [1], [The linker used to build libraries])
-])# AC_PROG_LD
-
-# Old name:
-AU_DEFUN([AM_PROG_LD], [AC_PROG_LD])
-
-
-# AC_PROG_LD_GNU
-# --------------
-AC_DEFUN([AC_PROG_LD_GNU],
-[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
-[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
-case `$LD -v 2>&1 </dev/null` in
-*GNU* | *'with BFD'*)
- lt_cv_prog_gnu_ld=yes
- ;;
-*)
- lt_cv_prog_gnu_ld=no
- ;;
-esac])
-with_gnu_ld=$lt_cv_prog_gnu_ld
-])# AC_PROG_LD_GNU
-
-
-# AC_PROG_LD_RELOAD_FLAG
-# ----------------------
-# find reload flag for linker
-# -- PORTME Some linkers may need a different reload flag.
-AC_DEFUN([AC_PROG_LD_RELOAD_FLAG],
-[AC_CACHE_CHECK([for $LD option to reload object files],
- lt_cv_ld_reload_flag,
- [lt_cv_ld_reload_flag='-r'])
-reload_flag=$lt_cv_ld_reload_flag
-case $reload_flag in
-"" | " "*) ;;
-*) reload_flag=" $reload_flag" ;;
-esac
-reload_cmds='$LD$reload_flag -o $output$reload_objs'
-case $host_os in
- darwin*)
- if test "$GCC" = yes; then
- reload_cmds='$CC -nostdlib ${wl}-r -o $output$reload_objs'
- else
- reload_cmds='$LD$reload_flag -o $output$reload_objs'
- fi
- ;;
-esac
-_LT_DECL([], [reload_flag], [1], [How to create reloadable object files])dnl
-_LT_DECL([], [reload_cmds], [2])dnl
-])# AC_PROG_LD_RELOAD_FLAG
-
-
-# AC_DEPLIBS_CHECK_METHOD
-# -----------------------
-# how to check for library dependencies
-# -- PORTME fill in with the dynamic library characteristics
-AC_DEFUN([AC_DEPLIBS_CHECK_METHOD],
-[AC_REQUIRE([LT_AC_PROG_EGREP])
-AC_CACHE_CHECK([how to recognise dependent libraries],
-lt_cv_deplibs_check_method,
-[lt_cv_file_magic_cmd='$MAGIC_CMD'
-lt_cv_file_magic_test_file=
-lt_cv_deplibs_check_method='unknown'
-# Need to set the preceding variable on all platforms that support
-# interlibrary dependencies.
-# 'none' -- dependencies not supported.
-# `unknown' -- same as none, but documents that we really don't know.
-# 'pass_all' -- all dependencies passed with no checks.
-# 'test_compile' -- check by making test program.
-# 'file_magic [[regex]]' -- check by looking for files in library path
-# which responds to the $file_magic_cmd with a given extended regex.
-# If you have `file' or equivalent on your system and you're not sure
-# whether `pass_all' will *always* work, you probably want this one.
-
-case $host_os in
-aix4* | aix5*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-beos*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-bsdi4*)
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
- lt_cv_file_magic_cmd='/usr/bin/file -L'
- lt_cv_file_magic_test_file=/shlib/libc.so
- ;;
-
-cygwin*)
- # func_win32_libid is a shell function defined in ltmain.sh
- lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
- lt_cv_file_magic_cmd='func_win32_libid'
- ;;
-
- # Base MSYS/MinGW do not provide the 'file' command needed by
- # func_win32_libid shell function, so use a weaker test based on 'objdump'.
-mingw* | pw32*)
- lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
- lt_cv_file_magic_cmd='$OBJDUMP -f'
- ;;
-
-darwin* | rhapsody*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-freebsd* | kfreebsd*-gnu)
- if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
- case $host_cpu in
- i*86 )
- # Not sure whether the presence of OpenBSD here was a mistake.
- # Let's accept both of them until this is cleared up.
- lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library'
- lt_cv_file_magic_cmd=/usr/bin/file
- lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
- ;;
- esac
- else
- lt_cv_deplibs_check_method=pass_all
- fi
- ;;
-
-gnu*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-hpux10.20* | hpux11*)
- lt_cv_file_magic_cmd=/usr/bin/file
- case "$host_cpu" in
- ia64*)
- lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
- lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
- ;;
- hppa*64*)
- [lt_cv_deplibs_check_method='file_magic (s[0-9][0-9][0-9]|ELF-[0-9][0-9]) shared object file - PA-RISC [0-9].[0-9]']
- lt_cv_file_magic_test_file=/usr/lib/pa20_64/libc.sl
- ;;
- *)
- lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|PA-RISC[[0-9]].[[0-9]]) shared library'
- lt_cv_file_magic_test_file=/usr/lib/libc.sl
- ;;
- esac
- ;;
-
-irix5* | irix6* | nonstopux*)
- case $LD in
- *-32|*"-32 ") libmagic=32-bit;;
- *-n32|*"-n32 ") libmagic=N32;;
- *-64|*"-64 ") libmagic=64-bit;;
- *) libmagic=never-match;;
- esac
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-# This must be Linux ELF.
-linux*)
- case $host_cpu in
- alpha*|hppa*|i*86|ia64*|m68*|mips*|powerpc*|sparc*|s390*|sh*)
- lt_cv_deplibs_check_method=pass_all ;;
- *)
- # glibc up to 2.1.1 does not perform some relocations on ARM
- # this will be overridden with pass_all, but let us keep it just in case
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;;
- esac
- lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-netbsd* | knetbsd*-gnu)
- if echo __ELF__ | $CC -E - | $GREP __ELF__ > /dev/null; then
- lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
- else
- lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|_pic\.a)$'
- fi
- ;;
-
-newos6*)
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (executable|dynamic lib)'
- lt_cv_file_magic_cmd=/usr/bin/file
- lt_cv_file_magic_test_file=/usr/lib/libnls.so
- ;;
-
-nto-qnx*)
- lt_cv_deplibs_check_method=unknown
- ;;
-
-openbsd*)
- lt_cv_file_magic_cmd=/usr/bin/file
- lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
- if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'
- else
- lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'
- fi
- ;;
-
-osf3* | osf4* | osf5*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-sco3.2v5*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-solaris*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-
-sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
- case $host_vendor in
- motorola)
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
- lt_cv_file_magic_test_file=`echo /usr/lib/libc.so*`
- ;;
- ncr)
- lt_cv_deplibs_check_method=pass_all
- ;;
- sequent)
- lt_cv_file_magic_cmd='/bin/file'
- lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )'
- ;;
- sni)
- lt_cv_file_magic_cmd='/bin/file'
- lt_cv_deplibs_check_method="file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB dynamic lib"
- lt_cv_file_magic_test_file=/lib/libc.so
- ;;
- siemens)
- lt_cv_deplibs_check_method=pass_all
- ;;
- esac
- ;;
-
-sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)
- lt_cv_deplibs_check_method=pass_all
- ;;
-esac
-])
-file_magic_cmd=$lt_cv_file_magic_cmd
-deplibs_check_method=$lt_cv_deplibs_check_method
-test -z "$deplibs_check_method" && deplibs_check_method=unknown
-
-_LT_DECL([], [deplibs_check_method], [1],
- [Method to check whether dependent libraries are shared objects])
-_LT_DECL([], [file_magic_cmd], [1],
- [Command to use when deplibs_check_method == "file_magic"])
-])# AC_DEPLIBS_CHECK_METHOD
-
-
-# AC_PROG_NM
-# ----------
-# find the pathname to a BSD-compatible name lister
-AC_DEFUN([AC_PROG_NM],
-[AC_CACHE_CHECK([for BSD-compatible nm], lt_cv_path_NM,
-[if test -n "$NM"; then
- # Let the user override the test.
- lt_cv_path_NM="$NM"
-else
- lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
- for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
- IFS="$lt_save_ifs"
- test -z "$ac_dir" && ac_dir=.
- tmp_nm="$ac_dir/${ac_tool_prefix}nm"
- if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
- # Check to see if the nm accepts a BSD-compat flag.
- # Adding the `sed 1q' prevents false positives on HP-UX, which says:
- # nm: unknown option "B" ignored
- # Tru64's nm complains that /dev/null is an invalid object file
- case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
- */dev/null* | *'Invalid file or object type'*)
- lt_cv_path_NM="$tmp_nm -B"
- break
- ;;
- *)
- case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
- */dev/null*)
- lt_cv_path_NM="$tmp_nm -p"
- break
- ;;
- *)
- lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
- continue # so that we can try to find one that supports BSD flags
- ;;
- esac
- esac
- fi
- done
- IFS="$lt_save_ifs"
- test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
-fi])
-NM="$lt_cv_path_NM"
-test -z "$NM" && NM=nm
-AC_SUBST([NM])
-_LT_DECL([], [NM], [1], [A BSD-compatible nm program])dnl
-])# AC_PROG_NM
-
-# Old name:
-AU_DEFUN([AM_PROG_NM], [AC_PROG_NM])
-
-
-# AC_CHECK_LIBM
-# -------------
-# check for math library
-AC_DEFUN([AC_CHECK_LIBM],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-LIBM=
-case $host in
-*-*-beos* | *-*-cygwin* | *-*-pw32* | *-*-darwin*)
- # These system don't have libm, or don't need it
- ;;
-*-ncr-sysv4.3*)
- AC_CHECK_LIB(mw, _mwvalidcheckl, LIBM="-lmw")
- AC_CHECK_LIB(m, cos, LIBM="$LIBM -lm")
- ;;
-*)
- AC_CHECK_LIB(m, cos, LIBM="-lm")
- ;;
-esac
-])# AC_CHECK_LIBM
-
-
-# AC_LIBLTDL_CONVENIENCE([DIRECTORY])
-# -----------------------------------
-# sets LIBLTDL to the link flags for the libltdl convenience library and
-# LTDLINCL to the include flags for the libltdl header and adds
-# --enable-ltdl-convenience to the configure arguments. Note that LIBLTDL
-# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If
-# DIRECTORY is not provided, it is assumed to be `libltdl'. LIBLTDL will
-# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with
-# '${top_srcdir}/' (note the single quotes!). If your package is not
-# flat and you're not using automake, define top_builddir and
-# top_srcdir appropriately in the Makefiles.
-AC_DEFUN([AC_LIBLTDL_CONVENIENCE],
-[case $enable_ltdl_convenience in
- no) AC_MSG_ERROR([this package needs a convenience libltdl]) ;;
- "") enable_ltdl_convenience=yes
- ac_configure_args="$ac_configure_args --enable-ltdl-convenience" ;;
- esac
- LIBLTDL='${top_builddir}/'m4_if($#, 1,[$1], ['libltdl'])/libltdlc.la
- LTDLINCL='-I${top_srcdir}/'m4_if($#, 1, [$1], ['libltdl'])
- # For backwards non-gettext consistent compatibility...
- INCLTDL="$LTDLINCL"
-])# AC_LIBLTDL_CONVENIENCE
-
-
-# AC_LIBLTDL_INSTALLABLE([DIRECTORY])
-# -----------------------------------
-# sets LIBLTDL to the link flags for the libltdl installable library and
-# LTDLINCL to the include flags for the libltdl header and adds
-# --enable-ltdl-install to the configure arguments. Note that LIBLTDL
-# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called. If
-# DIRECTORY is not provided and an installed libltdl is not found, it is
-# assumed to be `libltdl'. LIBLTDL will be prefixed with '${top_builddir}/'
-# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single
-# quotes!). If your package is not flat and you're not using automake,
-# define top_builddir and top_srcdir appropriately in the Makefiles.
-# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
-AC_DEFUN([AC_LIBLTDL_INSTALLABLE],
-[AC_CHECK_LIB(ltdl, lt_dlinit,
- [test x"$enable_ltdl_install" != xyes && enable_ltdl_install=no],
- [if test x"$enable_ltdl_install" = xno; then
- AC_MSG_WARN([libltdl not installed, but installation disabled])
- else
- enable_ltdl_install=yes
- fi
- ])
- if test x"$enable_ltdl_install" = x"yes"; then
- ac_configure_args="$ac_configure_args --enable-ltdl-install"
- LIBLTDL='${top_builddir}/'m4_if($#, 1, [$1], ['libltdl'])/libltdl.la
- LTDLINCL='-I${top_srcdir}/'m4_if($#, 1, [$1], ['libltdl'])
- else
- ac_configure_args="$ac_configure_args --enable-ltdl-install=no"
- LIBLTDL="-lltdl"
- LTDLINCL=
- fi
- # For backwards non-gettext consistent compatibility...
- INCLTDL="$LTDLINCL"
-])# AC_LIBLTDL_INSTALLABLE
-
-
-# AC_LIBTOOL_PROG_COMPILER_NO_RTTI([TAGNAME])
-# -------------------------------------------
-AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_NO_RTTI],
-[AC_REQUIRE([_LT_AC_SYS_COMPILER])dnl
-
-_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
-
-if test "$GCC" = yes; then
- _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
-
- AC_LIBTOOL_COMPILER_OPTION([if $compiler supports -fno-rtti -fno-exceptions],
- lt_cv_prog_compiler_rtti_exceptions,
- [-fno-rtti -fno-exceptions], [],
- [_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1) -fno-rtti -fno-exceptions"])
-fi
-_LT_TAGDECL([no_builtin_flag], [lt_prog_compiler_no_builtin_flag], [1],
- [Compiler flag to turn off builtin functions])
-])# AC_LIBTOOL_PROG_COMPILER_NO_RTTI
-
-
-# AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
-# ---------------------------------
-AC_DEFUN([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE],
-[AC_REQUIRE([AC_CANONICAL_HOST])dnl
-AC_REQUIRE([LT_AC_PROG_EGREP])dnl
-AC_REQUIRE([AC_PROG_CC])dnl
-AC_REQUIRE([AC_PROG_LD])dnl
-AC_REQUIRE([AC_PROG_NM])dnl
-AC_REQUIRE([AC_OBJEXT])dnl
-# Check for command to grab the raw symbol name followed by C symbol from nm.
-AC_MSG_CHECKING([command to parse $NM output from $compiler object])
-AC_CACHE_VAL([lt_cv_sys_global_symbol_pipe],
-[
-# These are sane defaults that work on at least a few old systems.
-# [They come from Ultrix. What could be older than Ultrix?!! ;)]
-
-# Character class describing NM global symbol codes.
-symcode='[[BCDEGRST]]'
-
-# Regexp to match symbols that can be accessed directly from C.
-sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
-
-# Transform the above into a raw symbol and a C symbol.
-symxfrm='\1 \2\3 \3'
-
-# Transform an extracted symbol line into a proper C declaration
-lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
-
-# Transform an extracted symbol line into symbol name and symbol address
-lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'"
-
-# Define system-specific variables.
-case $host_os in
-aix*)
- symcode='[[BCDT]]'
- ;;
-cygwin* | mingw* | pw32*)
- symcode='[[ABCDGISTW]]'
- ;;
-hpux*) # Its linker distinguishes data from code symbols
- if test "$host_cpu" = ia64; then
- symcode='[[ABCDEGRST]]'
- fi
- lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
- lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/ {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/ {\"\2\", (lt_ptr) \&\2},/p'"
- ;;
-irix* | nonstopux*)
- symcode='[[BCDEGRST]]'
- ;;
-osf*)
- symcode='[[BCDEGQRST]]'
- ;;
-solaris* | sysv5*)
- symcode='[[BDRT]]'
- ;;
-sysv4)
- symcode='[[DFNSTU]]'
- ;;
-esac
-
-# Handle CRLF in mingw tool chain
-opt_cr=
-case $build_os in
-mingw*)
- opt_cr=`echo 'x\{0,1\}' | tr x '\015'` # option cr in regexp
- ;;
-esac
-
-# If we're using GNU nm, then use its standard symbol codes.
-case `$NM -V 2>&1` in
-*GNU* | *'with BFD'*)
- symcode='[[ABCDGIRSTW]]' ;;
-esac
-
-# Try without a prefix undercore, then with it.
-for ac_symprfx in "" "_"; do
-
- # Write the raw and C identifiers.
- lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[ ]]\($symcode$symcode*\)[[ ]][[ ]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"
-
- # Check to see that the pipe works correctly.
- pipe_works=no
-
- rm -f conftest*
- cat > conftest.$ac_ext <<_LT_EOF
-#ifdef __cplusplus
-extern "C" {
-#endif
-char nm_test_var;
-void nm_test_func(){}
-#ifdef __cplusplus
-}
-#endif
-int main(){nm_test_var='a';nm_test_func();return(0);}
-_LT_EOF
-
- if AC_TRY_EVAL(ac_compile); then
- # Now try to grab the symbols.
- nlist=conftest.nm
- if AC_TRY_EVAL(NM conftest.$ac_objext \| $lt_cv_sys_global_symbol_pipe \> $nlist) && test -s "$nlist"; then
- # Try sorting and uniquifying the output.
- if sort "$nlist" | uniq > "$nlist"T; then
- mv -f "$nlist"T "$nlist"
- else
- rm -f "$nlist"T
- fi
-
- # Make sure that we snagged all the symbols we need.
- if $GREP ' nm_test_var$' "$nlist" >/dev/null; then
- if $GREP ' nm_test_func$' "$nlist" >/dev/null; then
- cat <<_LT_EOF > conftest.$ac_ext
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-_LT_EOF
- # Now generate the symbol file.
- eval "$lt_cv_sys_global_symbol_to_cdecl"' < "$nlist" | $GREP -v main >> conftest.$ac_ext'
-
- cat <<_LT_EOF >> conftest.$ac_ext
-#if defined (__STDC__) && __STDC__
-# define lt_ptr_t void *
-#else
-# define lt_ptr_t char *
-# define const
-#endif
-
-/* The mapping between symbol names and symbols. */
-const struct {
- const char *name;
- lt_ptr_t address;
-}
-lt_preloaded_symbols[[]] =
-{
-_LT_EOF
- $SED "s/^$symcode$symcode* \(.*\) \(.*\)$/ {\"\2\", (lt_ptr_t) \&\2},/" < "$nlist" | $GREP -v main >> conftest.$ac_ext
- cat <<\_LT_EOF >> conftest.$ac_ext
- {0, (lt_ptr_t) 0}
-};
-
-#ifdef __cplusplus
-}
-#endif
-_LT_EOF
- # Now try linking the two files.
- mv conftest.$ac_objext conftstm.$ac_objext
- lt_save_LIBS="$LIBS"
- lt_save_CFLAGS="$CFLAGS"
- LIBS="conftstm.$ac_objext"
- CFLAGS="$CFLAGS$_LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)"
- if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext}; then
- pipe_works=yes
- fi
- LIBS="$lt_save_LIBS"
- CFLAGS="$lt_save_CFLAGS"
- else
- echo "cannot find nm_test_func in $nlist" >&AS_MESSAGE_LOG_FD
- fi
- else
- echo "cannot find nm_test_var in $nlist" >&AS_MESSAGE_LOG_FD
- fi
- else
- echo "cannot run $lt_cv_sys_global_symbol_pipe" >&AS_MESSAGE_LOG_FD
- fi
- else
- echo "$progname: failed program was:" >&AS_MESSAGE_LOG_FD
- cat conftest.$ac_ext >&5
- fi
- rm -f conftest* conftst*
-
- # Do not use the global_symbol_pipe unless it works.
- if test "$pipe_works" = yes; then
- break
- else
- lt_cv_sys_global_symbol_pipe=
- fi
-done
-])
-if test -z "$lt_cv_sys_global_symbol_pipe"; then
- lt_cv_sys_global_symbol_to_cdecl=
-fi
-if test -z "$lt_cv_sys_global_symbol_pipe$lt_cv_sys_global_symbol_to_cdecl"; then
- AC_MSG_RESULT(failed)
-else
- AC_MSG_RESULT(ok)
-fi
-
-_LT_DECL([global_symbol_pipe], [lt_cv_sys_global_symbol_pipe], [1],
- [Take the output of nm and produce a listing of raw symbols and C names])
-_LT_DECL([global_symbol_to_cdecl], [lt_cv_sys_global_symbol_to_cdecl], [1],
- [Transform the output of nm in a proper C declaration])
-_LT_DECL([global_symbol_to_c_name_address],
- [lt_cv_sys_global_symbol_to_c_name_address], [1],
- [Transform the output of nm in a C name address pair])
-]) # AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE
-
-
-# AC_LIBTOOL_PROG_COMPILER_PIC([TAGNAME])
-# ---------------------------------------
-AC_DEFUN([AC_LIBTOOL_PROG_COMPILER_PIC],
-[_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)=
-_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
-_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=
-
-AC_MSG_CHECKING([for $compiler option to produce PIC])
-m4_if([$1], [CXX], [
- # C++ specific cases for pic, static, wl, etc.
- if test "$GXX" = yes; then
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
-
- case $host_os in
- aix*)
- # All AIX code is PIC.
- if test "$host_cpu" = ia64; then
- # AIX 5 now supports IA64 processor
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- fi
- ;;
- amigaos*)
- if test "$host_cpu" = m68k; then
- # FIXME: we need at least 68020 code to build shared libraries, but
- # adding the `-m68020' flag to GCC prevents building anything better,
- # like `-m68040'.
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
- fi
- ;;
- beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
- # PIC is the default for these OSes.
- ;;
- mingw* | os2* | pw32*)
- # This hack is so that the source file can tell whether it is being
- # built for inclusion in a dll (and should export symbols for example).
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
- ;;
- darwin* | rhapsody*)
- # PIC is the default on this platform
- # Common symbols not allowed in MH_DYLIB files
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
- ;;
- *djgpp*)
- # DJGPP does not support shared libraries at all
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
- ;;
- sysv4*MP*)
- if test -d /usr/nec; then
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
- fi
- ;;
- hpux*)
- # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
- # not for PA HP-UX.
- case "$host_cpu" in
- hppa*64*|ia64*)
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- esac
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- esac
- else
- case $host_os in
- aix4* | aix5*)
- # All AIX code is PIC.
- if test "$host_cpu" = ia64; then
- # AIX 5 now supports IA64 processor
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- else
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
- fi
- ;;
- chorus*)
- case $cc_basename in
- cxch68)
- # Green Hills C++ Compiler
- # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
- ;;
- esac
- ;;
- darwin*)
- # PIC is the default on this platform
- # Common symbols not allowed in MH_DYLIB files
- case "$cc_basename" in
- xlc*)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- ;;
- esac
- ;;
- dgux*)
- case $cc_basename in
- ec++)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- ;;
- ghcx)
- # Green Hills C++ Compiler
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
- ;;
- *)
- ;;
- esac
- ;;
- freebsd* | kfreebsd*-gnu)
- # FreeBSD uses GNU C++
- ;;
- hpux9* | hpux10* | hpux11*)
- case $cc_basename in
- CC)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
- if test "$host_cpu" != ia64; then
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
- fi
- ;;
- aCC)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
- case "$host_cpu" in
- hppa*64*|ia64*)
- # +Z the default
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
- ;;
- esac
- ;;
- *)
- ;;
- esac
- ;;
- irix5* | irix6* | nonstopux*)
- case $cc_basename in
- CC)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- # CC pic flag -KPIC is the default.
- ;;
- *)
- ;;
- esac
- ;;
- linux*)
- case $cc_basename in
- KCC)
- # KAI C++ Compiler
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- icpc)
- # Intel C++
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
- ;;
- cxx)
- # Compaq C++
- # Make sure the PIC flag is empty. It appears that all Alpha
- # Linux and Compaq Tru64 Unix objects are PIC.
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- ;;
- *)
- ;;
- esac
- ;;
- lynxos*)
- ;;
- m88k*)
- ;;
- mvs*)
- case $cc_basename in
- cxx)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
- ;;
- *)
- ;;
- esac
- ;;
- netbsd*)
- ;;
- osf3* | osf4* | osf5*)
- case $cc_basename in
- KCC)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
- ;;
- RCC)
- # Rational C++ 2.4.1
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
- ;;
- cxx)
- # Digital/Compaq C++
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- # Make sure the PIC flag is empty. It appears that all Alpha
- # Linux and Compaq Tru64 Unix objects are PIC.
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- ;;
- *)
- ;;
- esac
- ;;
- psos*)
- ;;
- sco*)
- case $cc_basename in
- CC)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- *)
- ;;
- esac
- ;;
- solaris*)
- case $cc_basename in
- CC)
- # Sun C++ 4.2, 5.x and Centerline C++
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
- ;;
- gcx)
- # Green Hills C++ Compiler
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
- ;;
- *)
- ;;
- esac
- ;;
- sunos4*)
- case $cc_basename in
- CC)
- # Sun C++ 4.x
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
- lcc)
- # Lucid
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
- ;;
- *)
- ;;
- esac
- ;;
- tandem*)
- case $cc_basename in
- NCC)
- # NonStop-UX NCC 3.20
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- ;;
- *)
- ;;
- esac
- ;;
- unixware*)
- ;;
- vxworks*)
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
- ;;
- esac
- fi
-],
-[
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
-
- case $host_os in
- aix*)
- # All AIX code is PIC.
- if test "$host_cpu" = ia64; then
- # AIX 5 now supports IA64 processor
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- fi
- ;;
-
- amigaos*)
- if test "$host_cpu" = m68k; then
- # FIXME: we need at least 68020 code to build shared libraries, but
- # adding the `-m68020' flag to GCC prevents building anything better,
- # like `-m68040'.
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-m68020 -resident32 -malways-restore-a4'
- fi
- ;;
-
- beos* | cygwin* | irix5* | irix6* | nonstopux* | osf3* | osf4* | osf5*)
- # PIC is the default for these OSes.
- ;;
-
- mingw* | pw32* | os2*)
- # This hack is so that the source file can tell whether it is being
- # built for inclusion in a dll (and should export symbols for example).
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
- ;;
-
- darwin* | rhapsody*)
- # PIC is the default on this platform
- # Common symbols not allowed in MH_DYLIB files
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
- ;;
-
- msdosdjgpp*)
- # Just because we use GCC doesn't mean we suddenly get shared libraries
- # on systems that don't support them.
- _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
- enable_shared=no
- ;;
-
- sysv4*MP*)
- if test -d /usr/nec; then
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
- fi
- ;;
-
- hpux*)
- # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
- # not for PA HP-UX.
- case "$host_cpu" in
- hppa*64*|ia64*)
- # +Z the default
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- esac
- ;;
-
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
- ;;
- esac
- else
- # PORTME Check for flag to pass linker flags through the system compiler.
- case $host_os in
- aix*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- if test "$host_cpu" = ia64; then
- # AIX 5 now supports IA64 processor
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- else
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
- fi
- ;;
- darwin*)
- # PIC is the default on this platform
- # Common symbols not allowed in MH_DYLIB files
- case "$cc_basename" in
- xlc*)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- ;;
- esac
- ;;
-
- mingw* | pw32* | os2*)
- # This hack is so that the source file can tell whether it is being
- # built for inclusion in a dll (and should export symbols for example).
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-DDLL_EXPORT'
- ;;
-
- hpux9* | hpux10* | hpux11*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
- # not for PA HP-UX.
- case "$host_cpu" in
- hppa*64*|ia64*)
- # +Z the default
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
- ;;
- esac
- # Is there a better lt_prog_compiler_static that works with the bundled CC?
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
- ;;
-
- irix5* | irix6* | nonstopux*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- # PIC (with -KPIC) is the default.
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- ;;
-
- newsos6)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
-
- linux*)
- case $CC in
- icc* | ecc*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
- ;;
- ccc*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- # All Alpha code is PIC.
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- ;;
- esac
- ;;
-
- osf3* | osf4* | osf5*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- # All OSF/1 code is PIC.
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
- ;;
-
- sco3.2v5*)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kpic'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-dn'
- ;;
-
- solaris*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
-
- sunos4*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
-
- sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
- _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
-
- sysv4*MP*)
- if test -d /usr/nec ;then
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kconform_pic'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- fi
- ;;
-
- uts4*)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
- _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
- ;;
-
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
- ;;
- esac
- fi
-])
-case "$host_os" in
- # For platforms which do not support PIC, -DPIC is meaningless:
- *djgpp*)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
- ;;
- *)
- _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])"
- ;;
-esac
-AC_MSG_RESULT([$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)])
-_LT_TAGDECL([wl], [lt_prog_compiler_wl], [1],
- [How to pass a linker flag through the compiler])
-
-#
-# Check to make sure the PIC flag actually works.
-#
-if test -n "$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)"; then
- AC_LIBTOOL_COMPILER_OPTION([if $compiler PIC flag $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) works],
- [_LT_AC_TAGVAR(lt_prog_compiler_pic_works, $1)],
- [$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)@&t@m4_if([$1],[],[ -DPIC],[m4_if([$1],[CXX],[ -DPIC],[])])], [],
- [case $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1) in
- "" | " "*) ;;
- *) _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=" $_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)" ;;
- esac],
- [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
- _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
-fi
-_LT_TAGDECL([pic_flag], [lt_prog_compiler_pic], [1],
- [Additional compiler flags for building library objects])
-
-#
-# Check to make sure the static flag actually works.
-#
-AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $_LT_AC_TAGVAR(lt_prog_compiler_static, $1) works],
- _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),
- $_LT_AC_TAGVAR(lt_prog_compiler_static, $1),
- [],
- [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])
-_LT_TAGDECL([link_static_flag], [lt_prog_compiler_static], [1],
- [Compiler flag to prevent dynamic linking])
-])# AC_LIBTOOL_PROG_COMPILER_PIC
-
-
-# AC_LIBTOOL_PROG_LD_SHLIBS([TAGNAME])
-# ------------------------------------
-# See if the linker supports building shared libraries.
-AC_DEFUN([AC_LIBTOOL_PROG_LD_SHLIBS],
-[AC_REQUIRE([LT_AC_PROG_EGREP])dnl
-AC_REQUIRE([AC_PROG_LD])dnl
-AC_REQUIRE([AC_PROG_NM])dnl
-AC_REQUIRE([AC_LIBTOOL_SYS_GLOBAL_SYMBOL_PIPE])dnl
-AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
-m4_if([$1], [CXX], [
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
- case $host_os in
- aix4* | aix5*)
- # If we're using GNU nm, then we don't want the "-C" option.
- # -C means demangle to AIX nm, but means don't demangle with GNU nm
- if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
- else
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
- fi
- ;;
- pw32*)
- _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
- ;;
- cygwin* | mingw*)
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([[^ ]]*\) [[^ ]]*/\1 DATA/;/^I /d;/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
- ;;
- *)
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
- ;;
- esac
-], [
- runpath_var=
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=
- _LT_AC_TAGVAR(always_export_symbols, $1)=no
- _LT_AC_TAGVAR(archive_cmds, $1)=
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)=
- _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
- _LT_AC_TAGVAR(hardcode_automatic, $1)=no
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
- _LT_AC_TAGVAR(inherit_rpath, $1)=no
- _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
- _LT_AC_TAGVAR(module_cmds, $1)=
- _LT_AC_TAGVAR(module_expsym_cmds, $1)=
- _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)=
- _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1)=
- _LT_AC_TAGVAR(thread_safe_flag_spec, $1)=
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
- # include_expsyms should be a list of space-separated symbols to be *always*
- # included in the symbol list
- _LT_AC_TAGVAR(include_expsyms, $1)=
- # exclude_expsyms can be an extended regexp of symbols to exclude
- # it will be wrapped by ` (' and `)$', so one must not match beginning or
- # end of line. Example: `a|bc|.*d.*' will exclude the symbols `a' and `bc',
- # as well as any symbol that contains `d'.
- _LT_AC_TAGVAR(exclude_expsyms, $1)="_GLOBAL_OFFSET_TABLE_"
- # Although _GLOBAL_OFFSET_TABLE_ is a valid symbol C name, most a.out
- # platforms (ab)use it in PIC code, but their linkers get confused if
- # the symbol is explicitly referenced. Since portable code cannot
- # rely on this symbol name, it's probably fine to never include it in
- # preloaded symbol tables.
- extract_expsyms_cmds=
-
- case $host_os in
- cygwin* | mingw* | pw32*)
- # FIXME: the MSVC++ port hasn't been tested in a loooong time
- # When not using gcc, we currently assume that we are using
- # Microsoft Visual C++.
- if test "$GCC" != yes; then
- with_gnu_ld=no
- fi
- ;;
- openbsd*)
- with_gnu_ld=no
- ;;
- esac
-
- _LT_AC_TAGVAR(ld_shlibs, $1)=yes
- if test "$with_gnu_ld" = yes; then
- # If archive_cmds runs LD, not CC, wlarc should be empty
- wlarc='${wl}'
-
- # See if GNU ld supports shared libraries.
- case $host_os in
- aix3* | aix4* | aix5*)
- # On AIX/PPC, the GNU linker is very broken
- if test "$host_cpu" != ia64; then
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- cat <<_LT_EOF 1>&2
-
-*** Warning: the GNU linker, at least up to release 2.9.1, is reported
-*** to be unable to reliably create shared libraries on AIX.
-*** Therefore, libtool is disabling shared libraries support. If you
-*** really care for shared libraries, you may want to modify your PATH
-*** so that a non-GNU linker is found, and then restart.
-
-_LT_EOF
- fi
- ;;
-
- amigaos*)
- if test "$host_cpu" = m68k; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- fi
-
- # Samuel A. Falvo II <kc5tja@dolphin.openprojects.net> reports
- # that the semantics of dynamic libraries on AmigaOS, at least up
- # to version 4, is to share data among multiple programs linked
- # with the same dynamic library. Since this doesn't match the
- # behavior of shared libraries on other platforms, we can't use
- # them.
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
-
- beos*)
- if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
- # support --undefined. This deserves some investigation. FIXME
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
- else
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
-
- cygwin* | mingw* | pw32*)
- # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
- # as there is no search path for DLLs.
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- _LT_AC_TAGVAR(always_export_symbols, $1)=no
- _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
-
- if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
- # If the export-symbols file already is a .def file (1st line
- # is EXPORTS), use it as is; otherwise, prepend...
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
- cp $export_symbols $output_objdir/$soname.def;
- else
- echo EXPORTS > $output_objdir/$soname.def;
- cat $export_symbols >> $output_objdir/$soname.def;
- fi~
- $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
- else
- ld_shlibs=no
- fi
- ;;
-
- netbsd*)
- if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
- wlarc=
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
- fi
- ;;
-
- solaris* | sysv5*)
- if $LD -v 2>&1 | $GREP 'BFD 2\.8' > /dev/null; then
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- cat <<_LT_EOF 1>&2
-
-*** Warning: The releases 2.8.* of the GNU linker cannot reliably
-*** create shared libraries on Solaris systems. Therefore, libtool
-*** is disabling shared libraries support. We urge you to upgrade GNU
-*** binutils to release 2.9.1 or newer. Another option is to modify
-*** your PATH or compiler configuration so that the native linker is
-*** used, and then restart.
-
-_LT_EOF
- elif $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
- else
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
-
- sunos4*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
- wlarc=
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- linux*)
- if $LD --help 2>&1 | $EGREP ': supported targets:.* elf' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
- case `$LD -v 2>&1` in
- *\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
- *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
- *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
- *\ 2.11.*) ;; # other 2.11 versions
- *) supports_anon_versioning=yes ;;
- esac
- if test "x$supports_anon_versioning" = xyes; then
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~$echo "local: *; };" >> $output_objdir/$libname.ver~$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
- else
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)=$_LT_AC_TAGVAR(archive_cmds, $1)
- fi
- else
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
-
- *)
- if $LD --help 2>&1 | $GREP ': supported targets:.* elf' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
- else
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- esac
-
- if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = yes; then
- runpath_var=LD_RUN_PATH
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
- # ancient GNU ld didn't support --whole-archive et. al.
- if $LD --help 2>&1 | $GREP 'no-whole-archive' > /dev/null; then
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
- else
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
- fi
- fi
- else
- # PORTME fill in a description of your system's linker (not GNU ld)
- case $host_os in
- aix3*)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- _LT_AC_TAGVAR(always_export_symbols, $1)=yes
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -o $output_objdir/$soname $libobjs $deplibs $linker_flags -bE:$export_symbols -T512 -H512 -bM:SRE~$AR $AR_FLAGS $lib $output_objdir/$soname'
- # Note: this linker hardcodes the directories in LIBPATH if there
- # are no directories specified by -L.
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- if test "$GCC" = yes && test -z "$link_static_flag"; then
- # Neither direct hardcoding nor static linking is supported with a
- # broken collect2.
- _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
- fi
- ;;
-
- aix4* | aix5*)
- if test "$host_cpu" = ia64; then
- # On IA64, the linker does run time linking by default, so we don't
- # have to do anything special.
- aix_use_runtimelinking=no
- exp_sym_flag='-Bexport'
- no_entry_flag=""
- else
- # If we're using GNU nm, then we don't want the "-C" option.
- # -C means demangle to AIX nm, but means don't demangle with GNU nm
- if $NM -V 2>&1 | $GREP 'GNU' > /dev/null; then
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -Bpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
- else
- _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM -BCpg $libobjs $convenience | awk '\''{ if (((\[$]2 == "T") || (\[$]2 == "D") || (\[$]2 == "B")) && ([substr](\[$]3,1,1) != ".")) { print \[$]3 } }'\'' | sort -u > $export_symbols'
- fi
- aix_use_runtimelinking=no
-
- # Test if we are trying to use run time linking or normal
- # AIX style linking. If -brtl is somewhere in LDFLAGS, we
- # need to do runtime linking.
- case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
- for ld_flag in $LDFLAGS; do
- if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then
- aix_use_runtimelinking=yes
- break
- fi
- done
- esac
-
- exp_sym_flag='-bexport'
- no_entry_flag='-bnoentry'
- fi
-
- # When large executables or shared objects are built, AIX ld can
- # have problems creating the table of contents. If linking a library
- # or program results in "error TOC overflow" add -mminimal-toc to
- # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
- # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
- _LT_AC_TAGVAR(archive_cmds, $1)=''
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
-
- if test "$GCC" = yes; then
- case $host_os in aix4.[012]|aix4.[012].*)
- # We only want to do this on AIX 4.2 and lower, the check
- # below for broken collect2 doesn't work under 4.3+
- collect2name=`${CC} -print-prog-name=collect2`
- if test -f "$collect2name" &&
- strings "$collect2name" | $GREP resolve_lib_name >/dev/null
- then
- # We have reworked collect2
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- else
- # We have old collect2
- _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
- # It fails to find uninstalled libraries when the uninstalled
- # path is not listed in the libpath. Setting hardcode_minus_L
- # to unsupported forces relinking
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
- fi
- esac
- shared_flag='-shared'
- else
- # not using gcc
- if test "$host_cpu" = ia64; then
- # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
- # chokes on -Wl,-G. The following line is correct:
- shared_flag='-G'
- else
- if test "$aix_use_runtimelinking" = yes; then
- shared_flag='${wl}-G'
- else
- shared_flag='${wl}-bM:SRE'
- fi
- fi
- fi
-
- # It seems that -bexpall does not export symbols beginning with
- # underscore (_), so it is better to generate a list of symbols to export.
- _LT_AC_TAGVAR(always_export_symbols, $1)=yes
- if test "$aix_use_runtimelinking" = yes; then
- # Warning - without using the other runtime loading flags (-brtl),
- # -berok will link without error, but may produce a broken library.
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
- # Determine the default libpath from the value encoded in an
- # empty executable.
- _LT_AC_SYS_LIBPATH_AIX
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
- else
- if test "$host_cpu" = ia64; then
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
- else
- # Determine the default libpath from the value encoded in an
- # empty executable.
- _LT_AC_SYS_LIBPATH_AIX
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
- # Warning - without using the other run time loading flags,
- # -berok will link without error, but may produce a broken library.
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
- # -bexpall does not export symbols beginning with underscore (_)
- _LT_AC_TAGVAR(always_export_symbols, $1)=yes
- # Exported symbols can be pulled into shared objects from archives
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
- # This is similar to how AIX traditionally builds it's shared libraries.
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
- fi
- fi
- ;;
-
- amigaos*)
- if test "$host_cpu" = m68k; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/a2ixlibrary.data~$echo "#define NAME $libname" > $output_objdir/a2ixlibrary.data~$echo "#define LIBRARY_ID 1" >> $output_objdir/a2ixlibrary.data~$echo "#define VERSION $major" >> $output_objdir/a2ixlibrary.data~$echo "#define REVISION $revision" >> $output_objdir/a2ixlibrary.data~$AR $AR_FLAGS $lib $libobjs~$RANLIB $lib~(cd $output_objdir && a2ixlibrary -32)'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- fi
- # see comment about different semantics on the GNU ld section
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
-
- bsdi4*)
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
- ;;
-
- cygwin* | mingw* | pw32*)
- # When not using gcc, we currently assume that we are using
- # Microsoft Visual C++.
- # hardcode_libdir_flag_spec is actually meaningless, as there is
- # no search path for DLLs.
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=' '
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- # Tell ltmain to make .lib files, not .a files.
- libext=lib
- # Tell ltmain to make .dll files, not .so files.
- shrext_cmds=".dll"
- # FIXME: Setting linknames here is a bad hack.
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
- # The linker will automatically build a .lib file if we build a DLL.
- _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)='true'
- # FIXME: Should let the user specify the lib program.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'
- fix_srcfile_path='`cygpath -w "$srcfile"`'
- _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
- ;;
-
- darwin* | rhapsody*)
- case "$host_os" in
- rhapsody* | darwin1.[[012]])
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
- ;;
- *) # Darwin 1.3 on
- if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${Wl}suppress'
- else
- case ${MACOSX_DEPLOYMENT_TARGET} in
- 10.[[012]])
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
- ;;
- 10.*)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
- ;;
- esac
- fi
- ;;
- esac
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
- if test "$GCC" = yes ; then
- output_verbose_link_cmd='echo'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
- _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
- # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- else
- case "$cc_basename" in
- xlc*)
- output_verbose_link_cmd='echo'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
- _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
- # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- ;;
- *)
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- fi
- ;;
- dgux*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- freebsd1*)
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
-
- # FreeBSD 2.2.[012] allows us to include c++rt0.o to get C++ constructor
- # support. Future versions do this automatically, but an explicit c++rt0.o
- # does not break anything, and helps significantly (at the cost of a little
- # extra space).
- freebsd2.2*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags /usr/lib/c++rt0.o'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- # Unfortunately, older versions of FreeBSD 2 do not have this feature.
- freebsd2*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
- freebsd* | kfreebsd*-gnu)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- hpux9*)
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $libobjs $deplibs $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$LD -b +b $install_libdir -o $output_objdir/$soname $libobjs $deplibs $linker_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
-
- # hardcode_minus_L: Not really in the search PATH,
- # but as the default location of the library.
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
- ;;
-
- hpux10* | hpux11*)
- if test "$GCC" = yes -a "$with_gnu_ld" = no; then
- case "$host_cpu" in
- hppa*64*|ia64*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
- ;;
- *)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
- ;;
- esac
- else
- case "$host_cpu" in
- hppa*64*|ia64*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags'
- ;;
- *)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
- ;;
- esac
- fi
- if test "$with_gnu_ld" = no; then
- case "$host_cpu" in
- hppa*64*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
- ia64*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
-
- # hardcode_minus_L: Not really in the search PATH,
- # but as the default location of the library.
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- ;;
- *)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
-
- # hardcode_minus_L: Not really in the search PATH,
- # but as the default location of the library.
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- ;;
- esac
- fi
- ;;
-
- irix5* | irix6* | nonstopux*)
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations ${wl}-exports_file ${wl}$export_symbols -o $lib'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$LD -shared $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -exports_file $export_symbols -o $lib'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='-rpath $libdir'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(inherit_rpath, $1)=yes
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
- ;;
-
- netbsd*)
- if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags' # a.out
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared -o $lib $libobjs $deplibs $linker_flags' # ELF
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- newsos6)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- openbsd*)
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- if test -z "`echo __ELF__ | $CC -E - | $GREP __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
- else
- case $host_os in
- openbsd[[01]].* | openbsd2.[[0-7]] | openbsd2.[[0-7]].*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- ;;
- *)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
- ;;
- esac
- fi
- ;;
-
- os2*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- _LT_AC_TAGVAR(archive_cmds, $1)='$echo "LIBRARY $libname INITINSTANCE" > $output_objdir/$libname.def~$echo "DESCRIPTION \"$libname\"" >> $output_objdir/$libname.def~$echo DATA >> $output_objdir/$libname.def~$echo " SINGLE NONSHARED" >> $output_objdir/$libname.def~$echo EXPORTS >> $output_objdir/$libname.def~emxexp $libobjs >> $output_objdir/$libname.def~$CC -Zdll -Zcrtdll -o $lib $libobjs $deplibs $compiler_flags $output_objdir/$libname.def'
- _LT_AC_TAGVAR(old_archive_from_new_cmds, $1)='emximp -o $output_objdir/$libname.a $output_objdir/$libname.def'
- ;;
-
- osf3*)
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
- else
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- ;;
-
- osf4* | osf5*) # as osf3* with the addition of -msym flag
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $libobjs $deplibs $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- else
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
- $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp'
-
- # Both c and cxx compiler support -rpath directly
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- ;;
-
- sco3.2v5*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
- runpath_var=LD_RUN_PATH
- hardcode_runpath_var=yes
- ;;
-
- solaris*)
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- case $host_os in
- solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
- *) # Supported since Solaris 2.6 (maybe 2.5.1?)
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;
- esac
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
- ;;
-
- sunos4*)
- if test "x$host_vendor" = xsequent; then
- # Use $CC to link under sequent, because it throws in some extra .o
- # files that make .init and .fini sections work.
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h $soname -o $lib $libobjs $deplibs $compiler_flags'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bstatic -o $lib $libobjs $deplibs $linker_flags'
- fi
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- sysv4)
- case $host_vendor in
- sni)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes # is this really true???
- ;;
- siemens)
- ## LD is ld it makes a PLAMLIB
- ## CC just makes a GrossModule.
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(reload_cmds, $1)='$CC -r -o $output$reload_objs'
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- ;;
- motorola)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_direct, $1)=no #Motorola manual says yes, but my tests say they lie
- ;;
- esac
- runpath_var='LD_RUN_PATH'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- sysv4.3*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='-Bexport'
- ;;
-
- sysv4*MP*)
- if test -d /usr/nec; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- runpath_var=LD_RUN_PATH
- hardcode_runpath_var=yes
- _LT_AC_TAGVAR(ld_shlibs, $1)=yes
- fi
- ;;
-
- sysv4.2uw2*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- hardcode_runpath_var=yes
- runpath_var=LD_RUN_PATH
- ;;
-
- sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)
- _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z ${wl}text'
- if test "$GCC" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
- fi
- runpath_var='LD_RUN_PATH'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- sysv5*)
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
- # $CC -shared without GNU ld will not create a library from C++
- # object files and a static libstdc++, better avoid it by now
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- runpath_var='LD_RUN_PATH'
- ;;
-
- uts4*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
-
- *)
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
-
- if test x$host_vendor = xsni; then
- case $host in
- sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
- export_dynamic_flag_spec='${wl}-Blargedynsym'
- ;;
- esac
- fi
- fi
-])
-AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
-test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
-
-_LT_DECL([], [libext], [0], [Old archive suffix (normally "a")])dnl
-_LT_DECL([], [shrext_cmds], [1], [Shared library suffix (normally ".so")])dnl
-_LT_DECL([], [extract_expsyms_cmds], [2],
- [The commands to extract the exported symbol list from a shared archive])
-
-variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
-if test "$GCC" = yes; then
- variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
-fi
-_LT_DECL([], [variables_saved_for_relink], [1],
- [Variables whose values should be saved in libtool wrapper scripts and
- restored at link time])
-
-#
-# Do we need to explicitly link libc?
-#
-case "x$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)" in
-x|xyes)
- # Assume -lc should be added
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
-
- if test "$enable_shared" = yes && test "$GCC" = yes; then
- case $_LT_AC_TAGVAR(archive_cmds, $1) in
- *'~'*)
- # FIXME: we may have to deal with multi-command sequences.
- ;;
- '$CC '*)
- # Test whether the compiler implicitly links with -lc since on some
- # systems, -lgcc has to come before -lc. If gcc already passes -lc
- # to ld, don't add -lc before -lgcc.
- AC_MSG_CHECKING([whether -lc should be explicitly linked in])
- $rm conftest*
- printf "$lt_simple_compile_test_code" > conftest.$ac_ext
-
- if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
- soname=conftest
- lib=conftest
- libobjs=conftest.$ac_objext
- deplibs=
- wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
- compiler_flags=-v
- linker_flags=-v
- verstring=
- output_objdir=.
- libname=conftest
- lt_save_allow_undefined_flag=$_LT_AC_TAGVAR(allow_undefined_flag, $1)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=
- if AC_TRY_EVAL(_LT_AC_TAGVAR(archive_cmds, $1) 2\>\&1 \| $GREP \" -lc \" \>/dev/null 2\>\&1)
- then
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- else
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
- fi
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=$lt_save_allow_undefined_flag
- else
- cat conftest.err 1>&5
- fi
- $rm conftest*
- AC_MSG_RESULT([$_LT_AC_TAGVAR(archive_cmds_need_lc, $1)])
- ;;
- esac
- fi
- ;;
-esac
-
-_LT_TAGDECL([build_libtool_need_lc], [archive_cmds_need_lc], [0],
- [Whether or not to add -lc for building shared libraries])
-_LT_TAGDECL([allow_libtool_libs_with_static_runtimes],
- [enable_shared_with_static_runtimes], [0],
- [Whether or not to disallow shared libs when runtime libs are static])
-_LT_TAGDECL([], [export_dynamic_flag_spec], [1],
- [Compiler flag to allow reflexive dlopens])
-_LT_TAGDECL([], [whole_archive_flag_spec], [1],
- [Compiler flag to generate shared objects directly from archives])
-_LT_TAGDECL([], [old_archive_from_new_cmds], [2],
- [Create an old-style archive from a shared archive])
-_LT_TAGDECL([], [old_archive_from_expsyms_cmds], [2],
- [Create a temporary old-style archive to link instead of a shared archive])
-_LT_TAGDECL([], [archive_cmds], [2], [Commands used to build a shared archive])
-_LT_TAGDECL([], [archive_expsym_cmds], [2])
-_LT_TAGDECL([], [module_cmds], [2],
- [Commands used to build a loadable module if different from building
- a shared archive.])
-_LT_TAGDECL([], [module_expsym_cmds], [2])
-_LT_TAGDECL([], [allow_undefined_flag], [1],
- [Flag that allows shared libraries with undefined symbols to be built])
-_LT_TAGDECL([], [no_undefined_flag], [1],
- [Flag that enforces no undefined symbols])
-_LT_TAGDECL([], [hardcode_libdir_flag_spec], [1],
- [Flag to hardcode $libdir into a binary during linking.
- This must work even if $libdir does not exist])
-_LT_TAGDECL([], [hardcode_libdir_flag_spec_ld], [1],
- [If ld is used when linking, flag to hardcode $libdir into a binary
- during linking. This must work even if $libdir does not exist])
-_LT_TAGDECL([], [hardcode_libdir_separator], [1],
- [Whether we need a single "-rpath" flag with a separated argument])
-_LT_TAGDECL([], [hardcode_direct], [0],
- [Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
- DIR into the resulting binary])
-_LT_TAGDECL([], [hardcode_minus_L], [0],
- [Set to "yes" if using the -LDIR flag during linking hardcodes DIR
- into the resulting binary])
-_LT_TAGDECL([], [hardcode_shlibpath_var], [0],
- [Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
- into the resulting binary])
-_LT_TAGDECL([], [hardcode_automatic], [0],
- [Set to "yes" if building a shared library automatically hardcodes DIR
- into the library and all subsequent libraries and executables linked
- against it])
-_LT_TAGDECL([], [inherit_rpath], [0],
- [Set to yes if linker adds runtime paths of dependent libraries
- to runtime path list])
-_LT_TAGDECL([], [link_all_deplibs], [0],
- [Whether libtool must link a program against all its dependency libraries])
-_LT_TAGDECL([], [fix_srcfile_path], [1],
- [Fix the shell variable $srcfile for the compiler])
-_LT_TAGDECL([], [always_export_symbols], [0],
- [Set to "yes" if exported symbols are required])
-_LT_TAGDECL([], [export_symbols_cmds], [2],
- [The commands to list exported symbols])
-_LT_TAGDECL([], [exclude_expsyms], [1],
- [Symbols that should not be listed in the preloaded symbols])
-_LT_TAGDECL([], [include_expsyms], [1],
- [Symbols that must always be exported])
-dnl FIXME: Not yet implemented
-dnl _LT_TAGDECL([], [thread_safe_flag_spec], [1],
-dnl [Compiler flag to generate thread safe objects])
-])# AC_LIBTOOL_PROG_LD_SHLIBS
-
-
-# _LT_LANG_C_CONFIG([TAG])
-# ------------------------
-# Ensure that the configuration variables for a C compiler are suitably
-# defined. These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to `libtool'.
-m4_define([_LT_LANG_C_CONFIG],
-[AC_REQUIRE([LT_AC_PROG_EGREP])
-lt_save_CC="$CC"
-AC_LANG_PUSH(C)
-
-# Source file extension for C test sources.
-ac_ext=c
-
-# Object file extension for compiled C test sources.
-objext=o
-_LT_AC_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="int some_variable = 0;\n"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='int main(){return(0);}\n'
-
-_LT_AC_SYS_COMPILER
-# Save the default compiler, since it gets overwritten when the other
-# tags are being tested, and _LT_AC_TAGVAR(compiler, []) is a NOP.
-compiler_DEFAULT=$CC
-
-#
-# Check for any special shared library compilation flags.
-#
-_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)=
-if test "$GCC" = no; then
- case $host_os in
- sco3.2v5*)
- _LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf'
- ;;
- esac
-fi
-if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then
- AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries])
- if echo "$old_CC $old_CFLAGS " | $GREP "[[ ]]$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[ ]]" >/dev/null; then :
- else
- AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure])
- _LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no
- fi
-fi
-
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
- AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
- AC_LIBTOOL_PROG_COMPILER_PIC($1)
- AC_LIBTOOL_PROG_CC_C_O($1)
- AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
- AC_LIBTOOL_PROG_LD_SHLIBS($1)
- AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
- AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
- AC_LIBTOOL_SYS_LIB_STRIP
- AC_LIBTOOL_DLOPEN_SELF($1)
-
- # Report which library types will actually be built
- AC_MSG_CHECKING([if libtool supports shared libraries])
- AC_MSG_RESULT([$can_build_shared])
-
- AC_MSG_CHECKING([whether to build shared libraries])
- test "$can_build_shared" = "no" && enable_shared=no
-
- # On AIX, shared libraries and static libraries use the same namespace, and
- # are all built from PIC.
- case "$host_os" in
- aix3*)
- test "$enable_shared" = yes && enable_static=no
- if test -n "$RANLIB"; then
- archive_cmds="$archive_cmds~\$RANLIB \$lib"
- postinstall_cmds='$RANLIB $lib'
- fi
- ;;
-
- aix4* | aix5*)
- if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
- test "$enable_shared" = yes && enable_static=no
- fi
- ;;
- esac
- AC_MSG_RESULT([$enable_shared])
-
- AC_MSG_CHECKING([whether to build static libraries])
- # Make sure either enable_shared or enable_static is yes.
- test "$enable_shared" = yes || enable_static=yes
- AC_MSG_RESULT([$enable_static])
-
- _LT_CONFIG($1)
-fi
-AC_LANG_POP
-CC="$lt_save_CC"
-])# _LT_LANG_C_CONFIG
-
-
-# _LT_LANG_CXX_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for a C++ compiler are suitably
-# defined. These variables are subsequently used by _LT_CONFIG to write
-# the compiler configuration to `libtool'.
-m4_define([_LT_LANG_CXX_CONFIG],
-[AC_LANG_PUSH(C++)
-AC_REQUIRE([LT_AC_PROG_EGREP])
-AC_REQUIRE([AC_PROG_CXX])
-AC_REQUIRE([AC_PROG_CXXCPP])
-
-_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
-_LT_AC_TAGVAR(allow_undefined_flag, $1)=
-_LT_AC_TAGVAR(always_export_symbols, $1)=no
-_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
-_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
-_LT_AC_TAGVAR(hardcode_direct, $1)=no
-_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
-_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
-_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
-_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
-_LT_AC_TAGVAR(hardcode_automatic, $1)=no
-_LT_AC_TAGVAR(inherit_rpath, $1)=no
-_LT_AC_TAGVAR(module_cmds, $1)=
-_LT_AC_TAGVAR(module_expsym_cmds, $1)=
-_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
-_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_AC_TAGVAR(no_undefined_flag, $1)=
-_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
-_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-
-# Source file extension for C++ test sources.
-ac_ext=cc
-
-# Object file extension for compiled C++ test sources.
-objext=o
-_LT_AC_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="int some_variable = 0;\n"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_AC_SYS_COMPILER
-
-# Allow CC to be a program name with arguments.
-lt_save_CC=$CC
-lt_save_LD=$LD
-lt_save_GCC=$GCC
-GCC=$GXX
-lt_save_with_gnu_ld=$with_gnu_ld
-lt_save_path_LD=$lt_cv_path_LD
-if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
- lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
-else
- unset lt_cv_prog_gnu_ld
-fi
-if test -n "${lt_cv_path_LDCXX+set}"; then
- lt_cv_path_LD=$lt_cv_path_LDCXX
-else
- unset lt_cv_path_LD
-fi
-test -z "${LDCXX+set}" || LD=$LDCXX
-CC=${CXX-"c++"}
-compiler=$CC
-_LT_AC_TAGVAR(compiler, $1)=$CC
-cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
-
-if test -n "$compiler"; then
- # We don't want -fno-exception when compiling C++ code, so set the
- # no_builtin_flag separately
- if test "$GXX" = yes; then
- _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=' -fno-builtin'
- else
- _LT_AC_TAGVAR(lt_prog_compiler_no_builtin_flag, $1)=
- fi
-
- if test "$GXX" = yes; then
- # Set up default GNU C++ configuration
-
- AC_PROG_LD
-
- # Check if GNU C++ uses GNU ld as the underlying linker, since the
- # archiving commands below assume that GNU ld is being used.
- if test "$with_gnu_ld" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
-
- # If archive_cmds runs LD, not CC, wlarc should be empty
- # XXX I think wlarc can be eliminated in ltcf-cxx, but I need to
- # investigate it a little bit more. (MM)
- wlarc='${wl}'
-
- # ancient GNU ld didn't support --whole-archive et. al.
- if eval "`$CC -print-prog-name=ld` --help 2>&1" |
- $GREP 'no-whole-archive' > /dev/null; then
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
- else
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
- fi
- else
- with_gnu_ld=no
- wlarc=
-
- # A generic and very simple default shared library creation
- # command for GNU C++ for the case where it uses the native
- # linker, instead of GNU ld. If possible, this setting should
- # overridden to take advantage of the native linker features on
- # the platform it is being used on.
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
- fi
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
-
- else
- GXX=no
- with_gnu_ld=no
- wlarc=
- fi
-
- # PORTME: fill in a description of your system's C++ link characteristics
- AC_MSG_CHECKING([whether the $compiler linker ($LD) supports shared libraries])
- _LT_AC_TAGVAR(ld_shlibs, $1)=yes
- case $host_os in
- aix3*)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- aix4* | aix5*)
- if test "$host_cpu" = ia64; then
- # On IA64, the linker does run time linking by default, so we don't
- # have to do anything special.
- aix_use_runtimelinking=no
- exp_sym_flag='-Bexport'
- no_entry_flag=""
- else
- aix_use_runtimelinking=no
-
- # Test if we are trying to use run time linking or normal
- # AIX style linking. If -brtl is somewhere in LDFLAGS, we
- # need to do runtime linking.
- case $host_os in aix4.[[23]]|aix4.[[23]].*|aix5*)
- for ld_flag in $LDFLAGS; do
- case $ld_flag in
- *-brtl*)
- aix_use_runtimelinking=yes
- break
- ;;
- esac
- done
- esac
-
- exp_sym_flag='-bexport'
- no_entry_flag='-bnoentry'
- fi
-
- # When large executables or shared objects are built, AIX ld can
- # have problems creating the table of contents. If linking a library
- # or program results in "error TOC overflow" add -mminimal-toc to
- # CXXFLAGS/CFLAGS for g++/gcc. In the cases where that is not
- # enough to fix the problem, add -Wl,-bbigtoc to LDFLAGS.
-
- _LT_AC_TAGVAR(archive_cmds, $1)=''
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
-
- if test "$GXX" = yes; then
- case $host_os in aix4.[012]|aix4.[012].*)
- # We only want to do this on AIX 4.2 and lower, the check
- # below for broken collect2 doesn't work under 4.3+
- collect2name=`${CC} -print-prog-name=collect2`
- if test -f "$collect2name" &&
- strings "$collect2name" | $GREP resolve_lib_name >/dev/null
- then
- # We have reworked collect2
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- else
- # We have old collect2
- _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
- # It fails to find uninstalled libraries when the uninstalled
- # path is not listed in the libpath. Setting hardcode_minus_L
- # to unsupported forces relinking
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
- fi
- esac
- shared_flag='-shared'
- else
- # not using gcc
- if test "$host_cpu" = ia64; then
- # VisualAge C++, Version 5.5 for AIX 5L for IA-64, Beta 3 Release
- # chokes on -Wl,-G. The following line is correct:
- shared_flag='-G'
- else
- if test "$aix_use_runtimelinking" = yes; then
- shared_flag='${wl}-G'
- else
- shared_flag='${wl}-bM:SRE'
- fi
- fi
- fi
-
- # It seems that -bexpall does not export symbols beginning with
- # underscore (_), so it is better to generate a list of symbols to export.
- _LT_AC_TAGVAR(always_export_symbols, $1)=yes
- if test "$aix_use_runtimelinking" = yes; then
- # Warning - without using the other runtime loading flags (-brtl),
- # -berok will link without error, but may produce a broken library.
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='-berok'
- # Determine the default libpath from the value encoded in an empty
- # executable.
- _LT_AC_SYS_LIBPATH_AIX
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
-
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
- else
- if test "$host_cpu" = ia64; then
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
- else
- # Determine the default libpath from the value encoded in an
- # empty executable.
- _LT_AC_SYS_LIBPATH_AIX
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
- # Warning - without using the other run time loading flags,
- # -berok will link without error, but may produce a broken library.
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
- # -bexpall does not export symbols beginning with underscore (_)
- _LT_AC_TAGVAR(always_export_symbols, $1)=yes
- # Exported symbols can be pulled into shared objects from archives
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
- # This is similar to how AIX traditionally builds it's shared libraries.
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
- fi
- fi
- ;;
- chorus*)
- case $cc_basename in
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
-
- cygwin* | mingw* | pw32*)
- # _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1) is actually meaningless,
- # as there is no search path for DLLs.
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
- _LT_AC_TAGVAR(always_export_symbols, $1)=no
- _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
-
- if $LD --help 2>&1 | $GREP 'auto-import' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
- # If the export-symbols file already is a .def file (1st line
- # is EXPORTS), use it as is; otherwise, prepend...
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
- cp $export_symbols $output_objdir/$soname.def;
- else
- echo EXPORTS > $output_objdir/$soname.def;
- cat $export_symbols >> $output_objdir/$soname.def;
- fi~
- $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
- else
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- darwin* | rhapsody*)
- case "$host_os" in
- rhapsody* | darwin1.[[012]])
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
- ;;
- *) # Darwin 1.3 on
- if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${Wl}suppress'
- else
- case ${MACOSX_DEPLOYMENT_TARGET} in
- 10.[[012]])
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
- ;;
- 10.*)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
- ;;
- esac
- fi
- ;;
- esac
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
-
- if test "$GXX" = yes ; then
- lt_int_apple_cc_single_mod=no
- output_verbose_link_cmd='echo'
- if $CC -dumpspecs 2>&1 | $GREP 'single_module' >/dev/null ; then
- lt_int_apple_cc_single_mod=yes
- fi
- if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
- fi
- _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
- # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
- if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- else
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- fi
- _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- else
- case "$cc_basename" in
- xlc*)
- output_verbose_link_cmd='echo'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
- _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
- # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[ ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
- ;;
- *)
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- fi
- ;;
-
- dgux*)
- case $cc_basename in
- ec++)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- ghcx)
- # Green Hills C++ Compiler
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
- freebsd[12]*)
- # C++ shared libraries reported to be fairly broken before switch to ELF
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- freebsd-elf*)
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- ;;
- freebsd* | kfreebsd*-gnu)
- # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
- # conventions
- _LT_AC_TAGVAR(ld_shlibs, $1)=yes
- ;;
- gnu*)
- ;;
- hpux9*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
- # but as the default
- # location of the library.
-
- case $cc_basename in
- CC)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- aCC)
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $EGREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
- ;;
- *)
- if test "$GXX" = yes; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -shared -nostdlib -fPIC ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
- else
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- esac
- ;;
- hpux10*|hpux11*)
- if test $with_gnu_ld = no; then
- case "$host_cpu" in
- hppa*64*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- ;;
- ia64*)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
- ;;
- *)
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
- ;;
- esac
- fi
- case "$host_cpu" in
- hppa*64*)
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- ;;
- ia64*)
- _LT_AC_TAGVAR(hardcode_direct, $1)=no
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
- # but as the default
- # location of the library.
- ;;
- *)
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
- # but as the default
- # location of the library.
- ;;
- esac
-
- case $cc_basename in
- CC)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- aCC)
- case "$host_cpu" in
- hppa*64*|ia64*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
- ;;
- *)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
- ;;
- esac
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | $GREP "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
- ;;
- *)
- if test "$GXX" = yes; then
- if test $with_gnu_ld = no; then
- case "$host_cpu" in
- ia64*|hppa*64*)
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
- ;;
- *)
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
- ;;
- esac
- fi
- else
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- esac
- ;;
- irix5* | irix6*)
- case $cc_basename in
- CC)
- # SGI C++
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
-
- # Archives containing C++ object files must be created using
- # "CC -ar", where "CC" is the IRIX C++ compiler. This is
- # necessary to make sure instantiated templates are included
- # in the archive.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -ar -WR,-u -o $oldlib $oldobjs'
- ;;
- *)
- if test "$GXX" = yes; then
- if test "$with_gnu_ld" = no; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
- else
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'
- fi
- fi
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
- ;;
- esac
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
- _LT_AC_TAGVAR(inherit_rpath, $1)=yes
- ;;
- linux*)
- case $cc_basename in
- KCC)
- # Kuck and Associates, Inc. (KAI) C++ Compiler
-
- # KCC will only create a shared library if the output file
- # ends with ".so" (or ".sl" for HP-UX), so rename the library
- # to its proper name (with version) after linking.
- _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib ${wl}-retain-symbols-file,$export_symbols; mv \$templib $lib'
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`$CC $CFLAGS -v conftest.$objext -o libconftest$shared_ext 2>&1 | $GREP "ld"`; rm -f libconftest$shared_ext; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath,$libdir'
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
-
- # Archives containing C++ object files must be created using
- # "CC -Bstatic", where "CC" is the KAI C++ compiler.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
- ;;
- icpc)
- # Intel C++
- with_gnu_ld=yes
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
- _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
- ;;
- cxx)
- # Compaq C++
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
-
- runpath_var=LD_RUN_PATH
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld .*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
- ;;
- esac
- ;;
- lynxos*)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- m88k*)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- mvs*)
- case $cc_basename in
- cxx)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
- netbsd*)
- if echo __ELF__ | $CC -E - | $GREP __ELF__ >/dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
- wlarc=
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_direct, $1)=yes
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- fi
- # Workaround some broken pre-1.5 toolchains
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
- ;;
- osf3*)
- case $cc_basename in
- KCC)
- # Kuck and Associates, Inc. (KAI) C++ Compiler
-
- # KCC will only create a shared library if the output file
- # ends with ".so" (or ".sl" for HP-UX), so rename the library
- # to its proper name (with version) after linking.
- _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Archives containing C++ object files must be created using
- # "CC -Bstatic", where "CC" is the KAI C++ compiler.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
-
- ;;
- RCC)
- # Rational C++ 2.4.1
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- cxx)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
- ;;
- *)
- if test "$GXX" = yes && test "$with_gnu_ld" = no; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
-
- else
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- esac
- ;;
- osf4* | osf5*)
- case $cc_basename in
- KCC)
- # Kuck and Associates, Inc. (KAI) C++ Compiler
-
- # KCC will only create a shared library if the output file
- # ends with ".so" (or ".sl" for HP-UX), so rename the library
- # to its proper name (with version) after linking.
- _LT_AC_TAGVAR(archive_cmds, $1)='tempext=`echo $shared_ext | $SED -e '\''s/\([[^()0-9A-Za-z{}]]\)/\\\\\1/g'\''`; templib=`echo $lib | $SED -e "s/\${tempext}\..*/.so/"`; $CC $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags --soname $soname -o \$templib; mv \$templib $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Archives containing C++ object files must be created using
- # the KAI C++ compiler.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'
- ;;
- RCC)
- # Rational C++ 2.4.1
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- cxx)
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
- echo "-hidden">> $lib.exp~
- $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~
- $rm $lib.exp'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "ld" | $GREP -v "ld:"`; templist=`echo $templist | $SED "s/\(^.*ld.*\)\( .*ld.*$\)/\1/"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
- ;;
- *)
- if test "$GXX" = yes && test "$with_gnu_ld" = no; then
- _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
- _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-L"'
-
- else
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- fi
- ;;
- esac
- ;;
- psos*)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- sco*)
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- case $cc_basename in
- CC)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
- sunos4*)
- case $cc_basename in
- CC)
- # Sun C++ 4.x
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- lcc)
- # Lucid
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
- solaris*)
- case $cc_basename in
- CC)
- # Sun C++ 4.2, 5.x and Centerline C++
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
- _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
- case $host_os in
- solaris2.[0-5] | solaris2.[0-5].*) ;;
- *)
- # The C++ compiler is used as linker so we must use $wl
- # flag to pass the commands to the underlying system
- # linker. We must also pass each convience library through
- # to the system linker between allextract/defaultextract.
- # The C++ compiler will combine linker options so we
- # cannot just pass the convience library names through
- # without $wl.
- # Supported since Solaris 2.6 (maybe 2.5.1?)
- _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
- ;;
- esac
- _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- #
- # There doesn't appear to be a way to prevent this compiler from
- # explicitly linking system object files so we need to strip them
- # from the output so that they don't get included in the library
- # dependencies.
- output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP "\-[[LR]]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
-
- # Archives containing C++ object files must be created using
- # "CC -xar", where "CC" is the Sun C++ compiler. This is
- # necessary to make sure instantiated templates are included
- # in the archive.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
- ;;
- gcx)
- # Green Hills C++ Compiler
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
-
- # The C++ compiler must be used to create the archive.
- _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC $LDFLAGS -archive -o $oldlib $oldobjs'
- ;;
- *)
- # GNU C++ compiler with Solaris linker
- if test "$GXX" = yes && test "$with_gnu_ld" = no; then
- _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-z ${wl}defs'
- if $CC --version | $GREP -v '^2\.7' > /dev/null; then
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $CC -shared -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- output_verbose_link_cmd="$CC -shared $CFLAGS -v conftest.$objext 2>&1 | $GREP \"\-L\""
- else
- # g++ 2.7 appears to require `-G' NOT `-shared' on this
- # platform.
- _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G -nostdlib $LDFLAGS $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
- _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
- $CC -G -nostdlib ${wl}-M $wl$lib.exp -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
-
- # Commands to make compiler produce verbose output that lists
- # what "hidden" libraries, object files and flags are used when
- # linking a shared library.
- output_verbose_link_cmd="$CC -G $CFLAGS -v conftest.$objext 2>&1 | $GREP \"\-L\""
- fi
-
- _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $wl$libdir'
- fi
- ;;
- esac
- ;;
- sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)
- _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
- ;;
- tandem*)
- case $cc_basename in
- NCC)
- # NonStop-UX NCC 3.20
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- ;;
- vxworks*)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- *)
- # FIXME: insert proper C++ library support
- _LT_AC_TAGVAR(ld_shlibs, $1)=no
- ;;
- esac
- AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
- test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
-
- _LT_AC_TAGVAR(GCC, $1)="$GXX"
- _LT_AC_TAGVAR(LD, $1)="$LD"
-
- ## CAVEAT EMPTOR:
- ## There is no encapsulation within the following macros, do not change
- ## the running order or otherwise move them around unless you know exactly
- ## what you are doing...
- AC_LIBTOOL_POSTDEP_PREDEP($1)
- AC_LIBTOOL_PROG_COMPILER_PIC($1)
- AC_LIBTOOL_PROG_CC_C_O($1)
- AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
- AC_LIBTOOL_PROG_LD_SHLIBS($1)
- AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
- AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
- AC_LIBTOOL_SYS_LIB_STRIP
- AC_LIBTOOL_DLOPEN_SELF($1)
-
- _LT_CONFIG($1)
-fi
-
-AC_LANG_POP
-CC=$lt_save_CC
-LDCXX=$LD
-LD=$lt_save_LD
-GCC=$lt_save_GCC
-with_gnu_ldcxx=$with_gnu_ld
-with_gnu_ld=$lt_save_with_gnu_ld
-lt_cv_path_LDCXX=$lt_cv_path_LD
-lt_cv_path_LD=$lt_save_path_LD
-lt_cv_prog_gnu_ldcxx=$lt_cv_prog_gnu_ld
-lt_cv_prog_gnu_ld=$lt_save_with_gnu_ld
-])# _LT_LANG_CXX_CONFIG
-
-
-# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])
-# ------------------------------------
-# Figure out "hidden" library dependencies from verbose
-# compiler output when linking a shared library.
-# Parse the compiler output and extract the necessary
-# objects, libraries and library flags.
-AC_DEFUN([AC_LIBTOOL_POSTDEP_PREDEP],[
-# Dependencies to place before and after the object being linked:
-_LT_AC_TAGVAR(predep_objects, $1)=
-_LT_AC_TAGVAR(postdep_objects, $1)=
-_LT_AC_TAGVAR(predeps, $1)=
-_LT_AC_TAGVAR(postdeps, $1)=
-_LT_AC_TAGVAR(compiler_lib_search_path, $1)=
-
-dnl we can't use the lt_simple_compile_test_code here,
-dnl because it contains code intended for an executable,
-dnl not a library. It's possible we should let each
-dnl tag define a new lt_????_link_test_code variable,
-dnl but it's only used here...
-m4_if([$1], [], [cat > conftest.$ac_ext <<_LT_EOF
-int a;
-void foo (void) { a = 0; }
-_LT_EOF
-], [$1], [CXX], [cat > conftest.$ac_ext <<_LT_EOF
-class Foo
-{
-public:
- Foo (void) { a = 0; }
-private:
- int a;
-};
-_LT_EOF
-], [$1], [F77], [cat > conftest.$ac_ext <<_LT_EOF
- subroutine foo
- implicit none
- integer*4 a
- a=0
- return
- end
-_LT_EOF
-], [$1], [GCJ], [cat > conftest.$ac_ext <<_LT_EOF
-public class foo {
- private int a;
- public void bar (void) {
- a = 0;
- }
-};
-_LT_EOF
-])
-dnl Parse the compiler output and extract the necessary
-dnl objects, libraries and library flags.
-if AC_TRY_EVAL(ac_compile); then
- # Parse the compiler output and extract the necessary
- # objects, libraries and library flags.
-
- # Sentinel used to keep track of whether or not we are before
- # the conftest object file.
- pre_test_object_deps_done=no
-
- # The `*' in the case matches for architectures that use `case' in
- # $output_verbose_cmd can trigger glob expansion during the loop
- # eval without this substitution.
- output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`"
-
- for p in `eval $output_verbose_link_cmd`; do
- case $p in
-
- -L* | -R* | -l*)
- # Some compilers place space between "-{L,R}" and the path.
- # Remove the space.
- if test $p = "-L" ||
- test $p = "-R"; then
- prev=$p
- continue
- else
- prev=
- fi
-
- if test "$pre_test_object_deps_done" = no; then
- case $p in
- -L* | -R*)
- # Internal compiler library paths should come after those
- # provided the user. The postdeps already come after the
- # user supplied libs so there is no need to process them.
- if test -z "$_LT_AC_TAGVAR(compiler_lib_search_path, $1)"; then
- _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${prev}${p}"
- else
- _LT_AC_TAGVAR(compiler_lib_search_path, $1)="${_LT_AC_TAGVAR(compiler_lib_search_path, $1)} ${prev}${p}"
- fi
- ;;
- # The "-l" case would never come before the object being
- # linked, so don't bother handling this case.
- esac
- else
- if test -z "$_LT_AC_TAGVAR(postdeps, $1)"; then
- _LT_AC_TAGVAR(postdeps, $1)="${prev}${p}"
- else
- _LT_AC_TAGVAR(postdeps, $1)="${_LT_AC_TAGVAR(postdeps, $1)} ${prev}${p}"
- fi
- fi
- ;;
-
- *.$objext)
- # This assumes that the test object file only shows up
- # once in the compiler output.
- if test "$p" = "conftest.$objext"; then
- pre_test_object_deps_done=yes
- continue
- fi
-
- if test "$pre_test_object_deps_done" = no; then
- if test -z "$_LT_AC_TAGVAR(predep_objects, $1)"; then
- _LT_AC_TAGVAR(predep_objects, $1)="$p"
- else
- _LT_AC_TAGVAR(predep_objects, $1)="$_LT_AC_TAGVAR(predep_objects, $1) $p"
- fi
- else
- if test -z "$_LT_AC_TAGVAR(postdep_objects, $1)"; then
- _LT_AC_TAGVAR(postdep_objects, $1)="$p"
- else
- _LT_AC_TAGVAR(postdep_objects, $1)="$_LT_AC_TAGVAR(postdep_objects, $1) $p"
- fi
- fi
- ;;
-
- *) ;; # Ignore the rest.
-
- esac
- done
-
- # Clean up.
- rm -f a.out a.exe
-else
- echo "libtool.m4: error: problem compiling $1 test program"
-fi
-
-$rm -f confest.$objext
-
-case " $_LT_AC_TAGVAR(postdeps, $1) " in
-*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;
-esac
-_LT_TAGDECL([], [predep_objects], [1],
- [Dependencies to place before and after the objects being linked to
- create a shared library])
-_LT_TAGDECL([], [postdep_objects], [1])
-_LT_TAGDECL([], [predeps], [1])
-_LT_TAGDECL([], [postdeps], [1])
-_LT_TAGDECL([], [compiler_lib_search_path], [1],
- [The library search path used internally by the compiler when linking
- a shared library])
-])# AC_LIBTOOL_POSTDEP_PREDEP
-
-# _LT_LANG_F77_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for a Fortran 77 compiler are
-# suitably defined. These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
-m4_define([_LT_LANG_F77_CONFIG],
-[AC_REQUIRE([AC_PROG_F77])
-AC_LANG_PUSH(Fortran 77)
-
-_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
-_LT_AC_TAGVAR(allow_undefined_flag, $1)=
-_LT_AC_TAGVAR(always_export_symbols, $1)=no
-_LT_AC_TAGVAR(archive_expsym_cmds, $1)=
-_LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
-_LT_AC_TAGVAR(hardcode_direct, $1)=no
-_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
-_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
-_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
-_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
-_LT_AC_TAGVAR(hardcode_automatic, $1)=no
-_LT_AC_TAGVAR(inherit_rpath, $1)=no
-_LT_AC_TAGVAR(module_cmds, $1)=
-_LT_AC_TAGVAR(module_expsym_cmds, $1)=
-_LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
-_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
-_LT_AC_TAGVAR(no_undefined_flag, $1)=
-_LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
-_LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=no
-
-# Source file extension for f77 test sources.
-ac_ext=f
-
-# Object file extension for compiled f77 test sources.
-objext=o
-_LT_AC_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code=" subroutine t\n return\n end\n"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code=" program t\n end\n"
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_AC_SYS_COMPILER
-
-# Allow CC to be a program name with arguments.
-lt_save_CC="$CC"
-CC=${F77-"f77"}
-compiler=$CC
-_LT_AC_TAGVAR(compiler, $1)=$CC
-cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
-
-if test -n "$compiler"; then
- AC_MSG_CHECKING([if libtool supports shared libraries])
- AC_MSG_RESULT([$can_build_shared])
-
- AC_MSG_CHECKING([whether to build shared libraries])
- test "$can_build_shared" = "no" && enable_shared=no
-
- # On AIX, shared libraries and static libraries use the same namespace, and
- # are all built from PIC.
- case "$host_os" in
- aix3*)
- test "$enable_shared" = yes && enable_static=no
- if test -n "$RANLIB"; then
- archive_cmds="$archive_cmds~\$RANLIB \$lib"
- postinstall_cmds='$RANLIB $lib'
- fi
- ;;
- aix4* | aix5*)
- test "$enable_shared" = yes && enable_static=no
- ;;
- esac
- AC_MSG_RESULT([$enable_shared])
-
- AC_MSG_CHECKING([whether to build static libraries])
- # Make sure either enable_shared or enable_static is yes.
- test "$enable_shared" = yes || enable_static=yes
- AC_MSG_RESULT([$enable_static])
-
- test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
-
- _LT_AC_TAGVAR(GCC, $1)="$G77"
- _LT_AC_TAGVAR(LD, $1)="$LD"
-
- ## CAVEAT EMPTOR:
- ## There is no encapsulation within the following macros, do not change
- ## the running order or otherwise move them around unless you know exactly
- ## what you are doing...
- AC_LIBTOOL_PROG_COMPILER_PIC($1)
- AC_LIBTOOL_PROG_CC_C_O($1)
- AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
- AC_LIBTOOL_PROG_LD_SHLIBS($1)
- AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
- AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
- AC_LIBTOOL_SYS_LIB_STRIP
-
- _LT_CONFIG($1)
-fi
-
-AC_LANG_POP
-CC="$lt_save_CC"
-])# _LT_LANG_F77_CONFIG
-
-
-# _LT_LANG_GCJ_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for the GNU Java Compiler compiler
-# are suitably defined. These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
-m4_define([_LT_LANG_GCJ_CONFIG],
-[AC_REQUIRE([LT_PROG_GCJ])
-AC_LANG_SAVE
-
-# Source file extension for Java test sources.
-ac_ext=java
-
-# Object file extension for compiled Java test sources.
-objext=o
-_LT_AC_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code="class foo {}\n"
-
-# Code to be used in simple link tests
-lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_AC_SYS_COMPILER
-
-# Allow CC to be a program name with arguments.
-lt_save_CC="$CC"
-CC=${GCJ-"gcj"}
-compiler=$CC
-_LT_AC_TAGVAR(compiler, $1)=$CC
-
-# GCJ did not exist at the time GCC didn't implicitly link libc in.
-_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
-
-## CAVEAT EMPTOR:
-## There is no encapsulation within the following macros, do not change
-## the running order or otherwise move them around unless you know exactly
-## what you are doing...
-if test -n "$compiler"; then
- AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
- AC_LIBTOOL_PROG_COMPILER_PIC($1)
- AC_LIBTOOL_PROG_CC_C_O($1)
- AC_LIBTOOL_SYS_HARD_LINK_LOCKS($1)
- AC_LIBTOOL_PROG_LD_SHLIBS($1)
- AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
- AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
- AC_LIBTOOL_SYS_LIB_STRIP
- AC_LIBTOOL_DLOPEN_SELF($1)
-
- _LT_CONFIG($1)
-fi
-
-AC_LANG_RESTORE
-CC="$lt_save_CC"
-])# _LT_LANG_GCJ_CONFIG
-
-
-# _LT_LANG_RC_CONFIG([TAG])
-# --------------------------
-# Ensure that the configuration variables for the Windows resource compiler
-# are suitably defined. These variables are subsequently used by _LT_CONFIG
-# to write the compiler configuration to `libtool'.
-m4_define([_LT_LANG_RC_CONFIG],
-[AC_REQUIRE([LT_PROG_RC])
-AC_LANG_SAVE
-
-# Source file extension for RC test sources.
-ac_ext=rc
-
-# Object file extension for compiled RC test sources.
-objext=o
-_LT_AC_TAGVAR(objext, $1)=$objext
-
-# Code to be used in simple compile tests
-lt_simple_compile_test_code='sample MENU { MENUITEM "&Soup", 100, CHECKED }\n'
-
-# Code to be used in simple link tests
-lt_simple_link_test_code="$lt_simple_compile_test_code"
-
-# ltmain only uses $CC for tagged configurations so make sure $CC is set.
-_LT_AC_SYS_COMPILER
-
-# Allow CC to be a program name with arguments.
-lt_save_CC="$CC"
-CC=${RC-"windres"}
-compiler=$CC
-_LT_AC_TAGVAR(compiler, $1)=$CC
-_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
-
-if test -n "$compiler"; then
- :
- _LT_CONFIG($1)
-fi
-
-AC_LANG_RESTORE
-CC="$lt_save_CC"
-])# _LT_LANG_RC_CONFIG
-
-
-AC_DEFUN([LT_PROG_GCJ],
-[m4_ifdef([AC_PROG_GCJ], [AC_PROG_GCJ],
- [m4_ifdef([A][M_PROG_GCJ], [A][M_PROG_GCJ],
- [AC_CHECK_TOOL(GCJ, gcj,)
- test "x${GCJFLAGS+set}" = xset || GCJFLAGS="-g -O2"
- AC_SUBST(GCJFLAGS)])])dnl
-])
-AU_DEFUN([LT_AC_PROG_GCJ], [LT_PROG_GCJ])
-
-AC_DEFUN([LT_PROG_RC],
-[AC_CHECK_TOOL(RC, windres,)
-])
-AU_DEFUN([LT_AC_PROG_RC], [LT_PROG_RC])
-
-
-# LT_AC_PROG_EGREP
-# ----------------
-# If we don't have a new enough Autoconf to choose the best grep
-# available, choose the one first in the user's PATH.
-AC_DEFUN([LT_AC_PROG_EGREP],
-[AC_REQUIRE([AC_PROG_EGREP])
-test -z "$GREP" && GREP=grep
-_LT_DECL([], [GREP], [1], [A grep program that handles long line])
-_LT_DECL([], [EGREP], [1], [An ERE matcher])
-])
-
-
-# LT_AC_PROG_SED
-# --------------
-# Check for a fully-functional sed program, that truncates
-# as few characters as possible. Prefer GNU sed if found.
-AC_DEFUN([LT_AC_PROG_SED],
-[AC_PROG_SED
-test -z "$SED" && SED=sed
-_LT_DECL([], [SED], [1], [A sed program that does not truncate output])
-_LT_DECL([], [Xsed], ["\$SED -e s/^X//"],
- [Sed that helps us avoid accidentally triggering echo(1) options like -n])
-])# LT_AC_PROG_SED
-
-m4_ifndef([AC_PROG_SED], [
-############################################################
-# NOTE: This macro has been submitted for inclusion into #
-# GNU Autoconf as AC_PROG_SED. When it is available in #
-# a released version of Autoconf we should remove this #
-# macro and use it instead. #
-############################################################
-
-m4_define([AC_PROG_SED],
-[AC_MSG_CHECKING([for a sed that does not truncate output])
-AC_CACHE_VAL(lt_cv_path_SED,
-[# Loop through the user's path and test for sed and gsed.
-# Then use that list of sed's as ones to test for truncation.
-as_save_IFS=$IFS; IFS=$PATH_SEPARATOR
-for as_dir in $PATH
-do
- IFS=$as_save_IFS
- test -z "$as_dir" && as_dir=.
- for lt_ac_prog in sed gsed; do
- for ac_exec_ext in '' $ac_executable_extensions; do
- if $as_executable_p "$as_dir/$lt_ac_prog$ac_exec_ext"; then
- lt_ac_sed_list="$lt_ac_sed_list $as_dir/$lt_ac_prog$ac_exec_ext"
- fi
- done
- done
-done
-lt_ac_max=0
-lt_ac_count=0
-# Add /usr/xpg4/bin/sed as it is typically found on Solaris
-# along with /bin/sed that truncates output.
-for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
- test ! -f $lt_ac_sed && break
- cat /dev/null > conftest.in
- lt_ac_count=0
- echo $ECHO_N "0123456789$ECHO_C" >conftest.in
- # Check for GNU sed and select it if it is found.
- if "$lt_ac_sed" --version 2>&1 < /dev/null | grep 'GNU' > /dev/null; then
- lt_cv_path_SED=$lt_ac_sed
- break
- fi
- while true; do
- cat conftest.in conftest.in >conftest.tmp
- mv conftest.tmp conftest.in
- cp conftest.in conftest.nl
- echo >>conftest.nl
- $lt_ac_sed -e 's/a$//' < conftest.nl >conftest.out || break
- cmp -s conftest.out conftest.nl || break
- # 10000 chars as input seems more than enough
- test $lt_ac_count -gt 10 && break
- lt_ac_count=`expr $lt_ac_count + 1`
- if test $lt_ac_count -gt $lt_ac_max; then
- lt_ac_max=$lt_ac_count
- lt_cv_path_SED=$lt_ac_sed
- fi
- done
-done
-SED=$lt_cv_path_SED
-AC_SUBST([SED])
-])
-AC_MSG_RESULT([$SED])
-])#AC_PROG_SED
-])#m4_ifndef
+++ /dev/null
-# Helper functions for option handling. -*- Autoconf -*-
-# Written by Gary V. Vaughan <gary@gnu.org>
-
-# Copyright (C) 2004 Free Software Foundation, Inc.
-
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2, 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, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
-# 02111-1307, USA.
-
-# serial 1
-
-# This is to help aclocal find these macros, as it can't see m4_define.
-AC_DEFUN([LTOPTIONS_VERSION], [m4_if([1])])
-
-
-# _LT_MANGLE_OPTION(NAME)
-# -----------------------
-m4_define([_LT_MANGLE_OPTION],
-[[_LT_OPTION_]m4_bpatsubst($1, [[^a-zA-Z0-9_]], [_])])
-
-
-# _LT_SET_OPTION(NAME)
-# ------------------------------
-# Set option NAME. Other NAMEs are saved as a flag.
-m4_define([_LT_SET_OPTION], [m4_define(_LT_MANGLE_OPTION([$1]))])
-
-
-# _LT_IF_OPTION(OPTION, IF-SET, [IF-NOT-SET])
-# -------------------------------------------
-# Execute IF-SET if OPTION is set, IF-NOT-SET otherwise.
-m4_define([_LT_IF_OPTION],
-[m4_ifdef(_LT_MANGLE_OPTION([$1]), [$2], [$3])])
-
-
-# _LT_UNLESS_OPTIONS(OPTIONS, IF-NOT-SET)
-# ---------------------------------------
-# Execute IF-NOT-SET if all OPTIONS are not set.
-m4_define([_LT_UNLESS_OPTIONS],
-[AC_FOREACH([_LT_Option], [$1],
- [m4_ifdef(_LT_MANGLE_OPTION(_LT_Option),
- [m4_define([$0_found])])])[]dnl
-m4_ifdef([$0_found], [m4_undefine([$0_found])], [$2
-])[]dnl
-])
-
-
-# _LT_SET_OPTIONS(OPTIONS)
-# ------------------------
-# OPTIONS is a space-separated list of Automake options.
-# If any OPTION has a handler macro declared with LT_OPTION_DEFINE,
-# despatch to that macro; otherwise complain about the unknown option
-# and exit.
-m4_define([_LT_SET_OPTIONS],
-[AC_FOREACH([_LT_Option], [$1],
- [_LT_SET_OPTION(_LT_Option)
- m4_ifdef(_LT_MANGLE_DEFUN(_LT_Option),
- _LT_MANGLE_DEFUN(_LT_Option),
- [m4_fatal([Unknown option `]_LT_Option[' to LT][_INIT_LIBTOOL])])
- ])dnl
-dnl
-dnl Simply set some default values (i.e off) if boolean options were not
-dnl specified:
-_LT_UNLESS_OPTIONS([dlopen], enable_dlopen=no)
-_LT_UNLESS_OPTIONS([win32-dll], enable_win32_dll=no)
-dnl
-dnl If no reference was made to various pairs of opposing options, then
-dnl we run the default mode handler for the pair. For example, if neither
-dnl `shared' nor `disable-shared' was passed, we enable building of shared
-dnl archives by default:
-_LT_UNLESS_OPTIONS([shared disable-shared], [_LT_ENABLE_SHARED])
-_LT_UNLESS_OPTIONS([static disable-static], [_LT_ENABLE_STATIC])
-_LT_UNLESS_OPTIONS([pic-only no-pic], [_LT_WITH_PIC])
-_LT_UNLESS_OPTIONS([fast-install disable-fast-install],
- [_LT_ENABLE_FAST_INSTALL])
-])# _LT_SET_OPTIONS
-
-
-## ----------------------------------------- ##
-## Macros to handle LT_INIT_LIBTOOL options. ##
-## ----------------------------------------- ##
-
-m4_define([_LT_MANGLE_DEFUN],
-[[_LT_OPTION_DEFUN_]m4_bpatsubst(m4_toupper([$1]), [[^A-Z0-9_]], [_])])
-
-
-# LT_OPTION_DEFINE(NAME, CODE)
-# ----------------------------
-m4_define([LT_OPTION_DEFINE],
-[m4_define(_LT_MANGLE_DEFUN([$1]), [$2])[]dnl
-])# LT_OPTION_DEFINE
-
-
-# dlopen
-# ------
-LT_OPTION_DEFINE([dlopen], [enable_dlopen=yes])
-
-AU_DEFUN([AC_LIBTOOL_DLOPEN],
-[_LT_SET_OPTION([dlopen])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `dlopen' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-
-# win32-dll
-# ---------
-# Declare package support for building win32 dll's.
-LT_OPTION_DEFINE([win32-dll],
-[enable_win32_dll=yes
-
-case $host in
-*-*-cygwin* | *-*-mingw* | *-*-pw32*)
- AC_CHECK_TOOL(AS, as, false)
- AC_CHECK_TOOL(DLLTOOL, dlltool, false)
- AC_CHECK_TOOL(OBJDUMP, objdump, false)
- ;;
-esac
-
-test -z "$AS" && AS=as
-_LT_DECL([], [AS], [0], [Assembler program])dnl
-
-test -z "$DLLTOOL" && DLLTOOL=dlltool
-_LT_DECL([], [DLLTOOL], [0], [DLL creation program])dnl
-
-test -z "$OBJDUMP" && OBJDUMP=objdump
-_LT_DECL([], [OBJDUMP], [0], [Object dumper program])dnl
-])# win32-dll
-
-AU_DEFUN([AC_LIBTOOL_WIN32_DLL],
-[_LT_SET_OPTION([win32-dll])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `win32-dll' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-
-# _LT_ENABLE_SHARED([DEFAULT])
-# ----------------------------
-# implement the --enable-shared flag, and supports the `shared' and
-# `disable-shared' LT_INIT_LIBTOOL options.
-# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
-m4_define([_LT_ENABLE_SHARED],
-[m4_define([_LT_ENABLE_SHARED_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([shared],
- [AC_HELP_STRING([--enable-shared@<:@=PKGS@:>@],
- [build shared libraries @<:@default=]_LT_ENABLE_SHARED_DEFAULT[@:>@])],
- [p=${PACKAGE-default}
- case $enableval in
- yes) enable_shared=yes ;;
- no) enable_shared=no ;;
- *)
- enable_shared=no
- # Look at the argument we got. We use all the common list separators.
- lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
- for pkg in $enableval; do
- IFS="$lt_save_ifs"
- if test "X$pkg" = "X$p"; then
- enable_shared=yes
- fi
- done
- IFS="$lt_save_ifs"
- ;;
- esac],
- [enable_shared=]_LT_ENABLE_SHARED_DEFAULT)
-
- _LT_DECL([build_libtool_libs], [enable_shared], [0],
- [Whether or not to build shared libraries])
-])# _LT_ENABLE_SHARED
-
-LT_OPTION_DEFINE([shared], [_LT_ENABLE_SHARED([yes])])
-LT_OPTION_DEFINE([disable-shared], [_LT_ENABLE_SHARED([no])])
-
-# Old names:
-AU_DEFUN([AC_ENABLE_SHARED],
-[_LT_SET_OPTION([shared])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AM_ENABLE_SHARED],
-[_LT_SET_OPTION([shared])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `shared' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AC_DISABLE_SHARED],
-[_LT_SET_OPTION([disable-shared])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AM_DISABLE_SHARED],
-[_LT_SET_OPTION([disable-shared])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-shared' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-
-# _LT_ENABLE_STATIC([DEFAULT])
-# ----------------------------
-# implement the --enable-static flag, and support the `static' and
-# `disable-static' LT_INIT_LIBTOOL options.
-# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
-m4_define([_LT_ENABLE_STATIC],
-[m4_define([_LT_ENABLE_STATIC_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([static],
- [AC_HELP_STRING([--enable-static@<:@=PKGS@:>@],
- [build static libraries @<:@default=]_LT_ENABLE_STATIC_DEFAULT[@:>@])],
- [p=${PACKAGE-default}
- case $enableval in
- yes) enable_static=yes ;;
- no) enable_static=no ;;
- *)
- enable_static=no
- # Look at the argument we got. We use all the common list separators.
- lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
- for pkg in $enableval; do
- IFS="$lt_save_ifs"
- if test "X$pkg" = "X$p"; then
- enable_static=yes
- fi
- done
- IFS="$lt_save_ifs"
- ;;
- esac],
- [enable_static=]_LT_ENABLE_STATIC_DEFAULT)
-
- _LT_DECL([build_old_libs], [enable_static], [0],
- [Whether or not to build static libraries])
-])# _LT_ENABLE_STATIC
-
-LT_OPTION_DEFINE([static], [_LT_ENABLE_STATIC([yes])])
-LT_OPTION_DEFINE([disable-static], [_LT_ENABLE_STATIC([no])])
-
-# Old names:
-AU_DEFUN([AC_ENABLE_STATIC],
-[_LT_SET_OPTION([static])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `static' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AM_ENABLE_STATIC],
-[_LT_SET_OPTION([static])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `static' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AC_DISABLE_STATIC],
-[_LT_SET_OPTION([disable-static])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AM_DISABLE_STATIC],
-[_LT_SET_OPTION([disable-static])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-static' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-
-# _LT_ENABLE_FAST_INSTALL([DEFAULT])
-# ----------------------------------
-# implement the --enable-fast-install flag, and support the `fast-install'
-# and `disable-fast-install' LT_INIT_LIBTOOL options.
-# DEFAULT is either `yes' or `no'. If omitted, it defaults to `yes'.
-m4_define([_LT_ENABLE_FAST_INSTALL],
-[m4_define([_LT_ENABLE_FAST_INSTALL_DEFAULT], [m4_if($1, no, no, yes)])dnl
-AC_ARG_ENABLE([fast-install],
- [AC_HELP_STRING([--enable-fast-install@<:@=PKGS@:>@],
- [optimize for fast installation @<:@default=]_LT_ENABLE_FAST_INSTALL_DEFAULT[@:>@])],
- [p=${PACKAGE-default}
- case $enableval in
- yes) enable_fast_install=yes ;;
- no) enable_fast_install=no ;;
- *)
- enable_fast_install=no
- # Look at the argument we got. We use all the common list separators.
- lt_save_ifs="$IFS"; IFS="${IFS}$PATH_SEPARATOR,"
- for pkg in $enableval; do
- IFS="$lt_save_ifs"
- if test "X$pkg" = "X$p"; then
- enable_fast_install=yes
- fi
- done
- IFS="$lt_save_ifs"
- ;;
- esac],
- [enable_fast_install=]_LT_ENABLE_FAST_INSTALL_DEFAULT)
-
-_LT_DECL([fast_install], [enable_fast_install], [0],
- [Whether or not to optimize for fast installation])dnl
-])# _LT_ENABLE_FAST_INSTALL
-
-LT_OPTION_DEFINE([fast-install], [_LT_ENABLE_FAST_INSTALL([yes])])
-LT_OPTION_DEFINE([disable-fast-install], [_LT_ENABLE_FAST_INSTALL([no])])
-
-# Old names:
-AU_DEFUN([AC_ENABLE_FAST_INSTALL],
-[_LT_SET_OPTION([fast-install])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `fast-install' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-AU_DEFUN([AC_DISABLE_FAST_INSTALL],
-[_LT_SET_OPTION([disable-fast-install])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you put
-the `disable-fast-install' option into LT_LIBTOOL_INIT's first parameter.])
-])
-
-
-# _LT_WITH_PIC([MODE])
-# --------------------
-# implement the --with-pic flag, and support the `pic-only' and `no-pic'
-# LT_INIT_LIBTOOL options.
-# MODE is either `yes' or `no'. If omitted, it defaults to `both'.
-m4_define([_LT_WITH_PIC],
-[AC_ARG_WITH([pic],
- [AC_HELP_STRING([--with-pic],
- [try to use only PIC/non-PIC objects @<:@default=use both@:>@])],
- [pic_mode="$withval"],
- [pic_mode=default])
-
-test -z "$pic_mode" && pic_mode=m4_if($#, 1, $1, default)
-
-_LT_DECL([], [pic_mode], [0], [What type of objects to build])dnl
-])# _LT_WITH_PIC
-
-LT_OPTION_DEFINE([pic-only], [_LT_WITH_PIC([yes])])
-LT_OPTION_DEFINE([no-pic], [_LT_WITH_PIC([no])])
-
-# Old name:
-AU_DEFUN([AC_LIBTOOL_PIC_MODE],
-[_LT_SET_OPTION([pic-only])
-AC_DIAGNOSE([obsolete],
-[$0: Remove this warning and the call to _LT_SET_OPTION when you
-put the `pic-only' option into LT_LIBTOOL_INIT's first parameter.])
-])
+++ /dev/null
-# ltsugar.m4 -- libtool m4 base layer. -*-Autoconf-*-
-#
-# Copyright (C) 2004 Free Software Foundation, Inc.
-# Written by Gary V. Vaughan.
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful, but
-# WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
-#
-# As a special exception to the GNU General Public License, if you
-# distribute this file as part of a program that contains a
-# configuration script generated by Autoconf, you may include it under
-# the same distribution terms that you use for the rest of that program.
-
-# serial 1
-
-# This is to help aclocal find these macros, as it can't see m4_define.
-AC_DEFUN([LTSUGAR_VERSION], [m4_if([0.1])])
-
-
-# lt_join(SEP, ARG1, [ARG2...])
-# -----------------------------
-# Produce ARG1SEPARG2...SEPARGn, omitting [] arguments and their
-# associated separator.
-m4_define([lt_join],
-[m4_case([$#],
- [0], [m4_fatal([$0: too few arguments: $#])],
- [1], [],
- [2], [[$2]],
- [m4_ifval([$2],
- [m4_ifval([$3],
- [[$2][$1][]$0([$1], m4_shiftn(2, $@))],
- [m4_if([$#], [3],
- [$2],
- [$0([$1], [$2], m4_shiftn(3, $@))])])],
- [$0([$1], m4_shiftn(2, $@))])])[]dnl
-])
-
-
-# lt_combine(SEP, PREFIX-LIST, INFIX, SUFFIX1, [SUFFIX2...])
-# ----------------------------------------------------------
-# Produce a SEP delimited list of all paired combinations of elements of
-# PREFIX-LIST with SUFFIX1 through SUFFIXn. Each element of the list
-# has the form PREFIXmINFIXSUFFIXn.
-m4_define([lt_combine],
-[m4_if([$2], [[]], [],
- [lt_join(m4_quote(m4_default([$1], [, ])),
- _$0([$1], m4_car($2)[$3], m4_shiftn(3, $@)),
- $0([$1], m4_cdr($2), m4_shiftn(2, $@)))])])
-m4_define([_lt_combine],
-[m4_if([$3], [], [],
- [lt_join(m4_quote(m4_default([$1], [, ])),
- [$2$3],
- $0([$1], [$2], m4_shiftn(3, $@)))])[]dnl
-])
-
-
-# lt_if_append_uniq(MACRO-NAME, VARNAME, [SEPARATOR], [UNIQ], [NOT-UNIQ])
-# -----------------------------------------------------------------------
-# Iff MACRO-NAME does not yet contain VARNAME, then append it (delimited
-# by SEPARATOR if supplied) and expand UNIQ, else NOT-UNIQ.
-m4_define([lt_if_append_uniq],
-[m4_ifdef([$1],
- [m4_bmatch($3[]m4_defn([$1])$3, $3[]m4_re_escape([$2])$3,
- [$5],
- [m4_append([$1], [$2], [$3])$4])],
- [m4_append([$1], [$2], [$3])$4])])
-
-
-# lt_dict_add(DICT, KEY, VALUE)
-# -----------------------------
-m4_define([lt_dict_add],
-[m4_define([$1($2)], [$4])])
-
-
-# lt_dict_add_subkey(DICT, KEY, SUBKEY, VALUE)
-# --------------------------------------------
-m4_define([lt_dict_add_subkey],
-[m4_define([$1($2:$3)], [$4])])
-
-
-# lt_dict_fetch(DICT, KEY, [SUBKEY])
-# ----------------------------------
-m4_define([lt_dict_fetch],
-[m4_ifval([$3],
- m4_ifdef([$1($2:$3)], [m4_defn([$1($2:$3)])]),
- m4_ifdef([$1($2)], [m4_defn([$1($2)])]))])
-
-
-# lt_if_dict_fetch(DICT, KEY, [SUBKEY], VALUE, IF-TRUE, [IF-FALSE])
-# -----------------------------------------------------------------
-m4_define([lt_if_dict_fetch],
-[m4_if(lt_dict_fetch([$1], [$2], [$3]), [$4],
- [$5],
- [$6])])
-
-
-# lt_dict_filter(DICT, [SUBKEY], VALUE, [SEPARATOR], KEY, [...])
-# ------------------------------------------------------------
-m4_define([lt_dict_filter],
-[m4_if([$5], [], [],
- [lt_join(m4_quote(m4_default([$4], [[, ]])),
- m4_quote(lt_if_dict_fetch([$1], [$5], [$2], [$3], [$5])),
- m4_quote($0([$1], [$2], [$3], [$4], m4_shiftn(5, $@))))])dnl
-])
+++ /dev/null
-# ltversion.m4 -- version numbers -*- Autoconf -*-
-# Generated from ltversion.in; do not edit by hand.
-
-# serial 1467
-# This file is part of GNU Libtool
-
-m4_define([LT_PACKAGE_VERSION], [])
-m4_define([LT_PACKAGE_REVISION], [1.1467])
-
-AC_DEFUN([LTVERSION_VERSION],
-[macro_version=''
-macro_revision='1.1467'
-_LT_DECL(, macro_version, 0, [Which release of libtool.m4 was used?])
-_LT_DECL(, macro_revision, 0)
-])
+++ /dev/null
-Makefile
-Makefile.in
-.deps
-*.os
# Base (./)
base_m4 = template.macros.m4 signal.h.m4 slot.h.m4 method_slot.h.m4 \
- object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4
+ object_slot.h.m4 class_slot.h.m4 hide.h.m4 retype.h.m4 \
+ limit_reference.h.m4
base_built_cc =
base_built_h = signal.h slot.h method_slot.h \
- object_slot.h class_slot.h hide.h retype.h
+ object_slot.h class_slot.h hide.h retype.h limit_reference.h
signal.cc : signal.h signal_base.h functors/slot.h functors/slot_base.h functors/mem_fun.h functors/functor_trait.h
functors/functors.h \
functors/slot_base.h \
adaptors/adaptors.h \
+ adaptors/bound_argument.h \
adaptors/lambda/lambda.h
+# Support for DLL on cygwin/mingw using libtool > 1.4
+if PLATFORM_WIN32
+win32_dlls_ldflags = -no-undefined -Wl,--export-all-symbols
+else
+win32_dlls_ldflags =
+endif
+
# build the library
-#lib_LTLIBRARIES = libsigc-2.0.la
-#libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
+lib_LTLIBRARIES = libsigc-2.0.la
+libsigc_2_0_la_SOURCES = signal.cc signal_base.cc trackable.cc connection.cc \
functors/slot.cc functors/slot_base.cc \
adaptors/lambda/lambda.cc
-#libsigc_2_0_la_LDFLAGS =
-
+libsigc_2_0_la_LDFLAGS = $(win32_dlls_ldflags)
BUILT_SOURCES = $(sigc_built_h) $(sigc_built_cc)
CLEANFILES = build-subdirs-stamp
{ return functor_(); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::adaptor_functor performs a functor
* on the functor stored in the sigc::adaptor_functor object.
void visit_each(const T_action& _A_action,
const adaptor_functor<T_functor>& _A_target)
{
- visit_each(_A_action, _A_target.functor_);
+ //The extra sigc:: prefix avoids ambiguity in some strange
+ //situations.
+ sigc::visit_each(_A_action, _A_target.functor_);
}
#ifndef _SIGC_ADAPTORS_MACROS_BINDHM4_
#define _SIGC_ADAPTORS_MACROS_BINDHM4_
#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
namespace sigc {
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<0, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<0, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 1th argument.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
- (bound_, _A_arg1);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass>
+ (bound_.invoke(), _A_arg1);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass>
- (bound_, _A_arg1);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass>
+ (bound_.invoke(), _A_arg1);
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
- (bound_, _A_arg1, _A_arg2);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
- (bound_, _A_arg1, _A_arg2);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (bound_, _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (bound_.invoke(), _A_arg1, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<0, T_functor, T_bound>::result_type
-bind_functor<0, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 2th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<1, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<1, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 2th argument.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1, bound_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
- (_A_arg1, bound_, _A_arg2);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass>
- (_A_arg1, bound_, _A_arg2);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1, bound_, _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1, bound_.invoke(), _A_arg2, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<1, T_functor, T_bound>::result_type
-bind_functor<1, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 3th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<2, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<2, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 3th argument.
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2, bound_, _A_arg3, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2, bound_.invoke(), _A_arg3, _A_arg4, _A_arg5, _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<2, T_functor, T_bound>::result_type
-bind_functor<2, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 4th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<3, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<3, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 4th argument.
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound_, _A_arg4, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound_.invoke(), _A_arg4, _A_arg5, _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<3, T_functor, T_bound>::result_type
-bind_functor<3, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 5th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<4, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<4, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 5th argument.
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5);
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_, _A_arg5, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound_.invoke(), _A_arg5, _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<4, T_functor, T_bound>::result_type
-bind_functor<4, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 6th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<5, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<5, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 6th argument.
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke(), _A_arg6);
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_bound>::pass, typename type_trait<T_arg6>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_, _A_arg6);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass, typename type_trait<T_arg6>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound_.invoke(), _A_arg6);
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<5, T_functor, T_bound>::result_type
-bind_functor<5, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
-
/** Adaptor that binds an argument to the wrapped functor.
* This template specialization fixes the 7th argument of the wrapped functor.
*
* @ingroup bind
*/
template <class T_functor, class T_bound>
-struct bind_functor<6, T_functor, T_bound> : public adapts<T_functor>
+struct bind_functor<6, T_functor, T_bound, nil,nil,nil,nil,nil,nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>::type type; };
typedef typename adaptor_type::result_type result_type;
/** Invokes the wrapped functor passing on the bound argument only.
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_bound>::type>::pass> (bound_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* bound_ is passed as the 7th argument.
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_bound>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_bound>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_bound bound_;
+ bound_argument<T_bound> bound_;
};
-template <class T_functor, class T_bound>
-typename bind_functor<6, T_functor, T_bound>::result_type
-bind_functor<6, T_functor, T_bound>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_bound>::pass> (bound_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1>
-struct bind_functor<-1, T_functor, T_type1> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, nil, nil, nil, nil, nil, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<2, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass> (bound1_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 1 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1, bound1_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5,T_arg6 _A_arg6)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<T_type1>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5,_A_arg6, bound1_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
+ bound_argument<T_type1> bound1_;
};
-template <class T_functor, class T_type1>
-typename bind_functor<-1, T_functor, T_type1>::result_type
-bind_functor<-1, T_functor, T_type1>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass> (bound1_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2>
-struct bind_functor<-1, T_functor, T_type1,T_type2> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, nil, nil, nil, nil, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<3, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass> (bound1_.invoke(),bound2_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 2 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke(),bound2_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4,T_arg5 _A_arg5)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_,bound2_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4,_A_arg5, bound1_.invoke(),bound2_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
};
-template <class T_functor, class T_type1,class T_type2>
-typename bind_functor<-1, T_functor, T_type1,T_type2>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass> (bound1_,bound2_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2,class T_type3>
-struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, nil, nil, nil, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<4, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 3 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3,T_arg4 _A_arg4)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass>
- (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_,bound2_,bound3_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3,_A_arg4, bound1_.invoke(),bound2_.invoke(),bound3_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
- T_type3 bound3_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
};
-template <class T_functor, class T_type1,class T_type2,class T_type3>
-typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2,T_type3>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass> (bound1_,bound2_,bound3_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
-struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, nil, nil, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<5, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 4 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2,T_arg3 _A_arg3)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass>
- (_A_arg1,_A_arg2,_A_arg3, bound1_,bound2_,bound3_,bound4_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass>
+ (_A_arg1,_A_arg2,_A_arg3, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
- T_type3 bound3_;
- T_type4 bound4_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
};
-template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4>
-typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass> (bound1_,bound2_,bound3_,bound4_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
-struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, nil, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>::type type; };
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal<6, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 5 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
}
#endif
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_arg1,T_arg2 _A_arg2)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass>
- (_A_arg1,_A_arg2, bound1_,bound2_,bound3_,bound4_,bound5_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass>
+ (_A_arg1,_A_arg2, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
- T_type3 bound3_;
- T_type4 bound4_;
- T_type5 bound5_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
};
-template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5>
-typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
-struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, nil> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
+ }
/** Invokes the wrapped functor passing on the arguments.
* The last 6 argument(s) are fixed.
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_arg1)
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass>
- (_A_arg1, bound1_,bound2_,bound3_,bound4_,bound5_,bound6_);
+ { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass>
+ (_A_arg1, bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke());
}
#endif
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
- T_type3 bound3_;
- T_type4 bound4_;
- T_type5 bound5_;
- T_type6 bound6_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
+ bound_argument<T_type6> bound6_;
};
-template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6>
-typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
-struct bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7> : public adapts<T_functor>
+struct bind_functor<-1, T_functor, T_type1, T_type2, T_type3, T_type4, T_type5, T_type6, T_type7> : public adapts<T_functor>
{
typedef typename adapts<T_functor>::adaptor_type adaptor_type;
#ifndef DOXYGEN_SHOULD_SKIP_THIS
template <int count, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
struct deduce_result_type_internal
- { typedef typename adaptor_type::template deduce_result_type<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass>::type type; };
+ { typedef typename adaptor_type::template deduce_result_type<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass,typename type_trait<typename unwrap_reference<T_type7>::type>::pass>::type type; };
#endif /*DOXYGEN_SHOULD_SKIP_THIS*/
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
* @return The return value of the functor invocation.
*/
result_type
- operator()();
+ operator()()
+ {
+ //Note: The AIX compiler sometimes gives linker errors if we do not define this in the class.
+ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<typename unwrap_reference<T_type1>::type>::pass,typename type_trait<typename unwrap_reference<T_type2>::type>::pass,typename type_trait<typename unwrap_reference<T_type3>::type>::pass,typename type_trait<typename unwrap_reference<T_type4>::type>::pass,typename type_trait<typename unwrap_reference<T_type5>::type>::pass,typename type_trait<typename unwrap_reference<T_type6>::type>::pass,typename type_trait<typename unwrap_reference<T_type7>::type>::pass> (bound1_.invoke(),bound2_.invoke(),bound3_.invoke(),bound4_.invoke(),bound5_.invoke(),bound6_.invoke(),bound7_.invoke());
+ }
/** Constructs a bind_functor object that binds an argument to the passed functor.
* @param _A_functor Functor to invoke from operator()().
{}
/// The argument bound to the functor.
- T_type1 bound1_;
- T_type2 bound2_;
- T_type3 bound3_;
- T_type4 bound4_;
- T_type5 bound5_;
- T_type6 bound6_;
- T_type7 bound7_;
+ bound_argument<T_type1> bound1_;
+ bound_argument<T_type2> bound2_;
+ bound_argument<T_type3> bound3_;
+ bound_argument<T_type4> bound4_;
+ bound_argument<T_type5> bound5_;
+ bound_argument<T_type6> bound6_;
+ bound_argument<T_type7> bound7_;
};
-template <class T_functor, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
-typename bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::result_type
-bind_functor<-1, T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
- { return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::pass,typename type_trait<T_type2>::pass,typename type_trait<T_type3>::pass,typename type_trait<T_type4>::pass,typename type_trait<T_type5>::pass,typename type_trait<T_type6>::pass,typename type_trait<T_type7>::pass> (bound1_,bound2_,bound3_,bound4_,bound5_,bound6_,bound7_); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_functor performs a functor on the
* functor and on the object instances stored in the sigc::bind_functor object.
* @ingroup bind
*/
template <int I_location, class T_bound1, class T_functor>
-inline bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
+inline bind_functor<I_location, T_functor, T_bound1>
bind(const T_functor& _A_func, T_bound1 _A_b1)
{
- return bind_functor<I_location, T_functor, typename unwrap_reference<T_bound1>::type>
+ return bind_functor<I_location, T_functor, T_bound1>
(_A_func, _A_b1);
}
*/
template <class T_type1, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type>
+ T_type1>
bind(const T_functor& _A_func, T_type1 _A_b1)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type>
+ T_type1>
(_A_func, _A_b1);
}
*/
template <class T_type1,class T_type2, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type>
+ T_type1,
+ T_type2>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type>
+ T_type1,
+ T_type2>
(_A_func, _A_b1,_A_b2);
}
*/
template <class T_type1,class T_type2,class T_type3, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type>
+ T_type1,
+ T_type2,
+ T_type3>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type>
+ T_type1,
+ T_type2,
+ T_type3>
(_A_func, _A_b1,_A_b2,_A_b3);
}
*/
template <class T_type1,class T_type2,class T_type3,class T_type4, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4>
(_A_func, _A_b1,_A_b2,_A_b3,_A_b4);
}
*/
template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5>
(_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5);
}
*/
template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type,
- typename unwrap_reference<T_type6>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type,
- typename unwrap_reference<T_type6>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6>
(_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6);
}
*/
template <class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7, class T_functor>
inline bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type,
- typename unwrap_reference<T_type6>::type,
- typename unwrap_reference<T_type7>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6,
+ T_type7>
bind(const T_functor& _A_func, T_type1 _A_b1,T_type2 _A_b2,T_type3 _A_b3,T_type4 _A_b4,T_type5 _A_b5,T_type6 _A_b6,T_type7 _A_b7)
{ return bind_functor<-1, T_functor,
- typename unwrap_reference<T_type1>::type,
- typename unwrap_reference<T_type2>::type,
- typename unwrap_reference<T_type3>::type,
- typename unwrap_reference<T_type4>::type,
- typename unwrap_reference<T_type5>::type,
- typename unwrap_reference<T_type6>::type,
- typename unwrap_reference<T_type7>::type>
+ T_type1,
+ T_type2,
+ T_type3,
+ T_type4,
+ T_type5,
+ T_type6,
+ T_type7>
(_A_func, _A_b1,_A_b2,_A_b3,_A_b4,_A_b5,_A_b6,_A_b7);
}
#ifndef _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#define _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_
#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/adaptors/bound_argument.h>
namespace sigc {
{
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
- { typedef T_return type; };
- typedef T_return result_type;
+ { typedef typename unwrap_reference<T_return>::type type; };
+ typedef typename unwrap_reference<T_return>::type result_type;
/** Invokes the wrapped functor dropping its return value.
* @return The fixed return value.
*/
- T_return operator()();
+ typename unwrap_reference<T_return>::type operator()();
/** Invokes the wrapped functor passing on the arguments.,
* @param _A_arg%1 Argument to be passed on to the functor.)
* @return The fixed return value.
*/
template <class T_arg1>
- inline T_return operator()(T_arg1 _A_a1)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
- (_A_a1); return ret_value_;
+ (_A_a1); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
- inline T_return sun_forte_workaround(T_arg1 _A_a1)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
- (_A_a1); return ret_value_;
+ (_A_a1); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
- (_A_a1,_A_a2); return ret_value_;
+ (_A_a1,_A_a2); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass>
- (_A_a1,_A_a2); return ret_value_;
+ (_A_a1,_A_a2); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2,class T_arg3>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
- (_A_a1,_A_a2,_A_a3); return ret_value_;
+ (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass>
- (_A_a1,_A_a2,_A_a3); return ret_value_;
+ (_A_a1,_A_a2,_A_a3); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); return ret_value_.invoke();
}
#endif
* @return The fixed return value.
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ inline typename unwrap_reference<T_return>::type operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ inline typename unwrap_reference<T_return>::type sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass,typename type_trait<T_arg2>::pass,typename type_trait<T_arg3>::pass,typename type_trait<T_arg4>::pass,typename type_trait<T_arg5>::pass,typename type_trait<T_arg6>::pass,typename type_trait<T_arg7>::pass>
- (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_;
+ (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); return ret_value_.invoke();
}
#endif
{}
/// The fixed return value.
- T_return ret_value_; // public, so that visit_each() can access it
+ bound_argument<T_return> ret_value_; // public, so that visit_each() can access it
};
template <class T_return, class T_functor>
-T_return bind_return_functor<T_return, T_functor>::operator()()
- { this->functor_(); return ret_value_; }
+typename unwrap_reference<T_return>::type bind_return_functor<T_return, T_functor>::operator()()
+ { this->functor_(); return ret_value_.invoke(); }
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bind_return_functor performs a functor on the
* functor and on the object instance stored in the sigc::bind_return_functor object.
* @ingroup bind
*/
template <class T_return, class T_functor>
-inline bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>
+inline bind_return_functor<T_return, T_functor>
bind_return(const T_functor& _A_functor, T_return _A_ret_value)
-{ return bind_return_functor<typename unwrap_reference<T_return>::type, T_functor>(_A_functor, _A_ret_value); }
+{ return bind_return_functor<T_return, T_functor>(_A_functor, _A_ret_value); }
} /* namespace sigc */
#endif /* _SIGC_ADAPTORS_MACROS_BIND_RETURNHM4_ */
--- /dev/null
+/*
+ * Copyright 2005, The libsigc++ Development Team
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+#ifndef _SIGC_BOUND_ARGUMENT_H_
+#define _SIGC_BOUND_ARGUMENT_H_
+
+
+#include <sigc++/limit_reference.h>
+#include <sigc++/reference_wrapper.h>
+
+
+namespace sigc {
+
+/** A bound_argument<Foo> object stores a bound (for instance, with sigc::bind(), or sigc::bind_return()) argument.
+ *
+ * If Foo is a wrapped reference to a class Bar (reference_wrapper<Bar>) then this
+ * object is implemented on top of a limit_reference. When the slot is
+ * invoked, the limit_reference::invoke() method provides the argument (a Bar&).
+ * When the slot is visited (e.g. visit_each<>()), we simply visit the limit_reference,
+ * which will visit the derived type, or a sigc::trackable base if necessary.
+ *
+ * Likewise, If Foo is a wrapped const reference to a class Bar (const_reference_wrapper<Bar>)
+ * then this object is implemented on top of a const_limit_reference.
+ *
+ * If Foo is something else (such as an argument that is bound by value) bound_argument just
+ * stores a cop of that value, and both invoke() and visit() simply return it.
+ *
+ * This object is used by the bind_functor<> and bind_return_functor<> objects,
+ * depending on whether the argument is bound as a parameter or as a return value.
+ *
+ * The general template implementation is used for parameters that are passed by value.
+ * @e T_type The type of the bound argument.
+ */
+template <class T_type>
+class bound_argument
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const T_type& _A_argument)
+ : visited_(_A_argument)
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The bound argument.
+ */
+ inline const T_type& visit() const
+ { return visited_; }
+
+ /** Retrieve the entity to pass to the bound functor or return.
+ * @return The bound argument.
+ */
+ inline T_type& invoke()
+ { return visited_; }
+
+private:
+ /** The value of the argument.
+ */
+ T_type visited_;
+};
+
+//Template specialization:
+/** bound_argument object for a bound argument that is passed by bind() or
+ * returned by bind_return() by reference, specialized for reference_wrapper<> types.
+ * @e T_wrapped The type of the bound argument.
+ */
+template <class T_wrapped>
+class bound_argument< reference_wrapper<T_wrapped> >
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const reference_wrapper<T_wrapped>& _A_argument)
+ : visited_(unwrap(_A_argument))
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The limited_reference to the bound argument.
+ */
+ inline const limit_reference<T_wrapped>& visit() const
+ { return visited_; }
+
+ /** Retrieve the entity to pass to the bound functor or return.
+ * @return The bound argument.
+ */
+ inline T_wrapped& invoke()
+ { return visited_.invoke(); }
+
+private:
+ /** The limited_reference to the bound argument.
+ */
+ limit_reference<T_wrapped> visited_;
+};
+
+/** bound_argument object for a bound argument that is passed by bind() or
+ * returned by bind_return() by const reference, specialized for const reference_wrapper<> types.
+ * - @e T_wrapped The type of the bound argument.
+ */
+template <class T_wrapped>
+class bound_argument< const_reference_wrapper<T_wrapped> >
+{
+public:
+ /** Constructor.
+ * @param _A_argument The argument to bind.
+ */
+ bound_argument(const const_reference_wrapper<T_wrapped>& _A_argument)
+ : visited_(unwrap(_A_argument))
+ {}
+
+ /** Retrieve the entity to visit in visit_each().
+ * @return The const_limited_reference to the bound argument.
+ */
+ inline const const_limit_reference<T_wrapped>& visit() const
+ { return visited_; }
+
+ /** Retrieve the entity to pass to the bound functor or return.
+ * @return The bound argument.
+ */
+ inline const T_wrapped& invoke()
+ { return visited_.invoke(); }
+
+private:
+ /** The const_limited_reference to the bound argument.
+ */
+ const_limit_reference<T_wrapped> visited_;
+};
+
+/** Implementation of visit_each() specialized for the bound_argument class.
+ * Call visit_each() on the entity returned by the bound_argument's visit()
+ * method.
+ * @e T_action The type of functor to invoke.
+ * @e T_type The type of bound_argument.
+ * @param _A_action The functor to invoke.
+ * @param _A_argument The visited instance.
+ */
+template <class T_action, class T_type>
+void
+visit_each(const T_action& _A_action,
+ const bound_argument<T_type>& _A_argument)
+{
+ visit_each(_A_action, _A_argument.visit());
+}
+
+
+} /* namespace sigc */
+
+
+#endif /* _SIGC_BOUND_ARGUMENT_H_ */
struct compose1_functor : public adapts<T_setter>
{
typedef typename adapts<T_setter>::adaptor_type adaptor_type;
+ typedef T_setter setter_type;
+ typedef T_getter getter_type;
- template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
+ template <class T_arg1 = void,class T_arg2 = void,class T_arg3 = void,class T_arg4 = void,class T_arg5 = void,class T_arg6 = void,class T_arg7 = void>
struct deduce_result_type
{ typedef typename adaptor_type::template deduce_result_type<
typename sigc::deduce_result_type<T_getter, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
: adapts<T_setter>(_A_setter), get_(_A_getter)
{}
- T_getter get_; // public, so that visit_each() can access it
+ getter_type get_; // public, so that visit_each() can access it
};
template <class T_setter, class T_getter>
struct compose2_functor : public adapts<T_setter>
{
typedef typename adapts<T_setter>::adaptor_type adaptor_type;
-
+ typedef T_setter setter_type;
+ typedef T_getter1 getter1_type;
+ typedef T_getter2 getter2_type;
+
template <class T_arg1=void,class T_arg2=void,class T_arg3=void,class T_arg4=void,class T_arg5=void,class T_arg6=void,class T_arg7=void>
struct deduce_result_type
{ typedef typename adaptor_type::template deduce_result_type<
: adapts<T_setter>(_A_setter), get1_(_A_getter1), get2_(_A_getter2)
{}
- T_getter1 get1_; // public, so that visit_each() can access it
- T_getter2 get2_; // public, so that visit_each() can access it
+ getter1_type get1_; // public, so that visit_each() can access it
+ getter2_type get2_; // public, so that visit_each() can access it
};
template <class T_setter, class T_getter1, class T_getter2>
compose2_functor<T_setter, T_getter1, T_getter2>::operator()()
{ return this->functor_(get1_(), get2_()); }
-
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::compose1_functor performs a functor on the
* functors stored in the sigc::compose1_functor object.
void visit_each(const T_action& _A_action,
const compose1_functor<T_setter, T_getter>& _A_target)
{
- visit_each(_A_action, _A_target.functor_);
- visit_each(_A_action, _A_target.get_);
+ typedef compose1_functor<T_setter, T_getter> type_functor;
+
+ //Note that the AIX compiler needs the actual template types of visit_each to be specified:
+ typedef typename type_functor::setter_type type_functor1;
+ visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
+
+ typedef typename type_functor::getter_type type_functor_getter;
+ visit_each<T_action, type_functor_getter>(_A_action, _A_target.get_);
}
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::compose2_functor performs a functor on the
* functors stored in the sigc::compose2_functor object.
void visit_each(const T_action& _A_action,
const compose2_functor<T_setter, T_getter1, T_getter2>& _A_target)
{
- visit_each(_A_action, _A_target.functor_);
- visit_each(_A_action, _A_target.get1_);
- visit_each(_A_action, _A_target.get2_);
+ typedef compose2_functor<T_setter, T_getter1, T_getter2> type_functor;
+
+ //Note that the AIX compiler needs the actual template types of visit_each to be specified:
+ typedef typename type_functor::setter_type type_functor1;
+ visit_each<T_action, type_functor1>(_A_action, _A_target.functor_);
+
+ typedef typename type_functor::getter1_type type_functor_getter1;
+ visit_each<T_action, type_functor_getter1>(_A_action, _A_target.get1_);
+
+ typedef typename type_functor::getter2_type type_functor_getter2;
+ visit_each<T_action, type_functor_getter2>(_A_action, _A_target.get2_);
}
: adapts<T_functor>(_A_func), catcher_(_A_catcher)
{}
- protected:
- T_catcher catcher_;
+ T_catcher catcher_;
};
template <class T_functor, class T_catcher, class T_return>
{}
~exception_catch_functor() {}
- protected:
T_catcher catcher_;
};
{ this->catcher_(); }
}
-
+
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, class T_catcher, class T_return>
void visit_each(const T_action& _A_action,
const exception_catch_functor<T_functor, T_catcher, T_return>& _A_target)
*/
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
- operator()(T_arg1 _A_a1)
+ operator()(T_arg1)
{ return this->functor_(); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
*/
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+ operator()(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ operator()(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a2, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3, T_arg4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a2, _A_a3); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif
*/
template <class T_arg1>
typename deduce_result_type<T_arg1>::type
- operator()(T_arg1 _A_a1)
+ operator()(T_arg1)
{ return this->functor_(); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
*/
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+ operator()(T_arg1, T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
(_A_a2); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass>
(_A_a2); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a2, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a2, _A_a3); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a2, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a2, _A_a3, _A_a4); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a2, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2)
+ operator()(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
typename deduce_result_type<T_arg1,T_arg2>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass>
(_A_a1); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a3); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a3, _A_a4); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a3, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass>
(_A_a1, _A_a2); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a4); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a4, _A_a5, _A_a6, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a2, _A_a3); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass>
(_A_a1, _A_a2, _A_a3); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a5, _A_a6, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5, T_arg6 _A_a6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg6>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a6, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6, T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg7>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a7); }
#endif
*/
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ operator()(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
- sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
+ sun_forte_workaround(T_arg1 _A_a1, T_arg2 _A_a2, T_arg3 _A_a3, T_arg4 _A_a4, T_arg5 _A_a5, T_arg6 _A_a6, T_arg7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_arg1>::pass, typename type_trait<T_arg2>::pass, typename type_trait<T_arg3>::pass, typename type_trait<T_arg4>::pass, typename type_trait<T_arg5>::pass, typename type_trait<T_arg6>::pass>
(_A_a1, _A_a2, _A_a3, _A_a4, _A_a5, _A_a6); }
#endif
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::hide_functor performs a functor on the
* functor stored in the sigc::hide_functor object.
#ifndef _SIGC_LAMBDA_BASE_HPP_
#define _SIGC_LAMBDA_BASE_HPP_
#include <sigc++/adaptors/adaptor_trait.h>
+#include <sigc++/reference_wrapper.h>
namespace sigc {
result_type operator()() const;
template <class T_arg1>
- result_type operator ()(T_arg1 _A_1) const
+ result_type operator ()(T_arg1) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
- result_type sun_forte_workaround(T_arg1 _A_1) const
+ result_type sun_forte_workaround(T_arg1) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2) const
+ result_type operator ()(T_arg1,T_arg2) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const
+ result_type sun_forte_workaround(T_arg1,T_arg2) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+ result_type operator ()(T_arg1,T_arg2,T_arg3) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const
+ result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+ result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const
+ result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+ result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const
+ result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+ result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const
+ result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- result_type operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+ result_type operator ()(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const
{ return value_; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- result_type sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const
+ result_type sun_forte_workaround(T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7) const
{ return value_; }
#endif //SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
} /* namespace internal */
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, bool I_islambda>
void visit_each(const T_action& _A_action,
const internal::lambda_core<T_functor, I_islambda>& _A_target)
};
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_type>
void visit_each(const T_action& _A_action,
const lambda<T_type>& _A_target)
}
-/// Converts a reference into a lambda object.
+/** Converts a reference into a lambda object.
+ * sigc::var creates a 0-ary functor, returning the value of a referenced variable.
+ *
+ * @par Example:
+ * @code
+ * int main(int argc, char* argv)
+ * {
+ * int data;
+ * sigc::signal<int> readValue;
+ *
+ * readValue.connect(sigc::var(data));
+ *
+ * data = 3;
+ * std::cout << readValue() << std::endl; //Prints 3.
+ *
+ * data = 5;
+ * std::cout << readValue() << std::endl; //Prints 5.
+ * }
+ * @endcode
+ */
template <class T_type>
lambda<T_type&> var(T_type& v)
{ return lambda<T_type&>(v); }
-/// Converts a constant reference into a lambda object.
+/** Converts a constant reference into a lambda object.
+ */
template <class T_type>
lambda<const T_type&> var(const T_type& v)
{ return lambda<const T_type&>(v); }
{ return func_(value1_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, class T_type1>
void visit_each(const T_action& _A_action,
const lambda_group1<T_functor, T_type1>& _A_target)
{ return func_(value1_(),value2_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, class T_type1,class T_type2>
void visit_each(const T_action& _A_action,
const lambda_group2<T_functor, T_type1,T_type2>& _A_target)
{ return func_(value1_(),value2_(),value3_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, class T_type1,class T_type2,class T_type3>
void visit_each(const T_action& _A_action,
const lambda_group3<T_functor, T_type1,T_type2,T_type3>& _A_target)
typename arg2_type::result_type>
(arg1_(), arg2_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_arg1, class T_arg2>
void visit_each(const T_action& _A_action,
const lambda_operator<T_lambda_action, T_arg1, T_arg2>& _A_target)
typename arg_type::result_type>
(arg_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_arg>
void visit_each(const T_action& _A_action,
const lambda_operator_unary<T_lambda_action, T_arg>& _A_target)
typename arg_type::result_type>
(arg_()); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_lambda_action, class T_type, class T_arg>
void visit_each(const T_action& _A_action,
const lambda_operator_convert<T_lambda_action, T_type, T_arg>& _A_target)
#endif
template <class T_arg1,class T_arg2>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_1; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg1 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
+ T_arg1 operator ()(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg1 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_1; }
+ T_arg1 sun_forte_workaround(T_arg1 _A_1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_1; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return operator()( _A_1,_A_2 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6) const { return _A_2; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg2 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
+ T_arg2 operator ()(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg2 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_2; }
+ T_arg2 sun_forte_workaround(T_arg1, T_arg2 _A_2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_2; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2,class T_arg3>
- T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return operator()( _A_1,_A_2,_A_3 ); }
- T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3) const { return _A_3; }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
- T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_3; }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
- T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_3; }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_3; }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6) const { return _A_3; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg3 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
+ T_arg3 operator ()(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg3 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_3; }
+ T_arg3 sun_forte_workaround(T_arg1, T_arg2, T_arg3 _A_3, T_arg4, T_arg5, T_arg6, T_arg7) const { return _A_3; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
- T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return operator()( _A_1,_A_2,_A_3,_A_4 ); }
- T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4) const { return _A_4; }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
- T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_4; }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_4; }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6) const { return _A_4; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg4 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
+ T_arg4 operator ()(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg4 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_4; }
+ T_arg4 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4 _A_4, T_arg5, T_arg6, T_arg7) const { return _A_4; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
- T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5 ); }
- T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5) const { return _A_5; }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5) const { return _A_5; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_5; }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6) const { return _A_5; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg5 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
+ T_arg5 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg5 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_5; }
+ T_arg5 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5 _A_5, T_arg6, T_arg7) const { return _A_5; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
- T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
+ T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
//Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6 ); }
- T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6) const { return _A_6; }
+ T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6) const { return _A_6; }
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg6 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
+ T_arg6 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg6 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_6; }
+ T_arg6 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6 _A_6, T_arg7) const { return _A_6; }
#endif
};
void operator ()() const; // not implemented
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
- T_arg7 operator ()(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
+ T_arg7 operator ()(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
//Does not work: T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return operator()( _A_1,_A_2,_A_3,_A_4,_A_5,_A_6,_A_7 ); }
- T_arg7 sun_forte_workaround(T_arg1 _A_1,T_arg2 _A_2,T_arg3 _A_3,T_arg4 _A_4,T_arg5 _A_5,T_arg6 _A_6,T_arg7 _A_7) const { return _A_7; }
+ T_arg7 sun_forte_workaround(T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, T_arg7 _A_7) const { return _A_7; }
#endif
};
typename deduce_result_type<T_arg1>::type
operator()(T_arg1 _A_a1)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
- ((T_type1)_A_a1);
+ (static_cast<T_type1>(_A_a1));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1>::type
sun_forte_workaround(T_arg1 _A_a1)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take>
- ((T_type1)_A_a1);
+ (static_cast<T_type1>(_A_a1));
}
#endif
typename deduce_result_type<T_arg1,T_arg2>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2));
}
#endif
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2,T_arg3>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3));
}
#endif
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4));
}
#endif
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5));
}
#endif
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6));
}
#endif
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
typename deduce_result_type<T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::type
sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ return this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename type_trait<T_type1>::take,typename type_trait<T_type2>::take,typename type_trait<T_type3>::take,typename type_trait<T_type4>::take,typename type_trait<T_type5>::take,typename type_trait<T_type6>::take,typename type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7);
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7));
}
#endif
retype_functor<T_functor, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>::operator()()
{ return this->functor_(); }
-
+
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::retype_functor performs a functor on the
* functor stored in the sigc::retype_functor object.
void retype_return_functor<void, T_functor>::operator()()
{ this->functor_(); }
-
+
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::retype_return_functor performs a functor on the
* functor stored in the sigc::retype_return_functor object.
void* connection::notify(void* data)
{
- connection* self = (connection*)data;
+ connection* self = reinterpret_cast<connection*>(data);
self->slot_ = 0;
return 0;
}
#define _SIGC_FUNCTORS_MACROS_MEM_FUNHM4_
#include <sigc++/type_traits.h>
#include <sigc++/functors/functor_trait.h>
+#include <sigc++/limit_reference.h>
namespace sigc {
function_type func_ptr_;
};
+
/** bound_mem_functor0 encapsulates a method with 0 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor0.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor0( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor0 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor0( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @return The return value of the method invocation.
*/
T_return operator()() const
- { return (obj_ptr_->*(this->func_ptr_))(); }
+ { return (obj_.invoke().*(this->func_ptr_))(); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor0<T_return, T_obj>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor1 encapsulates a method with 1 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor1.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor1( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor1 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor1( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor2 encapsulates a method with 2 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor2.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor2( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor2 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor2( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor3 encapsulates a method with 3 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor3.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor3( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor3 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor3( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor4 encapsulates a method with 4 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor4.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor4( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor4 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor4( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor5 encapsulates a method with 5 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor5.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor5( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor5 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor5( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor6 encapsulates a method with 6 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor6.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor6( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor6 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor6( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_mem_functor7 encapsulates a method with 7 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_mem_functor7.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor7( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_mem_functor7 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_mem_functor7( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_mem_functor performs a functor
* on the object instance stored in the sigc::bound_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor0 encapsulates a const method with 0 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor0.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor0(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor0 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor0(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @return The return value of the method invocation.
*/
T_return operator()() const
- { return (obj_ptr_->*(this->func_ptr_))(); }
+ { return (obj_.invoke().*(this->func_ptr_))(); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor0<T_return, T_obj>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor1 encapsulates a const method with 1 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor1.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor1(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor1 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor1(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor2 encapsulates a const method with 2 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor2.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor2(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor2 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor2(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor3 encapsulates a const method with 3 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor3.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor3(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor3 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor3(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor4 encapsulates a const method with 4 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor4.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor4(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor4 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor4(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor5 encapsulates a const method with 5 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor5.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor5(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor5 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor5(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor6 encapsulates a const method with 6 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor6.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor6(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor6 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor6(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_mem_functor7 encapsulates a const method with 7 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_mem_functor7.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor7(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_mem_functor7 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_mem_functor7(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor0 encapsulates a volatile method with 0 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor0.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor0( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor0 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor0( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @return The return value of the method invocation.
*/
T_return operator()() const
- { return (obj_ptr_->*(this->func_ptr_))(); }
+ { return (obj_.invoke().*(this->func_ptr_))(); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor0<T_return, T_obj>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor1 encapsulates a volatile method with 1 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor1.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor1( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor1 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor1( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor2 encapsulates a volatile method with 2 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor2.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor2( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor2 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor2( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor3 encapsulates a volatile method with 3 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor3.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor3( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor3 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor3( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor4 encapsulates a volatile method with 4 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor4.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor4( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor4 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor4( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor5 encapsulates a volatile method with 5 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor5.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor5( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor5 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor5( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor6 encapsulates a volatile method with 6 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor6.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor6( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor6 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor6( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_volatile_mem_functor7 encapsulates a volatile method with 7 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_volatile_mem_functor7.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor7( T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_volatile_mem_functor7 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_volatile_mem_functor7( T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
//protected:
- /// Pointer to stored object instance.
- T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor0 encapsulates a const volatile method with 0 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor0.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor0(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor0 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor0(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @return The return value of the method invocation.
*/
T_return operator()() const
- { return (obj_ptr_->*(this->func_ptr_))(); }
+ { return (obj_.invoke().*(this->func_ptr_))(); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor0<T_return, T_obj>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor1 encapsulates a const volatile method with 1 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor1.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor1(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor1 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor1(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor1<T_return, T_obj, T_arg1>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor2 encapsulates a const volatile method with 2 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor2.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor2(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor2 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor2(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor2<T_return, T_obj, T_arg1,T_arg2>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor3 encapsulates a const volatile method with 3 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor3.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor3(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor3 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor3(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor3<T_return, T_obj, T_arg1,T_arg2,T_arg3>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor4 encapsulates a const volatile method with 4 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor4.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor4(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor4 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor4(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor4<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor5 encapsulates a const volatile method with 5 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor5.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor5(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor5 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor5(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor5<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor6 encapsulates a const volatile method with 6 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor6.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor6(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor6 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor6(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor6<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
+
/** bound_const_volatile_mem_functor7 encapsulates a const volatile method with 7 arguments and an object instance.
* Use the convenience function mem_fun() to create an instance of bound_const_volatile_mem_functor7.
*
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor7(const T_obj* _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(_A_obj) {}
+ : base_type_(_A_func),
+ obj_(*_A_obj)
+ {}
/** Constructs a bound_const_volatile_mem_functor7 object that wraps the passed method.
* @param _A_obj Reference to instance the method will operate on.
* @param _A_func Pointer to method will be invoked from operator()().
*/
bound_const_volatile_mem_functor7(const T_obj& _A_obj, function_type _A_func)
- : base_type_(_A_func), obj_ptr_(&_A_obj) {}
+ : base_type_(_A_func),
+ obj_(_A_obj)
+ {}
/** Execute the wrapped method operating on the stored instance.
* @param _A_a1 Argument to be passed on to the method.
* @return The return value of the method invocation.
*/
T_return operator()(typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7) const
- { return (obj_ptr_->*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
+ { return (obj_.invoke().*(this->func_ptr_))(_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7); }
//protected:
- /// Pointer to stored object instance.
- const T_obj *obj_ptr_;
+ // Reference to stored object instance.
+ // This is the handler object, such as TheObject in void TheObject::signal_handler().
+ const_volatile_limit_reference<T_obj> obj_;
};
+//template specialization of visit_each<>(action, functor):
/** Performs a functor on each of the targets of a functor.
* The function overload for sigc::bound_const_volatile_mem_functor performs a functor
* on the object instance stored in the sigc::bound_const_volatile_mem_functor object.
void visit_each(const T_action& _A_action,
const bound_const_volatile_mem_functor7<T_return, T_obj, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>& _A_target)
{
- visit_each(_A_action, *_A_target.obj_ptr_);
+ sigc::visit_each(_A_action, _A_target.obj_);
}
*/
static void* destroy(void* data)
{
- self* self_ = static_cast<self*>((slot_rep*)data);
+ self* self_ = static_cast<self*>(reinterpret_cast<slot_rep*>(data));
self_->call_ = 0;
self_->destroy_ = 0;
visit_each_type<trackable*>(slot_do_unbind(self_), self_->functor_);
*/
static void* dup(void* data)
{
- slot_rep* rep_ = (slot_rep*)data;
- return static_cast<slot_rep*>(new self(*static_cast<self*>(rep_)));
+ slot_rep* a_rep = reinterpret_cast<slot_rep*>(data);
+ return static_cast<slot_rep*>(new self(*static_cast<self*>(a_rep)));
}
};
inline T_return operator()() const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_);
return T_return();
}
template <class T_functor>
slot0(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call0<T_functor, T_return>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call0<T_functor, T_return>::address();
+ }
slot0(const slot0& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1);
return T_return();
}
template <class T_functor>
slot1(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call1<T_functor, T_return, T_arg1>::address();
+ }
slot1(const slot1& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2);
return T_return();
}
template <class T_functor>
slot2(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call2<T_functor, T_return, T_arg1,T_arg2>::address();
+ }
slot2(const slot2& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3);
return T_return();
}
template <class T_functor>
slot3(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call3<T_functor, T_return, T_arg1,T_arg2,T_arg3>::address();
+ }
slot3(const slot3& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4);
return T_return();
}
template <class T_functor>
slot4(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call4<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4>::address();
+ }
slot4(const slot4& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
return T_return();
}
template <class T_functor>
slot5(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call5<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>::address();
+ }
slot5(const slot5& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
return T_return();
}
template <class T_functor>
slot6(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call6<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>::address();
+ }
slot6(const slot6& src)
: slot_base(src) {}
inline T_return operator()(arg1_type_ _A_a1,arg2_type_ _A_a2,arg3_type_ _A_a3,arg4_type_ _A_a4,arg5_type_ _A_a5,arg6_type_ _A_a6,arg7_type_ _A_a7) const
{
if (!empty() && !blocked())
- return (reinterpret_cast<call_type>(rep_->call_))(rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+ return (reinterpret_cast<call_type>(slot_base::rep_->call_))(slot_base::rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
return T_return();
}
template <class T_functor>
slot7(const T_functor& _A_func)
: slot_base(new internal::typed_slot_rep<T_functor>(_A_func))
- { rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address(); }
+ {
+ //The slot_base:: is necessary to stop the HP-UX aCC compiler from being confused. murrayc.
+ slot_base::rep_->call_ = internal::slot_call7<T_functor, T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6,T_arg7>::address();
+ }
slot7(const slot7& src)
: slot_base(src) {}
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot0 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 0 argument(s).
+ * template for 0 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return>
-class slot <T_return>
+class slot <T_return, nil, nil, nil, nil, nil, nil, nil>
: public slot0<T_return>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot1 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 1 argument(s).
+ * template for 1 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1>
-class slot <T_return, T_arg1>
+class slot <T_return, T_arg1, nil, nil, nil, nil, nil, nil>
: public slot1<T_return, T_arg1>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot2 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 2 argument(s).
+ * template for 2 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2>
-class slot <T_return, T_arg1,T_arg2>
+class slot <T_return, T_arg1, T_arg2, nil, nil, nil, nil, nil>
: public slot2<T_return, T_arg1,T_arg2>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot3 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 3 argument(s).
+ * template for 3 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-class slot <T_return, T_arg1,T_arg2,T_arg3>
+class slot <T_return, T_arg1, T_arg2, T_arg3, nil, nil, nil, nil>
: public slot3<T_return, T_arg1,T_arg2,T_arg3>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot4 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 4 argument(s).
+ * template for 4 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, nil, nil, nil>
: public slot4<T_return, T_arg1,T_arg2,T_arg3,T_arg4>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot5 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 5 argument(s).
+ * template for 5 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, nil, nil>
: public slot5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
+
/** Convenience wrapper for the numbered sigc::slot6 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::slot
- * template for 6 argument(s).
+ * template for 6 argument(s), specialized for different numbers of arguments
+ * This is possible because the template has default (nil) template types.
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-class slot <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
+class slot <T_return, T_arg1, T_arg2, T_arg3, T_arg4, T_arg5, T_arg6, nil>
: public slot6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
{
public:
: parent_type(_A_func) {}
slot(const slot& src)
- : parent_type((const parent_type&)src) {}
+ : parent_type(reinterpret_cast<const parent_type&>(src)) {}
};
parent_ = 0; // Just a precaution.
(cleanup_)(data_); // Notify the parent (might lead to destruction of this!).
}
+ else
+ call_ = 0;
}
//static
void* slot_rep::notify(void* data)
{
- slot_rep* self_ = (slot_rep*)data;
+ slot_rep* self_ = reinterpret_cast<slot_rep*>(data);
+
self_->call_ = 0; // Invalidate the slot.
self_->destroy(); // Detach the stored functor from the other referred trackables and destroy it.
self_->disconnect(); // Disconnect the slot (might lead to deletion of self_!).
+
return 0;
}
blocked_(src.blocked_)
{
if (src.rep_)
- rep_ = src.rep_->dup();
+ {
+ //Check call_ so we can ignore invalidated slots.
+ //Otherwise, destroyed bound reference parameters (whose destruction caused the slot's invalidation) may be used during dup().
+ //Note: I'd prefer to check somewhere during dup(). murrayc.
+ if (src.rep_->call_)
+ rep_ = src.rep_->dup();
+ else
+ {
+ *this = slot_base(); //Return the default invalid slot.
+ }
+ }
}
slot_base::~slot_base()
* @return A deep copy of the slot_rep object.
*/
inline slot_rep* dup() const
- { return (slot_rep*)(*dup_)(const_cast<slot_rep*>(this)); }
+ { return reinterpret_cast<slot_rep*>((*dup_)(const_cast<slot_rep*>(this))); }
/** Set the parent with a callback.
* slots have one parent exclusively.
*/
void disconnect();
-protected:
+//The Tru64 and Solaris Forte 5.5 compilers needs this operator=() to be public. I'm not sure why, or why it needs to be protected usually. murrayc.
+//See bug #168265.
+//protected:
/** Overrides this slot making a copy from another slot.
* @param src The slot from which to make a copy.
* @return @p this.
--- /dev/null
+// -*- c++ -*-
+/* Do not edit! -- generated file */
+
+
+#ifndef _SIGC_MACROS_LIMIT_REFERENCEHM4_
+#define _SIGC_MACROS_LIMIT_REFERENCEHM4_
+
+
+#include <sigc++/type_traits.h>
+#include <sigc++/trackable.h>
+
+
+namespace sigc {
+
+
+/** A limit_reference<Foo> object stores a reference (Foo&), but make sure that,
+ * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
+ * sigc::trackable reference instead of the derived reference. This avoids use of
+ * a reference to the derived type when the derived destructor has run. That can be
+ * a problem when using virtual inheritance.
+ *
+ * If Foo inherits from trackable then both the derived reference and the
+ * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
+ * reference without doing an implicit conversion. To retrieve the derived reference
+ * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
+ * reference (so that you can call visit_each() on it), you use visit().
+ *
+ * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
+ * derived reference.
+ *
+ * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
+ * and, with mem_fun(), the reference to the handling object.
+ *
+ * - @e T_type The type of the reference.
+ */
+template <class T_type,
+ bool I_derives_trackable =
+ is_base_and_derived<trackable, T_type>::value>
+class limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ limit_reference(T_type& _A_target)
+ : visited(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const T_type& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ T_type& visited;
+};
+
+/** limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ limit_reference(T_type& _A_target)
+ : visited(_A_target),
+ invoked(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const trackable& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ trackable& visited;
+
+ /** The reference.
+ */
+ T_type& invoked;
+};
+
+/** Implementation of visit_each() specialized for the limit_reference
+ * class, to call visit_each() on the entity returned by the limit_reference's
+ * visit() method.
+ * - @e T_action The type of functor to invoke.
+ * - @e T_type The type of the reference.
+ * @param _A_action The functor to invoke.
+ * @param _A_argument The visited instance.
+ */
+template <class T_action, class T_type, bool I_derives_trackable>
+void
+visit_each(const T_action& _A_action,
+ const limit_reference<T_type, I_derives_trackable>& _A_target)
+{
+ visit_each(_A_action, _A_target.visit());
+}
+
+
+/** A const_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
+ * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
+ * sigc::trackable reference instead of the derived reference. This avoids use of
+ * a reference to the derived type when the derived destructor has run. That can be
+ * a problem when using virtual inheritance.
+ *
+ * If Foo inherits from trackable then both the derived reference and the
+ * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
+ * reference without doing an implicit conversion. To retrieve the derived reference
+ * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
+ * reference (so that you can call visit_each() on it), you use visit().
+ *
+ * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
+ * derived reference.
+ *
+ * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
+ * and, with mem_fun(), the reference to the handling object.
+ *
+ * - @e T_type The type of the reference.
+ */
+template <class T_type,
+ bool I_derives_trackable =
+ is_base_and_derived<trackable, T_type>::value>
+class const_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_limit_reference(const T_type& _A_target)
+ : visited(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const T_type& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline const T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ const T_type& visited;
+};
+
+/** const_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class const_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_limit_reference(const T_type& _A_target)
+ : visited(_A_target),
+ invoked(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const trackable& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline const T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ const trackable& visited;
+
+ /** The reference.
+ */
+ const T_type& invoked;
+};
+
+/** Implementation of visit_each() specialized for the const_limit_reference
+ * class, to call visit_each() on the entity returned by the const_limit_reference's
+ * visit() method.
+ * - @e T_action The type of functor to invoke.
+ * - @e T_type The type of the reference.
+ * @param _A_action The functor to invoke.
+ * @param _A_argument The visited instance.
+ */
+template <class T_action, class T_type, bool I_derives_trackable>
+void
+visit_each(const T_action& _A_action,
+ const const_limit_reference<T_type, I_derives_trackable>& _A_target)
+{
+ visit_each(_A_action, _A_target.visit());
+}
+
+
+/** A volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
+ * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
+ * sigc::trackable reference instead of the derived reference. This avoids use of
+ * a reference to the derived type when the derived destructor has run. That can be
+ * a problem when using virtual inheritance.
+ *
+ * If Foo inherits from trackable then both the derived reference and the
+ * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
+ * reference without doing an implicit conversion. To retrieve the derived reference
+ * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
+ * reference (so that you can call visit_each() on it), you use visit().
+ *
+ * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
+ * derived reference.
+ *
+ * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
+ * and, with mem_fun(), the reference to the handling object.
+ *
+ * - @e T_type The type of the reference.
+ */
+template <class T_type,
+ bool I_derives_trackable =
+ is_base_and_derived<trackable, T_type>::value>
+class volatile_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ volatile_limit_reference(T_type& _A_target)
+ : visited(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const T_type& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline volatile T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ T_type& visited;
+};
+
+/** volatile_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class volatile_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ volatile_limit_reference(T_type& _A_target)
+ : visited(_A_target),
+ invoked(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const trackable& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline volatile T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ trackable& visited;
+
+ /** The reference.
+ */
+ T_type& invoked;
+};
+
+/** Implementation of visit_each() specialized for the volatile_limit_reference
+ * class, to call visit_each() on the entity returned by the volatile_limit_reference's
+ * visit() method.
+ * - @e T_action The type of functor to invoke.
+ * - @e T_type The type of the reference.
+ * @param _A_action The functor to invoke.
+ * @param _A_argument The visited instance.
+ */
+template <class T_action, class T_type, bool I_derives_trackable>
+void
+visit_each(const T_action& _A_action,
+ const volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
+{
+ visit_each(_A_action, _A_target.visit());
+}
+
+
+/** A const_volatile_limit_reference<Foo> object stores a reference (Foo&), but make sure that,
+ * if Foo inherits from sigc::trackable, then visit_each<>() will "limit" itself to the
+ * sigc::trackable reference instead of the derived reference. This avoids use of
+ * a reference to the derived type when the derived destructor has run. That can be
+ * a problem when using virtual inheritance.
+ *
+ * If Foo inherits from trackable then both the derived reference and the
+ * sigc::trackable reference are stored, so we can later retrieve the sigc::trackable
+ * reference without doing an implicit conversion. To retrieve the derived reference
+ * (so that you invoke methods or members of it), use invoke(). To retrieve the trackable
+ * reference (so that you can call visit_each() on it), you use visit().
+ *
+ * If Foo does not inherit from sigc::trackable then invoke() and visit() just return the
+ * derived reference.
+ *
+ * This is used for bound (sigc::bind) slot parameters (via bound_argument), bound return values,
+ * and, with mem_fun(), the reference to the handling object.
+ *
+ * - @e T_type The type of the reference.
+ */
+template <class T_type,
+ bool I_derives_trackable =
+ is_base_and_derived<trackable, T_type>::value>
+class const_volatile_limit_reference
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_volatile_limit_reference(const T_type& _A_target)
+ : visited(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const T_type& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline const volatile T_type& invoke() const
+ { return visited; }
+
+private:
+ /** The reference.
+ */
+ const T_type& visited;
+};
+
+/** const_volatile_limit_reference object for a class that derives from trackable.
+ * - @e T_type The type of the reference.
+ */
+template <class T_type>
+class const_volatile_limit_reference<T_type, true>
+{
+public:
+ /** Constructor.
+ * @param _A_target The reference to limit.
+ */
+ const_volatile_limit_reference(const T_type& _A_target)
+ : visited(_A_target),
+ invoked(_A_target)
+ {}
+
+ /** Retrieve the entity to visit for visit_each().
+ * Depending on the template specialization, this is either a derived reference, or sigc::trackable& if T_type derives from sigc::trackable.
+ * @return The reference.
+ */
+ inline const trackable& visit() const
+ { return visited; }
+
+ /** Retrieve the reference.
+ * This is always a reference to the derived instance.
+ * @return The reference.
+ */
+ inline const volatile T_type& invoke() const
+ { return invoked; }
+
+private:
+ /** The trackable reference.
+ */
+ const trackable& visited;
+
+ /** The reference.
+ */
+ const T_type& invoked;
+};
+
+/** Implementation of visit_each() specialized for the const_volatile_limit_reference
+ * class, to call visit_each() on the entity returned by the const_volatile_limit_reference's
+ * visit() method.
+ * - @e T_action The type of functor to invoke.
+ * - @e T_type The type of the reference.
+ * @param _A_action The functor to invoke.
+ * @param _A_argument The visited instance.
+ */
+template <class T_action, class T_type, bool I_derives_trackable>
+void
+visit_each(const T_action& _A_action,
+ const const_volatile_limit_reference<T_type, I_derives_trackable>& _A_target)
+{
+ visit_each(_A_action, _A_target.visit());
+}
+
+
+} /* namespace sigc */
+
+
+#endif /* _SIGC_MACROS_LIMIT_REFERENCEHM4_ */
typedef const T_type& type;
};
-template <class T_type>
-T_type& unwrap(T_type& v)
-{ return v; }
-
-template <class T_type>
-const T_type& unwrap(const T_type& v)
-{ return v; }
-
template <class T_type>
T_type& unwrap(const reference_wrapper<T_type>& v)
{ return v; }
template <class T_arg1>
inline T_return operator()(T_arg1 _A_a1)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
- ((T_type1)_A_a1));
+ (static_cast<T_type1>(_A_a1)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
inline T_return sun_forte_workaround(T_arg1 _A_a1)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
- ((T_type1)_A_a1));
+ (static_cast<T_type1>(_A_a1)));
}
#endif
template <class T_arg1,class T_arg2>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline T_return operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline T_return sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ return T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#endif
template <class T_arg1>
inline void operator()(T_arg1 _A_a1)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
- ((T_type1)_A_a1));
+ (static_cast<T_type1>(_A_a1)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1>
inline void sun_forte_workaround(T_arg1 _A_a1)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take>
- ((T_type1)_A_a1));
+ (static_cast<T_type1>(_A_a1)));
}
#endif
template <class T_arg1,class T_arg2>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6)));
}
#endif
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline void operator()(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#ifndef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
template <class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6,class T_arg7>
inline void sun_forte_workaround(T_arg1 _A_a1,T_arg2 _A_a2,T_arg3 _A_a3,T_arg4 _A_a4,T_arg5 _A_a5,T_arg6 _A_a6,T_arg7 _A_a7)
{ T_return(this->functor_.SIGC_WORKAROUND_OPERATOR_PARENTHESES<typename ::sigc::type_trait<T_type1>::take,typename ::sigc::type_trait<T_type2>::take,typename ::sigc::type_trait<T_type3>::take,typename ::sigc::type_trait<T_type4>::take,typename ::sigc::type_trait<T_type5>::take,typename ::sigc::type_trait<T_type6>::take,typename ::sigc::type_trait<T_type7>::take>
- ((T_type1)_A_a1,(T_type2)_A_a2,(T_type3)_A_a3,(T_type4)_A_a4,(T_type5)_A_a5,(T_type6)_A_a6,(T_type7)_A_a7));
+ (static_cast<T_type1>(_A_a1),static_cast<T_type2>(_A_a2),static_cast<T_type3>(_A_a3),static_cast<T_type4>(_A_a4),static_cast<T_type5>(_A_a5),static_cast<T_type6>(_A_a6),static_cast<T_type7>(_A_a7)));
}
#endif
{ this->functor_(); }
+//template specialization of visit_each<>(action, functor):
template <class T_action, class T_functor, class T_return, class T_type1,class T_type2,class T_type3,class T_type4,class T_type5,class T_type6,class T_type7>
void visit_each(const T_action& _A_action,
const retype_slot_functor<T_functor, T_return, T_type1,T_type2,T_type3,T_type4,T_type5,T_type6,T_type7>& _A_target)
#include <sigc++/functors/slot.h>
#include <sigc++/functors/mem_fun.h>
-// TODO: This should have its own test.
+//SIGC_TYPEDEF_REDEFINE_ALLOWED:
+// TODO: This should have its own test, but I can not create one that gives the error instead of just a warning. murrayc.
// I have just used this because there is a correlation between these two problems.
#ifdef SIGC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
- //Compilers, such as SUN Forte C++, that do not allow this also often
+ //Compilers, such as older versions of SUN Forte C++, that do not allow this also often
//do not allow a typedef to have the same name as a class in the typedef's definition.
+ //For Sun Forte CC 5.7 (SUN Workshop 10), comment this out to fix the build.
#define SIGC_TYPEDEF_REDEFINE_ALLOWED 1
#endif
return *this;
}
- slot_iterator& operator--(int)
+ slot_iterator operator--(int)
{
slot_iterator __tmp(*this);
--i_;
return *this;
}
- slot_const_iterator& operator--(int)
+ slot_const_iterator operator--(int)
{
slot_const_iterator __tmp(*this);
--i_;
typedef slot_iterator<slot_type> iterator;
typedef slot_const_iterator<slot_type> const_iterator;
+
+ #ifndef SIGC_HAVE_SUN_REVERSE_ITERATOR
typedef std::reverse_iterator<iterator> reverse_iterator;
typedef std::reverse_iterator<const_iterator> const_reverse_iterator;
+ #else
+ typedef std::reverse_iterator<iterator, std::random_access_iterator_tag,
+ int, int&, int*, ptrdiff_t> reverse_iterator;
+
+ typedef std::reverse_iterator<const_iterator, std::random_access_iterator_tag,
+ int, const int&, const int*, ptrdiff_t> const_reverse_iterator;
+ #endif /* SIGC_HAVE_SUN_REVERSE_ITERATOR */
+
+
+
slot_list()
: list_(0) {}
return *this;
}
- slot_iterator_buf& operator--(int)
+ slot_iterator_buf operator--(int)
{
slot_iterator_buf __tmp(*this);
--i_;
return *this;
}
- slot_iterator_buf& operator--(int)
+ slot_iterator_buf operator--(int)
{
slot_iterator_buf __tmp(*this);
--i_;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self ;
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
};
*/
static result_type emit(signal_impl* impl)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
return accumulator(slot_iterator_buf_type(), slot_iterator_buf_type());
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
self_type self (_A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
- return accumulator(slot_iterator_buf_type(impl->slots_.begin(), &self),
- slot_iterator_buf_type(impl->slots_.end(), &self));
+ return accumulator(slot_iterator_buf_type(slots.begin(), &self),
+ slot_iterator_buf_type(slots.end(), &self));
}
typename type_trait<T_arg1>::take _A_a1_;
*/
static result_type emit(signal_impl* impl, typename type_trait<T_arg1>::take _A_a1,typename type_trait<T_arg2>::take _A_a2,typename type_trait<T_arg3>::take _A_a3,typename type_trait<T_arg4>::take _A_a4,typename type_trait<T_arg5>::take _A_a5,typename type_trait<T_arg6>::take _A_a6,typename type_trait<T_arg7>::take _A_a7)
{
- if (!impl || impl->slots_.empty()) return T_return();
- iterator_type it = impl->slots_.begin();
- for (; it != impl->slots_.end(); ++it)
- if (!it->empty() && !it->blocked()) break;
- if (it == impl->slots_.end()) return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
-
+ if (!impl || impl->slots_.empty())
+ return T_return();
+
signal_exec exec(impl);
-
- T_return r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
- for (++it; it != impl->slots_.end(); ++it)
- {
- if (it->empty() || it->blocked())
- continue;
- r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
- }
+ T_return r_ = T_return();
+
+ //Use this scope to make sure that "slots" is destroyed before "exec" is destroyed.
+ //This avoids a leak on MSVC++ - see http://bugzilla.gnome.org/show_bug.cgi?id=306249
+ {
+ temp_slot_list slots(impl->slots_);
+ iterator_type it = slots.begin();
+ for (; it != slots.end(); ++it)
+ if (!it->empty() && !it->blocked()) break;
+
+ if (it == slots.end())
+ return T_return(); // note that 'T_return r_();' doesn't work => define 'r_' after this line and initialize as follows:
+
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+ for (++it; it != slots.end(); ++it)
+ {
+ if (it->empty() || it->blocked())
+ continue;
+ r_ = (reinterpret_cast<call_type>(it->rep_->call_))(it->rep_, _A_a1,_A_a2,_A_a3,_A_a4,_A_a5,_A_a6,_A_a7);
+ }
+ }
+
return r_;
}
};
{
if (!impl || impl->slots_.empty()) return;
signal_exec exec(impl);
+ temp_slot_list slots(impl->slots_);
- for (iterator_type it = impl->slots_.begin(); it != impl->slots_.end(); ++it)
+ for (iterator_type it = slots.begin(); it != slots.end(); ++it)
{
if (it->empty() || it->blocked())
continue;
};
+
/** Convenience wrapper for the numbered sigc::signal0 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 0 argument(s).
*/
template <class T_return>
-class signal <T_return>
+class signal <T_return, nil,nil,nil,nil,nil,nil,nil>
: public signal0<T_return, nil>
{
public:
: signal0<T_return, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal1 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 1 argument(s).
*/
template <class T_return, class T_arg1>
-class signal <T_return, T_arg1>
+class signal <T_return, T_arg1, nil,nil,nil,nil,nil,nil>
: public signal1<T_return, T_arg1, nil>
{
public:
: signal1<T_return, T_arg1, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal2 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 2 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2>
-class signal <T_return, T_arg1,T_arg2>
+class signal <T_return, T_arg1,T_arg2, nil,nil,nil,nil,nil>
: public signal2<T_return, T_arg1,T_arg2, nil>
{
public:
: signal2<T_return, T_arg1,T_arg2, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal3 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 3 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3>
-class signal <T_return, T_arg1,T_arg2,T_arg3>
+class signal <T_return, T_arg1,T_arg2,T_arg3, nil,nil,nil,nil>
: public signal3<T_return, T_arg1,T_arg2,T_arg3, nil>
{
public:
: signal3<T_return, T_arg1,T_arg2,T_arg3, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal4 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 4 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil,nil,nil>
: public signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil>
{
public:
: signal4<T_return, T_arg1,T_arg2,T_arg3,T_arg4, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal5 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 5 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil,nil>
: public signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>
{
public:
: signal5<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5, nil>(src) {}
};
+
/** Convenience wrapper for the numbered sigc::signal6 template.
* See the base class for useful methods.
* This is the template specialization of the unnumbered sigc::signal
* template for 6 argument(s).
*/
template <class T_return, class T_arg1,class T_arg2,class T_arg3,class T_arg4,class T_arg5,class T_arg6>
-class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6>
+class signal <T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
: public signal6<T_return, T_arg1,T_arg2,T_arg3,T_arg4,T_arg5,T_arg6, nil>
{
public:
void signal_impl::sweep()
{
+ deferred_ = false;
iterator_type i = slots_.begin();
while (i != slots_.end())
if ((*i).empty())
void* signal_impl::notify(void* d)
{
- signal_impl* self = (signal_impl*)d;
+ signal_impl* self = reinterpret_cast<signal_impl*>(d);
if (self->exec_count_ == 0)
self->sweep();
else // This is occuring during signal emission.
struct SIGC_API signal_impl
{
typedef size_t size_type;
- typedef std::list<slot_base>::iterator iterator_type;
- typedef std::list<slot_base>::const_iterator const_iterator_type;
+ typedef std::list<slot_base> slot_list;
+ typedef slot_list::iterator iterator_type;
+ typedef slot_list::const_iterator const_iterator_type;
signal_impl();
{ sig_->unreference_exec(); }
};
+/** Temporary slot list used during signal emission.
+ * Through evolution this class is slightly misnamed. It is now
+ * an index into the slot_list passed into it. It simply keeps track
+ * of where the end of this list was at construction, and pretends that's
+ * the end of your list. This way you may connect during emittion without
+ * inadvertently entering an infinite loop, as well as make other
+ * modifications to the slot_list at your own risk.
+ */
+struct temp_slot_list
+{
+ typedef signal_impl::slot_list slot_list;
+ typedef signal_impl::iterator_type iterator;
+ typedef signal_impl::const_iterator_type const_iterator;
+
+ temp_slot_list(slot_list &slots) : slots_(slots)
+ {
+ placeholder = slots_.insert(slots_.end(), slot_base());
+ }
+
+ ~temp_slot_list()
+ {
+ slots_.erase(placeholder);
+ }
+
+ iterator begin() { return slots_.begin(); }
+ iterator end() { return placeholder; }
+ const_iterator begin() const { return slots_.begin(); }
+ const_iterator end() const { return placeholder; }
+
+private:
+ slot_list &slots_;
+ slot_list::iterator placeholder;
+};
+
} /* namespace internal */
protected:
typedef internal::signal_impl::iterator_type iterator_type;
- /** Adds a slot at the bottom of the list of slots.
+ /** Adds a slot at the end of the list of slots.
+ * With connect(), slots can also be added during signal emission.
+ * In this case, they won't be executed until the next emission occurs.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
*/
iterator_type connect(const slot_base& slot_);
/** Adds a slot at the given position into the list of slots.
+ * Note that this function does not work during signal emission!
* @param i An iterator indicating the position where @e slot_ should be inserted.
* @param slot_ The slot to add to the list of slots.
* @return An iterator pointing to the new slot in the list.
iterator_type insert(iterator_type i, const slot_base& slot_);
/** Removes the slot at the given position from the list of slots.
+ * Note that this function does not work during signal emission!
* @param i An iterator pointing to the slot to be removed.
* @return An iterator pointing to the slot in the list after the one removed.
*/
#include <sigc++/trackable.h>
#include <iostream>
+
+SIGC_USING_STD(ostream)
+
using namespace std;
namespace sigc
#ifndef _SIGC_TYPE_TRAIT_H_
#define _SIGC_TYPE_TRAIT_H_
-#include <sigc++/reference_wrapper.h>
+#include <sigc++config.h> //To get SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
+
namespace sigc {
typedef const T_type* pointer;
};
-template <class T_type>
-struct type_trait<reference_wrapper<T_type> >
-{
- typedef T_type type;
- typedef T_type& pass;
- typedef T_type& take;
- typedef T_type* pointer;
-};
-
-template <class T_type>
-struct type_trait<const_reference_wrapper<T_type> >
-{
- typedef T_type type;
- typedef T_type& pass;
- typedef const T_type& take;
- typedef T_type* pointer;
-};
-
template<>
struct type_trait<void>
{
};
-/** From Esa Pulkkin:
+// From Esa Pulkkin:
+/**
* Compile-time determination of base-class relationship in C++
* (adapted to match the syntax of boost's type_traits library).
+ *
+ * Use this to provide a template specialization for a set of types.
+ * For instance,
+ *
+ * template < class T_thing, bool Tval_derives_from_something = sigc::is_base_and_derived<Something, T_thing>::value >
+ * class TheTemplate
+ * {
+ * //Standard implementation.
+ * }
+ *
+ * //Specialization for T_things that derive from Something (Tval_derives_from_something is true)
+ * template <class T_thing>
+ * class TheTemplate<T_thing, true>
+ * {
+ * T_thing thing;
+ thing.method_that_is_in_something();
+ * }
*/
template <class T_base, class T_derived>
struct is_base_and_derived
char memory[64];
};
- struct test {
+#ifndef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
+
+ //Allow the internal inner class to access the other (big) inner
+ //class. The Tru64 compiler needs this. murrayc.
+ friend struct internal_class;
+
+ //Certain compilers, notably GCC 3.2, require these functions to be inside an inner class.
+ struct internal_class
+ {
static big is_base_class_(...);
static char is_base_class_(typename type_trait<T_base>::pointer);
};
public:
static const bool value =
- sizeof(test::is_base_class_((typename type_trait<T_derived>::pointer)0)) ==
+ sizeof(internal_class::is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
sizeof(char);
+
+#else //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
+
+ //The AIX xlC compiler does not like these 2 functions being in the inner class.
+ //It says "The incomplete type "test" must not be used as a qualifier.
+ //It does not seem necessary anyway. murrayc.
+ static big is_base_class_(...);
+ static char is_base_class_(typename type_trait<T_base>::pointer);
+
+public:
+ static const bool value =
+ sizeof(is_base_class_(reinterpret_cast<typename type_trait<T_derived>::pointer>(0))) ==
+ sizeof(char);
+
+#endif //SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
+
+ void avoid_gcc3_warning_(); //Not implemented. g++ 3.3.5 (but not 3.3.4, and not 3.4) warn that there are no public methods, even though there is a public variable.
};
template <class T_base>
namespace internal {
+//This should really be an inner class of limit_derived_target, without the T_limit template type,
+//But the SUN CC 5.7 (not earlier versions) compiler finds it ambiguous when we specify a particular specialization of it.
+//and does not seem to allow us to tell it explicitly that it's an inner class.
+template <bool I_derived, class T_type, class T_limit>
+struct with_type;
+
+//Specialization for I_derived = false
+template <class T_type, class T_limit> struct
+with_type<false, T_type, T_limit>
+{
+ static void execute_(const T_type&, const T_limit&) {}
+};
+
+//Specialization for I_derived = true
+template <class T_type, class T_limit>
+struct with_type<true, T_type, T_limit>
+{
+ static void execute_(const T_type& _A_type, const T_limit& _A_action)
+ { _A_action.action_(_A_type); }
+};
+
+
/// Helper struct for visit_each_type().
template <class T_target, class T_action>
struct limit_derived_target
{
typedef limit_derived_target<T_target, T_action> T_self;
- template <bool I_derived, class T_type> struct with_type;
-
- template <class T_type> struct with_type<false,T_type>
- { static void execute_(const T_type&, const T_self&) {} };
-
- template <class T_type> struct with_type<true,T_type>
- { static void execute_(const T_type& _A_type, const T_self& _A_action)
- { _A_action.action_(_A_type); }
- };
-
+
template <class T_type>
void operator()(const T_type& _A_type) const
- { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
+ {
+ with_type<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
+ }
- limit_derived_target(const T_action& _A_action): action_(_A_action) {}
+ limit_derived_target(const T_action& _A_action)
+ : action_(_A_action)
+ {}
T_action action_;
};
-/// Helper struct for visit_each_type().
+// Specialization for T_target pointer types, to provide a slightly different execute_() implementation.
+
+template <bool I_derived, class T_type, class T_limit>
+struct with_type_pointer;
+
+//Specialization for I_derived = false
+template <class T_type, class T_limit>
+struct with_type_pointer<false, T_type, T_limit>
+{
+ static void execute_(const T_type&, const T_limit&) {}
+};
+
+//Specialization for I_derived = true
+template <class T_type, class T_limit>
+struct with_type_pointer<true, T_type, T_limit>
+{
+ static void execute_(const T_type& _A_type, const T_limit& _A_action)
+ { _A_action.action_(&_A_type); }
+};
+
template <class T_target, class T_action>
struct limit_derived_target<T_target*, T_action>
{
typedef limit_derived_target<T_target*, T_action> T_self;
- template <bool I_derived, class T_type> struct with_type;
-
- template <class T_type> struct with_type<false,T_type>
- { static void execute_(const T_type&, const T_self&) {} };
-
- template <class T_type> struct with_type<true,T_type>
- { static void execute_(const T_type& _A_type, const T_self& _A_action)
- { _A_action.action_(&_A_type); }
- };
template <class T_type>
void operator()(const T_type& _A_type) const
- { with_type<is_base_and_derived<T_target,T_type>::value,T_type>::execute_(_A_type,*this); }
+ {
+ with_type_pointer<is_base_and_derived<T_target, T_type>::value, T_type, T_self>::execute_(_A_type, *this);
+ }
- limit_derived_target(const T_action& _A_action): action_(_A_action) {}
+ limit_derived_target(const T_action& _A_action)
+ : action_(_A_action)
+ {}
T_action action_;
};
template <class T_type, class T_action, class T_functor>
void visit_each_type(const T_action& _A_action, const T_functor& _A_functor)
{
- internal::limit_derived_target<T_type,T_action> limited_action(_A_action);
- visit_each(limited_action,_A_functor);
+ typedef internal::limit_derived_target<T_type, T_action> type_limited_action;
+
+ type_limited_action limited_action(_A_action);
+
+ //specifying the types of the template specialization prevents disconnection of bound trackable references (such as with sigc::ref()),
+ //probably because the visit_each<> specializations take various different template types,
+ //in various sequences, and we are probably specifying only a subset of them with this.
+ //
+ //But this is required by the AIX (and maybe IRIX MipsPro and Tru64) compilers.
+ //I guess that sigc::ref() therefore does not work on those platforms. murrayc
+ //visit_each<type_limited_action, T_functor>(limited_action, _A_functor);
+
+ //g++ (even slightly old ones) is our primary platform, so we could use the non-crashing version.
+ //However, the expliict version also fixes a crash in a slightl more common case: http://bugzilla.gnome.org/show_bug.cgi?id=169225
+ //Users (and distributors) of libsigc++ on AIX (and maybe IRIX MipsPro and Tru64) do
+ //need to use the version above instead, to allow compilation.
+ visit_each(limited_action, _A_functor);
}
} /* namespace sigc */
-/* sigc++config.h.in. (Generated manually.) */
-/* configure checks */
-#undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
-#undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+#ifndef _SIGCXX_CONFIG_H
+#define _SIGCXX_CONFIG_H
-/* platform specific macros */
-// #define LIBSIGC_DISABLE_DEPRECATED
-// #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // only defined for MSVC to keep ABI compatibility
-#define SIGC_API
+// Detect common platforms
+#if defined(_WIN32)
+ // Win32 compilers have a lot of variation
+ #if defined(_MSC_VER)
+ #define SIGC_MSC
+ #define SIGC_WIN32
+ #define SIGC_DLL
+ #elif defined(__CYGWIN__)
+ #define SIGC_CONFIGURE
+ #elif defined(__MINGW32__)
+ #define SIGC_WIN32
+ #define SIGC_CONFIGURE
+ #else
+ //The Tru64 compiler complains about this "unrecognized preprocessing directive", but it should never get this far anyway.
+ //#warning "libsigc++ config: Unknown win32 architecture (send me gcc --dumpspecs or equiv)"
+ #endif
+#else
+ #define SIGC_CONFIGURE
+#endif /* _WIN32 */
+
+#ifdef SIGC_CONFIGURE
+ // configure checks
+ #undef SIGC_GCC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ #undef SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ #undef SIGC_SELF_REFERENCE_IN_MEMBER_INITIALIZATION
+
+ #undef SIGC_HAVE_NAMESPACE_STD
+ #undef SIGC_HAVE_SUN_REVERSE_ITERATOR
+ #undef SIGC_TYPEDEF_REDEFINE_ALLOWED
+
+ // platform specific macros
+ // #define LIBSIGC_DISABLE_DEPRECATED
+ // #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY
+#endif /* SIGC_CONFIGURE */
+
+#ifdef SIGC_MSC
+
+ // MS VC7 Warning 4251 says that the classes to any member objects in an
+ // exported class must be also be exported. Some of the libsigc++
+ // template classes contain std::list members. MS KB article 168958 says
+ // that it's not possible to export a std::list instantiation due to some
+ // wacky class nesting issues, so our only options are to ignore the
+ // warning or to modify libsigc++ to remove the std::list dependency.
+ // AFAICT, the std::list members are used internally by the library code
+ // and don't need to be used from the outside, and ignoring the warning
+ // seems to have no adverse effects, so that seems like a good enough
+ // solution for now.
+ //
+ #pragma warning(disable:4251)
+
+ #define SIGC_MSVC_TEMPLATE_SPECIALIZATION_OPERATOR_OVERLOAD
+ #define SIGC_NEW_DELETE_IN_LIBRARY_ONLY // To keep ABI compatibility
+ #define SIGC_HAVE_NAMESPACE_STD 1
+
+#endif /* SIGC_MSC */
+
+//Put things in the std namespace, if they should be there.
+#ifndef SIGC_HAVE_NAMESPACE_STD
+ # define SIGC_USING_STD(Symbol) namespace std { using ::Symbol; }
+#else
+ # define SIGC_USING_STD(Symbol) /* empty */
+#endif
+
+#ifdef SIGC_DLL
+ #if defined(SIGC_BUILD) && defined(_WINDLL)
+ #define SIGC_API __declspec(dllexport)
+ #elif !defined(SIGC_BUILD)
+ #define SIGC_API __declspec(dllimport)
+ #else
+ #define SIGC_API
+ #endif /* SIGC_BUILD - _WINDLL */
+#else
+ #define SIGC_API
+#endif /* SIGC_DLL */
+
+#endif /* _SIGCXX_CONFIG_H */
projects / ardour.git / commitdiff