smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-10 00:34:59 +01:00
Code Issues Projects Releases Wiki Activity

Initial revision

Browse source 
git-svn-id: svn://localhost/trunk/ardour2@4 d708f5d6-7413-0410-9779-e7cbd77b26cf
This commit is contained in:
Taybin Rutkin 2005-05-13 20:47:18 +00:00
commit d09f6b3016
1253 changed files with 292928 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

5
libs/glibmm2/scripts/.cvsignore Normal file
View file

@ -0,0 +1,5 @@
config.guess
config.sub
install-sh
ltmain.sh
missing

364
libs/glibmm2/scripts/cxx.m4 Normal file
View file

@ -0,0 +1,364 @@
dnl
dnl AC_CXX_NAMESPACES(ACTION_FOUND,ACTION_NOT_FOUND)
dnl
AC_DEFUN([AC_CXX_NAMESPACES],[
AC_MSG_CHECKING(if C++ compiler supports namespaces)
AC_TRY_COMPILE(
[
namespace Foo { struct A {}; }
using namespace Foo;
],[
A a;
(void)a;
],[
ac_cxx_namespaces=yes
AC_MSG_RESULT([$ac_cxx_namespaces])
$1
],[
ac_cxx_namespaces=no
AC_MSG_RESULT([$ac_cxx_namespaces])
$2
])
])
dnl
dnl AC_CXX_NAMESPACES(ACTION_FOUND,ACTION_NOT_FOUND)
dnl
AC_DEFUN([AC_CXX_BOOL],[
AC_MSG_CHECKING(if C++ compiler supports bool)
AC_TRY_COMPILE(
[
],[
bool b=true;
bool b1=false;
(void)b;
(void)b1;
],[
ac_cxx_bool=yes
AC_MSG_RESULT([$ac_cxx_bool])
$1
],[
ac_cxx_bool=no
AC_MSG_RESULT([$ac_cxx_bool])
$2
])
])
dnl
dnl AC_CXX_MUTABLE(ACTION_FOUND,ACTION_NOT_FOUND)
dnl
AC_DEFUN([AC_CXX_MUTABLE],[
AC_MSG_CHECKING(if C++ compiler supports mutable)
AC_TRY_COMPILE(
[
class k {
mutable char *c;
public:
void foo() const { c=0; }
};
],[
],[
ac_cxx_mutable=yes
AC_MSG_RESULT([$ac_cxx_mutable])
$1
],[
ac_cxx_mutable=no
AC_MSG_RESULT([$ac_cxx_mutable])
$2
])
])
dnl
dnl AC_CXX_CONST_CAST(ACTION_FOUND,ACTION_NOT_FOUND)
dnl
AC_DEFUN([AC_CXX_CONST_CAST],[
AC_MSG_CHECKING([if C++ compiler supports const_cast<>])
AC_TRY_COMPILE(
[
class foo;
],[
const foo *c=0;
foo *c1=const_cast<foo*>(c);
(void)c1;
],[
ac_cxx_const_cast=yes
AC_MSG_RESULT([$ac_cxx_const_cast])
],[
ac_cxx_const_cast=no
AC_MSG_RESULT([$ac_cxx_const_cast])
])
])
dnl
dnl GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES(ACTION_FOUND,ACTION_NOT_FOUND)
dnl
dnl Test whether the compiler allows member functions to refer to spezialized member function templates.
dnl Some compilers have problems with this. gcc 2.95.3 aborts with an internal compiler error.
dnl
AC_DEFUN([GLIBMM_CXX_MEMBER_FUNCTIONS_MEMBER_TEMPLATES],[
AC_MSG_CHECKING([if C++ compiler allows member functions to refer to member templates])
AC_TRY_COMPILE(
[
struct foo {
template <class C> inline
void doit();
void thebug();
};
template <class C> inline
void foo::doit() {
}
struct bar {
void neitherabug();
};
void notabug() {
void (foo::*func)();
func = &foo::doit<int>;
(void)func;
}
void bar::neitherabug() {
void (foo::*func)();
func = &foo::doit<int>;
(void)func;
}
void foo::thebug() {
void (foo::*func)();
func = &foo::doit<int>; //Compiler bugs usually show here.
(void)func;
}
],[],[
glibmm_cxx_member_functions_member_templates=yes
AC_DEFINE([GLIBMM_MEMBER_FUNCTIONS_MEMBER_TEMPLATES],[1],[does the C++ compiler allow member functions to refer to member templates])
AC_MSG_RESULT([$glibmm_cxx_member_functions_member_templates])
],[
glibmm_cxx_member_functions_member_templates=no
AC_DEFINE([GLIBMM_MEMBER_FUNCTIONS_MEMBER_TEMPLATES],[0])
AC_MSG_RESULT([$glibmm_cxx_member_functions_member_templates])
])
])
## GLIBMM_CXX_CAN_DISAMBIGUATE_CONST_TEMPLATE_SPECIALIZATIONS()
##
## Check whether the compiler finds it ambiguous to have both
## const and non-const template specializations,
## The SUN Forte compiler has this problem, though we are
## not 100% sure that it's a C++ standards violation.
##
AC_DEFUN([GLIBMM_CXX_CAN_DISAMBIGUATE_CONST_TEMPLATE_SPECIALIZATIONS],
[
AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[whether the compiler finds it ambiguous to have both const and non-const template specializations],
[glibmm_cv_cxx_can_disambiguate_const_template_specializations],
[
AC_TRY_COMPILE(
[
#include <iostream>
template <class T> class Foo {};
template <typename T> class Traits {
public:
const char* whoami() {
return "generic template";
}
};
template <typename T> class Traits<Foo<T> > {
public:
const char* whoami() {
return "partial specialization for Foo<T>";
}
};
template <typename T> class Traits<Foo<const T> > {
public:
const char* whoami() {
return "partial specialization for Foo<const T>";
}
};
],[
Traits<int> it;
Traits<Foo<int> > fit;
Traits<Foo<const int> > cfit;
std::cout << "Traits<int> --> "
<< it.whoami() << std::endl;
std::cout << "Traits<Foo<int>> --> "
<< fit.whoami() << std::endl;
std::cout << "Traits<Foo<const int >> --> "
<< cfit.whoami() << std::endl;
],
[glibmm_cv_cxx_can_disambiguate_const_template_specializations="yes"],
[glibmm_cv_cxx_can_disambiguate_const_template_specializations="no"]
)
])
if test "x${glibmm_cv_cxx_can_disambiguate_const_template_specializations}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_DISAMBIGUOUS_CONST_TEMPLATE_SPECIALIZATIONS],[1], [Defined if the compiler does not find it ambiguous to have both const and non-const template specializations])
}
fi
])
## GLIBMM_CXX_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION()
##
## Check whether the compiler allows us to define a template that uses
## dynamic_cast<> with an object whose type is not defined,
## even if we do not use that template before we have defined the type.
## This should probably not be allowed anyway.
##
AC_DEFUN([GLIBMM_CXX_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION],
[
AC_CACHE_CHECK(
[whether the compiler allows us to define a template that uses dynamic_cast<> with an object whose type is not yet defined],
[glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition],
[
AC_TRY_COMPILE(
[
class SomeClass;
SomeClass* some_function();
template <class T>
class SomeTemplate
{
static bool do_something()
{
//This does not compile, with the MipsPro (IRIX) compiler
//even if we don't use this template at all.
//(We would use it later, after we have defined the type).
return dynamic_cast<T*>(some_function());
}
};
],[
],
[glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition="yes"],
[glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition="no"]
)
])
if test "x${glibmm_cv_cxx_can_use_dynamic_cast_in_unused_template_without_definition}" = "xyes"; then
{
AC_DEFINE([GLIBMM_CAN_USE_DYNAMIC_CAST_IN_UNUSED_TEMPLATE_WITHOUT_DEFINITION],[1], [Defined if the compiler allows us to define a template that uses dynamic_cast<> with an object whose type is not yet defined.])
}
fi
])
## GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS()
##
## Check whether the compiler allows us to use a non-extern "C" function,
## such as a static member function, to an extern "C" function pointer,
## such as a GTK+ callback.
## This should not be allowed anyway.
##
AC_DEFUN([GLIBMM_CXX_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS],
[
AC_CACHE_CHECK(
[whether the the compilerallows us to use a non-extern "C" function for an extern "C" function pointer.],
[glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks],
[
AC_TRY_COMPILE(
[
extern "C"
{
struct somestruct
{
void (*callback) (int);
};
} // extern "C"
void somefunction(int)
{
}
],[
somestruct something;
something.callback = &somefunction;
],
[glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks="yes"],
[glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks="no"]
)
])
if test "x${glibmm_cv_cxx_can_assign_non_extern_c_functions_to_extern_c_callbacks}" = "xyes"; then
{
AC_DEFINE([GLIBMM_CAN_ASSIGN_NON_EXTERN_C_FUNCTIONS_TO_EXTERN_C_CALLBACKS],[1], [Defined if the compiler allows us to use a non-extern "C" function for an extern "C" function pointer.])
}
fi
])
## GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC()
##
## Check whether the compiler puts extern "C" functions in the global namespace,
## even inside a namespace declaration. The AIX xlC compiler does this, and also
## gets confused if we declare the namespace again inside the extern "C" block.
## This seems like a compiler bug, but not a serious one.
##
AC_DEFUN([GLIBMM_CXX_CAN_USE_NAMESPACES_INSIDE_EXTERNC],
[
AC_CACHE_CHECK(
[whether the compiler uses namespace declarations inside extern "C" blocks.],
[glibmm_cv_cxx_can_use_namespaces_inside_externc],
[
AC_TRY_COMPILE(
[
namespace test
{
extern "C"
{
void do_something();
} //extern C
class Something
{
protected:
int i;
friend void do_something();
};
void do_something()
{
Something something;
something.i = 1;
}
} //namespace
],[
],
[glibmm_cv_cxx_can_use_namespaces_inside_externc="yes"],
[glibmm_cv_cxx_can_use_namespaces_inside_externc="no"]
)
])
if test "x${glibmm_cv_cxx_can_use_namespaces_inside_externc}" = "xyes"; then
{
AC_DEFINE([GLIBMM_CAN_USE_NAMESPACES_INSIDE_EXTERNC],[1], [Defined if the compiler whether the compiler uses namespace declarations inside extern "C" blocks.])
}
fi
])

