← Back to branch summary

~posulliv/drizzle/optimizer-style-cleanup

« back to all changes in this revision

Viewing changes to m4/pandora_stl_hash.m4

  • Committer: Padraig O'Sullivan
  • Date: 2010-04-17 01:38:47 UTC
  • mfrom: (1237.9.238 bad-staging)
  • Revision ID: osullivan.padraig@gmail.com-20100417013847-ibjioqsfbmf5yg4g
Merge trunk.

Show diffs side-by-side

added added

removed removed

Lines of Context:
m4/pandora_stl_hash.m4
1
 
# We check two things: where the include file is for hash_map, and
2
 
# what namespace hash_map lives in within that include file.  We
 
1
# We check two things: where the include file is for unordered_map, and
 
2
# what namespace unordered_map lives in within that include file.  We
3
3
# include AC_COMPILE_IFELSE for all the combinations we've seen in the
4
 
# wild.  We define one of HAVE_HASH_MAP or HAVE_EXT_HASH_MAP depending
5
 
# on location, and HASH_NAMESPACE to be the namespace hash_map is
6
 
# defined in.
7
 
#
8
 
# Ideally we'd use AC_CACHE_CHECK, but that only lets us store one value
9
 
# at a time, and we need to store two (filename and namespace).
10
 
# prints messages itself, so we have to do the message-printing ourselves
11
 
# via AC_MSG_CHECKING + AC_MSG_RESULT.  (TODO(csilvers): can we cache?)
12
 
 
13
 
