1
  
2
  
3
  
4
  
5
  
6
  
7
  
8
  
9
  
10
  
11
  
12
  
13
  
14
  
15
  
16
  
17
  
18
  
19
  
20
  
21
  
22
  
23
  
24
  
25
  
26
  
27
  
28
  
29
  
30
  
31
  
32
  
33
  
34
  
35
  
36
  
37
  
38
  
39
  
40
  
41
  
42
  
43
  
44
  
45
  
46
  
47
  
48
  
49
  
50
  
51
  
52
  
53
  
54
  
55
  
56
  
57
  
58
  
59
  
60
  
61
  
62
  
63
  
64
  
65
  
66
  
67
  
68
  
69
  
70
  
71
  
72
  
73
  
74
  
75
  
76
  
77
  
78
  
79
  
80
  
81
  
82
  
83
  
84
  
85
  
86
  
87
  
88
  
89
  
90
  
91
  
92
  
93
  
94
  
95
  
96
  
97
  
98
  
99
  
100
  
101
  
102
  
103
  
104
  
105
  
106
  
107
  
108
  
109
  
110
  
111
  
112
  
113
  
AC_INIT(yp.c) 
AC_CONFIG_HEADER(config.h) 
 
AC_MODULE_INIT() 
 
AC_CHECK_LIB(nsl, gethostbyname) 
 
AC_HAVE_HEADERS(sys/types.h rpc/types.h rpc/rpc.h rpc/clnt.h \ 
                rpcsvc/ypclnt.h rpcsvc/yp_prot.h,,,[ 
#ifdef HAVE_RPC_TYPES_H 
#include <rpc/types.h> 
#endif 
#ifdef HAVE_RPC_RPC_H 
#include <rpc/rpc.h> 
#endif 
]) 
 
# 
# yp_order() is 
# 
# yp_order(char *, char *, int *)           On most BSD's 
# yp_order(char *, char *, unsigned int *)  On OSF/1 
# yp_order(char *, char *, unsigned long *) On SysV's 
# 
# int and unsigned int have the same size, so we only test if the last 
# arg's an unsigned long * or not. 
# 
# The above strategy is unfortunately not enough to satify TCC, 
# so we do it the hard way anyway... 
# 
AC_MSG_CHECKING(the type of the last argument to yp_order) 
AC_CACHE_VAL(pike_cv_yp_order_type, [ 
  old_ac_compile="[$]ac_compile" 
  ac_compile="[$]old_ac_compile 2>conftezt.out.2" 
  for order_type in "unsigned long" "long" "unsigned int" "int"; do 
    for str_type in "char" "const char"; do 
      AC_TRY_COMPILE([ 
#include <sys/types.h> 
#ifdef HAVE_RPC_TYPES_H 
#include <rpc/types.h> 
#endif /* HAVE_RPC_TYPES_H */ 
#ifdef HAVE_RPC_RPC_H 
#include <rpc/rpc.h> 
#endif /* HAVE_RPC_RPC_H */ 
#ifdef HAVE_RPC_CLNT_H 
#include <rpc/clnt.h> 
#endif /* HAVE_RPC_CLNT_H */ 
#include <rpcsvc/yp_prot.h> 
#include <rpcsvc/ypclnt.h> 
 
int yp_order($str_type *, $str_type *, $order_type *); 
      ],[ 
        /* EMPTY */ 
      ],[ 
        if grep -i "declaration is incompatible" <conftezt.out.2 >/dev/null; 
        then :; else 
          cat conftezt.out.2 >&AC_FD_CC 
          pike_cv_yp_order_type="$order_type" 
          break 
        fi 
      ]) 
      cat conftezt.out.2 >&AC_FD_CC 
    done 
    if test "x$pike_cv_yp_order_type" = "x$order_type"; then 
      break; 
    fi 
  done 
  ac_compile="[$]old_ac_compile" 
  rm conftezt.out.2 
 
  if test "x$pike_cv_yp_order_type" = "x"; then 
    # Use default 
    pike_cv_yp_order_type="unsigned int" 
  fi 
]) 
AC_DEFINE_UNQUOTED(YP_ORDER_TYPE, $pike_cv_yp_order_type) 
AC_MSG_RESULT($pike_cv_yp_order_type) 
 
AC_CHECK_FUNCS(yperr_string) 
 
if test "$av_cv_func_yperr_string" = "yes"; then 
  AC_MSG_CHECKING(if we need a prototype for yperr_string) 
  AC_CACHE_VAL(pike_cv_prototype_yperr_string_missing, [ 
    AC_TRY_COMPILE([ 
#if defined(HAVE_RPCSVC_YPCLNT_H) && defined(HAVE_RPCSVC_YP_PROT_H) 
#include <sys/types.h> 
#ifdef HAVE_RPC_TYPES_H 
#include <rpc/types.h> 
#endif /* HAVE_RPC_TYPES_H */ 
#ifdef HAVE_RPC_RPC_H 
#include <rpc/rpc.h> 
#endif /* HAVE_RPC_RPC_H */ 
#ifdef HAVE_RPC_CLNT_H 
#include <rpc/clnt.h> 
#endif /* HAVE_RPC_CLNT_H */ 
#include <rpcsvc/yp_prot.h> 
#include <rpcsvc/ypclnt.h> 
 
char *yperr_string(int incode); 
    ],[],[ 
      pike_cv_prototype_yperr_string_missing="yes" 
    ],[ 
      pike_cv_prototype_yperr_string_missing="no" 
    ]) 
  ]) 
  AC_MSG_RESULT($pike_cv_protype_yperr_string_missing) 
  if test "$pike_cv_protype_yperr_string_missing" = "yes"; then 
    AC_DEFINE(YPERR_STRING_PROTOTYPE_MISSING) 
  fi 
fi 
 
AC_OUTPUT(Makefile,echo FOO >stamp-h )