195
libs/glibmm2/scripts/cxx_std.m4 Normal file
View file

@ -0,0 +1,195 @@
cv_cxx_has_namespace_std
## GLIBMM_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 GLIBMM_HAVE_NAMESPACE_STD to 1.
##
AC_DEFUN([GLIBMM_CXX_HAS_NAMESPACE_STD],
[
AC_CACHE_CHECK(
[whether C++ library symbols are declared in namespace std],
[gtkmm_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;
],
[gtkmm_cv_cxx_has_namespace_std="yes"],
[gtkmm_cv_cxx_has_namespace_std="no"]
)
])
if test "x${gtkmm_cv_cxx_has_namespace_std}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_NAMESPACE_STD],[1], [Defined when the libstdc++ declares the std-namespace])
}
fi
])
## GLIBMM_CXX_HAS_STD_ITERATOR_TRAITS()
##
## Check for standard-conform std::iterator_traits<>, and
## #define GLIBMM_HAVE_STD_ITERATOR_TRAITS on success.
##
AC_DEFUN([GLIBMM_CXX_HAS_STD_ITERATOR_TRAITS],
[
AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[whether the C++ library supports std::iterator_traits],
[gtkmm_cv_cxx_has_std_iterator_traits],
[
AC_TRY_COMPILE(
[
#include <iterator>
#ifdef GLIBMM_HAVE_NAMESPACE_STD
using namespace std;
#endif
],[
typedef iterator_traits<char*>::value_type ValueType;
],
[gtkmm_cv_cxx_has_std_iterator_traits="yes"],
[gtkmm_cv_cxx_has_std_iterator_traits="no"]
)
])
if test "x${gtkmm_cv_cxx_has_std_iterator_traits}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_STD_ITERATOR_TRAITS],[1], [Defined if std::iterator_traits<> is standard-conforming])
}
fi
])
## GLIBMM_CXX_HAS_SUN_REVERSE_ITERATOR()
##
## Check for Sun libCstd style std::reverse_iterator,
## and #define GLIBMM_HAVE_SUN_REVERSE_ITERATOR if found.
##
AC_DEFUN([GLIBMM_CXX_HAS_SUN_REVERSE_ITERATOR],
[
AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[for non-standard Sun libCstd reverse_iterator],
[gtkmm_cv_cxx_has_sun_reverse_iterator],
[
AC_TRY_COMPILE(
[
#include <iterator>
#ifdef GLIBMM_HAVE_NAMESPACE_STD
using namespace std;
#endif
],[
typedef reverse_iterator<char*,random_access_iterator_tag,char,char&,char*,int> ReverseIter;
],
[gtkmm_cv_cxx_has_sun_reverse_iterator="yes"],
[gtkmm_cv_cxx_has_sun_reverse_iterator="no"]
)
])
if test "x${gtkmm_cv_cxx_has_sun_reverse_iterator}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_SUN_REVERSE_ITERATOR],[1], [Defined if std::reverse_iterator is in Sun libCstd style])
}
fi
])
## GLIBMM_CXX_HAS_TEMPLATE_SEQUENCE_CTORS()
##
## Check whether the STL containers have templated sequence ctors,
## and #define GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS on success.
##
AC_DEFUN([GLIBMM_CXX_HAS_TEMPLATE_SEQUENCE_CTORS],
[
AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[whether STL containers have templated sequence constructors],
[gtkmm_cv_cxx_has_template_sequence_ctors],
[
AC_TRY_COMPILE(
[
#include <vector>
#include <deque>
#include <list>
#ifdef GLIBMM_HAVE_NAMESPACE_STD
using namespace std;
#endif
],[
const int array[8] = { 0, };
vector<int> test_vector (&array[0], &array[8]);
deque<short> test_deque (test_vector.begin(), test_vector.end());
list<long> test_list (test_deque.begin(), test_deque.end());
test_vector.assign(test_list.begin(), test_list.end());
],
[gtkmm_cv_cxx_has_template_sequence_ctors="yes"],
[gtkmm_cv_cxx_has_template_sequence_ctors="no"]
)
])
if test "x${gtkmm_cv_cxx_has_template_sequence_ctors}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_TEMPLATE_SEQUENCE_CTORS],[1], [Defined if the STL containers have templated sequence ctors])
}
fi
])
## GLIBMM_CXX_ALLOWS_STATIC_INLINE_NPOS()
##
## Check whether the a static member variable may be initialized inline to std::string::npos.
## The MipsPro (IRIX) compiler does not like this.
## and #define GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS on success.
##
AC_DEFUN([GLIBMM_CXX_ALLOWS_STATIC_INLINE_NPOS],
[
AC_REQUIRE([GLIBMM_CXX_HAS_NAMESPACE_STD])
AC_CACHE_CHECK(
[whether the compiler allows a static member variable to be initialized inline to std::string::npos],
[gtkmm_cv_cxx_has_allows_static_inline_npos],
[
AC_TRY_COMPILE(
[
#include <string>
#include <iostream>
class ustringtest
{
public:
//The MipsPro compiler (IRIX) says "The indicated constant value is not known",
//so we need to initalize the static member data elsewhere.
static const std::string::size_type ustringnpos = std::string::npos;
};
],[
std::cout << "npos=" << ustringtest::ustringnpos << std::endl;
],
[gtkmm_cv_cxx_has_allows_static_inline_npos="yes"],
[gtkmm_cv_cxx_has_allows_static_inline_npos="no"]
)
])
if test "x${gtkmm_cv_cxx_has_allows_static_inline_npos}" = "xyes"; then
{
AC_DEFINE([GLIBMM_HAVE_ALLOWS_STATIC_INLINE_NPOS],[1], [Defined if a static member variable may be initialized inline to std::string::npos])
}
fi
])