AC_DEFUN([PANDORA_CXX_STL_HASH],
14
 
  [AC_MSG_CHECKING(the location of hash_map)
15
 
   save_CXXFLAGS="${CXXFLAGS}"
16
 
   CXXFLAGS="${AM_CXXFLAGS} ${CXXFLAGS}"
17
 
   AC_LANG_PUSH(C++)
18
 
   ac_cv_cxx_hash_map=""
19
 
   for location in "" "ext/" "tr1/" ; do
20
 
     for namespace in __gnu_cxx "" std stdext; do
21
 
       for classprefix in unordered hash; do
22
 
         if test -z "$ac_cv_cxx_hash_map"; then
23
 
           AC_COMPILE_IFELSE(
24
 
             [AC_LANG_PROGRAM([[#include <${location}${classprefix}_map>]],
25
 
                           [[${namespace}::${classprefix}_map<int, int> t]])],
26
 
             [ac_cv_cxx_hash_map="<${location}${classprefix}_map>";
27
 
              ac_cv_cxx_hash_set="<${location}${classprefix}_set>";
28
 
              ac_cv_cxx_hash_namespace="$namespace";
29
 
              ac_cv_cxx_hash_map_class="${classprefix}_map";
30
 
              ac_cv_cxx_hash_set_class="${classprefix}_set"])
31
 
 
32
 
         fi
33
 
       done
34
 
     done
35
 
   done
36
 
 
37
 
   if test -n "$ac_cv_cxx_hash_map"; then
38
 
      AC_DEFINE(HAVE_HASH_MAP, 1, [define if the compiler has hash_map])
39
 
      AC_DEFINE(HAVE_HASH_SET, 1, [define if the compiler has hash_set])
40
 
      AC_DEFINE_UNQUOTED(HASH_MAP_H,$ac_cv_cxx_hash_map,
41
 
                         [the location of <hash_map>])
42
 
      AC_DEFINE_UNQUOTED(HASH_SET_H,$ac_cv_cxx_hash_set,
43
 
                         [the location of <hash_set>])
44
 
      AC_DEFINE_UNQUOTED(HASH_NAMESPACE,$ac_cv_cxx_hash_namespace,
45
 
                         [the namespace of hash_map/hash_set])
46
 
      AC_DEFINE_UNQUOTED(HASH_MAP_CLASS,$ac_cv_cxx_hash_map_class,
47
 
                         [the classname of hash_map])
48
 
      AC_DEFINE_UNQUOTED(HASH_SET_CLASS,$ac_cv_cxx_hash_set_class,
49
 
                         [the classname of hash_set])
50
 
      AC_MSG_RESULT([$ac_cv_cxx_hash_map])
51
 
   else
52
 
      AC_MSG_RESULT()
53
 
      AC_MSG_WARN([could not find an STL hash_map])
54
 
   fi
55
 
   AC_CACHE_CHECK(
56
 
     [whether hash_map has rehash method],
57
 
     [ac_cv_hash_map_has_rehash],
58
 
     [AC_COMPILE_IFELSE(
59
 
       [AC_LANG_PROGRAM([[
60
 
#include HASH_MAP_H
61
 
using namespace HASH_NAMESPACE;
62
 
       ]],[[
63
 
HASH_MAP_CLASS<int, int> test_hash;
64
 
test_hash.rehash(100);
65
 
          ]])],
66
 
       [ac_cv_hash_map_has_rehash=yes],
67
 
       [ac_cv_hash_map_has_rehash=no])])
68
 
   AS_IF([test $ac_cv_hash_map_has_rehash = yes],[
69
 
      AC_DEFINE(HASH_MAP_HAS_REHASH, 1, [if hash_map<> hash rehash method])
70
 
   ])
71
 
   AC_CACHE_CHECK(
72
 
     [whether hash_map has resize method],
73
 
     [ac_cv_hash_map_has_resize],
74
 
     [AC_COMPILE_IFELSE(
75
 
       [AC_LANG_PROGRAM([[
76
 
#include HASH_MAP_H
77
 
using namespace HASH_NAMESPACE;
78
 
       ]],[[
79
 
HASH_MAP_CLASS<int, int> test_hash;
80
 
test_hash.resize(100);
81
 
          ]])],
82
 
       [ac_cv_hash_map_has_resize=yes],
83
 
       [ac_cv_hash_map_has_resize=no])])
84
 
   AS_IF([test $ac_cv_hash_map_has_resize = yes],[
85
 
      AC_DEFINE(HASH_MAP_HAS_RESIZE, 1, [if hash_map<> hash resize method])
86
 
   ])
87
 
   AC_CACHE_CHECK(
88
 
     [whether to redefine hash<string>],
89
 
     [ac_cv_redefine_hash_string],
90
 
     [AC_COMPILE_IFELSE(
91
 
       [AC_LANG_PROGRAM([[
92
 
#include HASH_SET_H
93
 
#include <string>
94
 
using namespace HASH_NAMESPACE;
95
 
using namespace std;
96
 
          ]],[[
97
 
string teststr("test");
98
 
HASH_SET_CLASS<string> test_hash;
99
 
HASH_SET_CLASS<string>::iterator iter= test_hash.find(teststr);
100
 
if (iter != test_hash.end())
101
 
  return 1;
102
 
          ]])],
103
 
       [ac_cv_redefine_hash_string=no],
104
 
       [ac_cv_redefine_hash_string=yes])])
105
 
   AS_IF([test $ac_cv_redefine_hash_string = yes],[
106
 
      AC_DEFINE(REDEFINE_HASH_STRING, 1, [if hash<string> needs to be defined])
107
 
   ])
108
 
   CXXFLAGS="${save_CXXFLAGS}"
109
 
   AC_LANG_POP()
 
4
# wild.  We define HAVE_UNORDERED_MAP and HAVE_UNORDERED_SET if we have
 
5
# them, UNORDERED_MAP_H and UNORDERED_SET_H to their location and
 
6
# UNORDERED_NAMESPACE to be the namespace unordered_map is defined in.
 
7
 
 
8
AC_DEFUN([PANDORA_CXX_STL_UNORDERED],[
 
9
  save_CXXFLAGS="${CXXFLAGS}"
 
10
  CXXFLAGS="${AM_CXXFLAGS} ${CXXFLAGS}"
 
11
  AC_LANG_PUSH(C++)
 
12
  AC_CACHE_CHECK([for STL unordered_map],
 
13
    [pandora_cv_stl_unordered],[
 
14
      AC_COMPILE_IFELSE(
 
15
        [AC_LANG_PROGRAM([[#include <unordered_map>]],
 
16
                         [[std::unordered_map<int, int> t]])],
 
17
        [pandora_cv_stl_unordered="yes"],
 
18
        [pandora_cv_stl_unordered="no"])])
 
19
 
 
20
  AS_IF([test "x${pandora_cv_stl_unordered}" != "xyes"],[
 
21
    AC_CACHE_CHECK([for tr1 unordered_map],
 
22
      [pandora_cv_tr1_unordered],[
 
23
        AC_COMPILE_IFELSE(
 
24
          [AC_LANG_PROGRAM([[
 
25
/* We put in this define because of a YACC symbol clash in Drizzle.
 
26
   Seriously... I cannot believe the GCC guys defined a piece of the internals
 
27
   of this named IF - and I can't believe that YACC generates a token define
 
28
   called IF. Really?
 
29
*/
 
30
#define IF 21;
 
31
#include <tr1/unordered_map>
 
32
            ]],[[
 
33
std::tr1::unordered_map<int, int> t
 
34
          ]])],
 
35
          [pandora_cv_tr1_unordered="yes"],
 
36
          [pandora_cv_tr1_unordered="no"])])
 
37
  ])
 
38
 
 
39
  AS_IF([test "x${pandora_cv_stl_unordered}" != "xyes" -a "x${pandora_cv_tr1_unordered}" != "xyes"],[
 
40
    AC_CACHE_CHECK([for boost unordered_map],
 
41
      [pandora_cv_boost_unordered],[
 
42
        AC_COMPILE_IFELSE(
 
43
          [AC_LANG_PROGRAM([[#include <boost/unordered_map.hpp>]],
 
44
                           [[boost::unordered_map<int, int> t]])],
 
45
          [pandora_cv_boost_unordered="yes"],
 
46
          [pandora_cv_boost_unordered="no"])])
 
47
  ])
 
48
 
 
49
  CXXFLAGS="${save_CXXFLAGS}"
 
50
  AC_LANG_POP()
 
51
 
 
52
  AS_IF([test "x${pandora_cv_stl_unordered}" = "xyes"],[
 
53
    AC_DEFINE(HAVE_STD_UNORDERED_MAP, 1,
 
54
              [if the compiler has std::unordered_map])
 
55
    AC_DEFINE(HAVE_STD_UNORDERED_SET, 1,
 
56
              [if the compiler has std::unordered_set])
 
57
    pandora_has_unordered=yes
 
58
  ])
 
59
  AS_IF([test "x${pandora_cv_tr1_unordered}" = "xyes"],[
 
60
    AC_DEFINE(HAVE_TR1_UNORDERED_MAP, 1,
 
61
              [if the compiler has std::tr1::unordered_map])
 
62
    AC_DEFINE(HAVE_TR1_UNORDERED_SET, 1,
 
63
              [if the compiler has std::tr1::unordered_set])
 
64
    pandora_has_unordered=yes
 
65
  ])
 
66
  AS_IF([test "x${pandora_cv_boost_unordered}" = "xyes"],[
 
67
    AC_DEFINE(HAVE_BOOST_UNORDERED_MAP, 1,
 
68
              [if the compiler has boost::unordered_map])
 
69
    AC_DEFINE(HAVE_BOOST_UNORDERED_SET, 1,
 
70
              [if the compiler has boost::unordered_set])
 
71
    pandora_has_unordered=yes
 
72
  ])
 
73
    
 
74
  AS_IF([test "x${pandora_has_unordered}" != "xyes"],[
 
75
    AC_MSG_WARN([could not find an STL unordered_map])
 
76
  ])
 
77
])
 
78
 
 
79
AC_DEFUN([PANDORA_HAVE_CXX_UNORDERED],[
 
80
  AC_REQUIRE([PANDORA_CXX_STL_UNORDERED])
 
81
])
 
82
 
 
83
AC_DEFUN([PANDORA_REQUIRE_CXX_UNORDERED],[
 
84
  AC_REQUIRE([PANDORA_HAVE_CXX_UNORDERED])
 
85
  AS_IF([test "x${pandora_has_unordered}" != "xyes"],[
 
86
    AC_MSG_ERROR([An STL compliant unordered_map is required for ${PACKAGE}.
 
87
    Implementations can be found in Recent versions of gcc and in boost])
 
88
  ])
110
89
])