134
libs/glibmm2/scripts/macros.m4 Normal file
View file

@ -0,0 +1,134 @@
dnl
dnl Some macros needed for autoconf
dnl
dnl AL_PROG_GNU_M4(ACTION_NOT_FOUND)
dnl Check for GNU m4. (sun won't do.)
dnl
AC_DEFUN([AL_PROG_GNU_M4],[
AC_CHECK_PROGS(M4, gm4 m4, m4)
if test "$M4" = "m4"; then
AC_MSG_CHECKING(whether m4 is GNU m4)
if $M4 --version </dev/null 2>/dev/null | grep '^GNU m4 ' >/dev/null ; then
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
if test "$host_vendor" = "sun"; then
$1
fi
fi
fi
])
dnl AL_PROG_GNU_MAKE(ACTION_NOT_FOUND)
dnl Check for GNU make (no sun make)
dnl
AC_DEFUN([AL_PROG_GNU_MAKE],[
dnl
dnl Check for GNU make (stolen from gtk+/configure.in)
AC_MSG_CHECKING(whether make is GNU Make)
if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
AC_MSG_RESULT(yes)
else
AC_MSG_RESULT(no)
if test "$host_vendor" = "sun" ; then
$1
fi
fi
])
dnl AL_ACLOCAL_INCLUDE(macrodir)
dnl Add a directory to macro search (from gnome)
AC_DEFUN([AL_ACLOCAL_INCLUDE],
[
test "x$ACLOCAL_FLAGS" = "x" || ACLOCAL="$ACLOCAL $ACLOCAL_FLAGS"
for dir in $1
do
ACLOCAL="$ACLOCAL -I $srcdir/$dir"
done
])
## GLIBMM_ARG_ENABLE_DEBUG_REFCOUNTING()
##
## Provide the --enable-debug-refcounting configure argument, disabled
## by default. If enabled, #define GTKMM_DEBUG_REFCOUNTING.
##
AC_DEFUN([GLIBMM_ARG_ENABLE_DEBUG_REFCOUNTING],
[
AC_ARG_ENABLE([debug-refcounting],
[ --enable-debug-refcounting Print a debug message on every ref/unref.
[[default=disabled]]],
[glibmm_debug_refcounting="$enableval"],
[glibmm_debug_refcounting='no'])
if test "x$glibmm_debug_refcounting" = "xyes"; then
{
AC_DEFINE([GLIBMM_DEBUG_REFCOUNTING],[1], [Defined when the --enable-debug-refcounting configure argument was given])
}
fi
])
## GTKMM_ARG_ENABLE_WARNINGS()
##
## Provide the --enable-warnings configure argument, set to 'minimum'
## by default.
##
AC_DEFUN([GTKMM_ARG_ENABLE_WARNINGS],
[
AC_ARG_ENABLE([warnings],
[ --enable-warnings=[[none|minimum|maximum|hardcore]]
Control compiler pickyness. [[default=minimum]]],
[gtkmm_enable_warnings="$enableval"],
[gtkmm_enable_warnings='minimum'])
AC_MSG_CHECKING([for compiler warning flags to use])
gtkmm_warning_flags=''
case "$gtkmm_enable_warnings" in
minimum|yes) gtkmm_warning_flags='-Wall -Wno-long-long';;
maximum) gtkmm_warning_flags='-pedantic -W -Wall -Wno-long-long';;
hardcore) gtkmm_warning_flags='-pedantic -W -Wall -Wno-long-long -Werror';;
esac
gtkmm_use_flags=''
if test "x$gtkmm_warning_flags" != "x"
then
echo 'int foo() { return 0; }' > conftest.cc
for flag in $gtkmm_warning_flags
do
# Test whether the compiler accepts the flag. GCC doesn't bail
# out when given an unsupported flag but prints a warning, so
# check the compiler output instead.
gtkmm_cxx_out="`$CXX $flag -c conftest.cc 2>&1`"
rm -f conftest.$OBJEXT
test "x${gtkmm_cxx_out}" = "x" && \
gtkmm_use_flags="${gtkmm_use_flags:+$gtkmm_use_flags }$flag"
done
rm -f conftest.cc
gtkmm_cxx_out=''
fi
if test "x$gtkmm_use_flags" != "x"
then
for flag in $gtkmm_use_flags
do
case " $CXXFLAGS " in
*" $flag "*) ;; # don't add flags twice
*) CXXFLAGS="${CXXFLAGS:+$CXXFLAGS }$flag";;
esac
done
else
gtkmm_use_flags='none'
fi
AC_MSG_RESULT([$gtkmm_use_flags])
])