dnl ##define([AC_CACHE_LOAD], )dnl
dnl---------------------------------------------------------------------------
dnl configure-script template
dnl
dnl---------------------------------------------------------------------------
dnl TODO: allow the use of hosts/<foo>/machine.h.in resp Makefile.in
dnl TODO:: when existing instead of the normal ones.

dnl
dnl some helper macros
dnl

AC_DEFUN([AC_UPDATE_VAR],
[if test "x$[$1]" = "x" && test "x$DEFAULT[$1]" != "x"; then
  [$1]=$DEFAULT[$1]
fi]
)

AC_DEFUN([AC_CDEF_FROM_ENABLE],
[AC_UPDATE_VAR(enable_[$1])
if test "x$enable_[$1]" = "xyes"; then
  cdef_[$1]="#define"
else
  cdef_[$1]="#undef"
fi
])

AC_DEFUN([AC_INT_VAL_FROM_WITH],
[if test "x$with_[$1]" != "x"; then
  with_[$1]=`echo $with_[$1]|
changequote(, )dnl
             sed -e 's/^\(-\?\(0x[0-9a-fA-F]\+\)\?[0-9]*\)[^0-9]\?.*$/\1/'`
changequote([, ])dnl
fi
AC_UPDATE_VAR(with_[$1])
val_[$1]=$with_[$1]]
)

AC_DEFUN([AC_STRING_VAL_FROM_WITH],
[if test "x$with_[$1]" != "x"; then
  with_[$1]=`echo $with_[$1]|
changequote(, )dnl
             sed -e 's/^\([^"]*\)\?.*$/\1/'`
changequote([, ])dnl
fi
AC_UPDATE_VAR(with_[$1])
val_[$1]="\"$with_[$1]\""]
)

AC_DEFUN([AC_TEXT_VAL_FROM_WITH],
[if test "x$with_[$1]" != "x"; then
  with_[$1]=`echo $with_[$1]|
changequote(, )dnl
             sed -e 's/^\([^"]*\)\?.*$/\1/'`
changequote([, ])dnl
fi
AC_UPDATE_VAR(with_[$1])
val_[$1]="$with_[$1]"]
)

AC_DEFUN([AC_FORM_HELP],[  --$1[]dnl
ifelse([$2],,,dnl
builtin(format,%[.]builtin(eval,(len([$1])<50)*(50-len([$1])))s,)  [default=$2])[]dnl
ifelse([$3],,,[
]patsubst([$3],[^],[        ]))[]dnl
])


AC_DEFUN([AC_MY_ARG_ENABLE],
[DEFAULTenable_[]translit([$1],[-],[_])=ifelse($2,,no,[$2])
AC_ARG_ENABLE([$1],AC_FORM_HELP([enable-$1]ifelse($3,,,[=($3)]),
ifelse([$2],,[disabled],[$2],no,[disabled],[$2],yes,[enabled],[enabled($2)]),
[$4]),[$5],[$6])
])

AC_DEFUN([AC_MY_ARG_WITH],
[DEFAULTwith_[]translit([$1],[-],[_])=ifelse($2,,no,[$2])
AC_ARG_WITH([$1],AC_FORM_HELP([with-$1]ifelse($3,,[=VALUE],[=$3]),
[$2],
[$4]),[$5],[$6])
])

AC_DEFUN([AC_NOT_AVAILABLE],
[if test "x$not_available" = "x"; then
    not_available="$1"
else
    not_available="[$not_available], $1"
fi])

dnl
dnl let's start
AC_INIT(prolang.y)

dnl set the default prefix
AC_PREFIX_DEFAULT(/opt/psyclpc)

dnl
dnl This variable collects those requested features for which the system
dnl doesn't offer the right support.

not_available=""

dnl
dnl define default values for package arguments
dnl and declare the package arguments
dnl

AC_MY_ARG_ENABLE(erq,erq,[no/erq],[Enables and or selects ERQ demon])
AC_MY_ARG_ENABLE(access-control,yes,,)
AC_MY_ARG_ENABLE(access-log,no,,)
AC_MY_ARG_ENABLE(align-functions,yes,,)
AC_MY_ARG_ENABLE(compat-mode,no,,)
AC_MY_ARG_ENABLE(strict-euids,no,,)
AC_MY_ARG_ENABLE(filename-spaces,no,,[Allow space characters in filenames])
AC_MY_ARG_ENABLE(share-variables,no,,[Enable clone initialization from blueprint variable values])
AC_MY_ARG_ENABLE(use-system-crypt,yes,,)
AC_MY_ARG_ENABLE(udp-send,yes,,)
AC_MY_ARG_ENABLE(use-ipv6,no,,[Enables support for IPv6])
AC_MY_ARG_ENABLE(use-alists,no,,[Enables alist support])
AC_MY_ARG_ENABLE(use-gnunet,no,,[Enables GNUnet support])
AC_MY_ARG_ENABLE(use-psyc,no,,[Enables libpsyc support])
AC_MY_ARG_ENABLE(use-mccp,no,,[Enables MCCP support])
AC_MY_ARG_ENABLE(use-mysql,no,,[Enables mySQL support])
AC_MY_ARG_ENABLE(use-pgsql,no,,[Enables PostgreSQL support])
AC_MY_ARG_ENABLE(use-sqlite,no,,[Enables SQLite support])

AC_MY_ARG_ENABLE(use-json,no,,[Enables JSON-C Support])
AC_MY_ARG_ENABLE(use-expat,no,,[Enables Expat XML Support])
AC_MY_ARG_ENABLE(use-iksemel,no,,[Enables Iksemel XML Support])
AC_MY_ARG_ENABLE(use-srv,no,,[Enables DNS SRV Support])
AC_MY_ARG_ENABLE(use-actions,yes,,[Enables regular MUD command parser])
AC_MY_ARG_ENABLE(use-builtin-editor,yes,,[Enables built-in text editor 'ed'])
AC_MY_ARG_ENABLE(use-debug-log,yes,,[Enables built-in text editor 'ed'])
AC_MY_ARG_ENABLE(use-experimental,no,,[Enables recent experimental features])
AC_MY_ARG_ENABLE(use-inventories,yes,,[Enables all inventory-related functions])
AC_MY_ARG_ENABLE(use-paranoia,no,,[Enables paranoid reference checking])
AC_MY_ARG_ENABLE(use-restored-objects,no,,[Enables serializing object pointers as name strings])
AC_MY_ARG_ENABLE(use-shadowing,yes,,[Enables all shadowing-related functions])
AC_MY_ARG_ENABLE(use-snooping,yes,,[Enables all snooping-related functions])
AC_MY_ARG_ENABLE(use-socket-limits,yes,,[Enables socket lines per second limits])
AC_MY_ARG_ENABLE(use-swap,no,,[Enables support for LPC memory swapping])
#AC_MY_ARG_ENABLE(backtrace-always,no,,[Always output error backtraces on the console])
AC_MY_ARG_ENABLE(use-ldmud-compatibility,yes,,[Makes psyclpc behave more like LDMUD than you will want])

AC_MY_ARG_ENABLE(use-pthreads,no,,[Enables using of threads for socket writes])
AC_MY_ARG_ENABLE(use-pcre,yes,,[Enables PCRE: yes/no])
AC_MY_ARG_ENABLE(use-iksemel,no,,[Enables use of iksemel for XML parsing])
AC_MY_ARG_ENABLE(use-deprecated,yes,,[Enables obsolete and deprecated efuns])
AC_MY_ARG_ENABLE(use-structs,yes,,[Enables structs])
AC_MY_ARG_ENABLE(use-tls,no,,[Enables Transport Layer Security over Telnet: no/gnu/ssl/yes])
AC_MY_ARG_WITH(tls-path,,,[Optional location of the TLS include/ and lib/ directory])
AC_MY_ARG_ENABLE(use-new-inlines,yes,,[Enables new inline syntax])
AC_MY_ARG_ENABLE(use-set-light,yes,,[Enables efun set_light()])
AC_MY_ARG_ENABLE(use-set-is-wizard,yes,,[Enables efun set_is_wizard()])
AC_MY_ARG_ENABLE(use-parse-command,yes,,[Enables efun parse_command()])
AC_MY_ARG_ENABLE(use-process-string,yes,,[Enables efun process_string()])
AC_MY_ARG_ENABLE(lpc-array-calls,yes,,[Enables call_others on arrays of objects])
AC_MY_ARG_ENABLE(comm-stat,yes,,)
AC_MY_ARG_ENABLE(apply-cache_stat,yes,,)
AC_MY_ARG_ENABLE(malloc-sbrk,yes,,[Use sbrk() if possible (smalloc,slaballoc)])
AC_MY_ARG_ENABLE(malloc-check,yes,,[Enable simple malloc checks (smalloc,slaballoc)])
AC_MY_ARG_ENABLE(malloc-trace,no,,[Annotate allocations with source file:line])
AC_MY_ARG_ENABLE(malloc-lpc-trace,no,,[Annotate allocations with LPC object info])
AC_MY_ARG_ENABLE(malloc-sbrk-trace,no,,[Log all esbrk() calls (smalloc,slaballoc)])
AC_MY_ARG_ENABLE(dynamic-costs,no,,)
AC_MY_ARG_ENABLE(eval-cost-trace,no,,[Writes the evaluation costs in the stracktrace])
AC_MY_ARG_ENABLE(trace-code,yes,,[trace the most recently executed bytecode])

AC_MY_ARG_ENABLE(rxcache_table,yes,,)
AC_MY_ARG_ENABLE(synchronous-heart-beat,yes,,[Do all heart beats at once.])

AC_MY_ARG_ENABLE(opcprof,no,,[create VM instruction usage statistics])
AC_MY_ARG_ENABLE(verbose-opcprof,no,,[with opcprof: include instruction names])
AC_MY_ARG_ENABLE(debug,yes,,[enable sanity checks])
AC_MY_ARG_ENABLE(yydebug,no,,[enable LPC compiler debug output])
AC_MY_ARG_ENABLE(no-inlines,no,,[disable inlining])
AC_MY_ARG_ENABLE(debug-telnet,no,,[enable telnet machine diagnostics])
AC_MY_ARG_ENABLE(debug-malloc-allocs,no,,[enable small block diagnostics])

AC_MY_ARG_ENABLE(check-object-stat,no,,[trace changes to the object statistics])
AC_MY_ARG_ENABLE(check-mapping-total,no,,[check the mapping statistic])
AC_MY_ARG_ENABLE(check-object-ref,no,,[check object references])
AC_MY_ARG_ENABLE(check-object-gc-ref,yes,,[check object references in GC])
AC_MY_ARG_ENABLE(dump-gc-refs,no,,[trace GC references])

AC_MY_ARG_WITH(optimize,med,,[Optimization level: no/low/med/high])

AC_MY_ARG_WITH(access-file,ACCESS.ALLOW,,[access permissions file])
AC_MY_ARG_WITH(access-log,access.allow.log,,[access log file])

AC_MY_ARG_WITH(pthreads-write-max-size,100000,,[max size of write buffer per thread])
AC_MY_ARG_WITH(erq-max-reply,1024,,)
AC_MY_ARG_WITH(erq-max-send,1024,,)
AC_MY_ARG_WITH(erq-debug,0,,[ERQ debug level])

AC_MY_ARG_WITH(read-file-max-size,50000,[BYTES],
  [maximum size of a file allowed to be read by 'read_file()'])

AC_MY_ARG_WITH(master-name,secure/master,,[name of the master object])
AC_MY_ARG_WITH(input-escape,"!",,[input escape character])
AC_MY_ARG_WITH(time-to-clean_up,3600,[SECONDS],)
AC_MY_ARG_WITH(time-to-swap,900,[SECONDS],)
AC_MY_ARG_WITH(time-to-swap-variables,1800,[SECONDS],)
AC_MY_ARG_WITH(time-to-reset,1800,[SECONDS],)
AC_MY_ARG_WITH(alarm-time,2,[SECONDS],)
AC_MY_ARG_WITH(heart-beat-interval,2,[SECONDS],)
AC_MY_ARG_WITH(evaluator-stack-size,2000,,)
AC_MY_ARG_WITH(max-user-trace,60,,)
AC_MY_ARG_WITH(max-trace,65,,)
AC_MY_ARG_WITH(compiler-stack-size,400,,)
AC_MY_ARG_WITH(max-bits,6144,,)
AC_MY_ARG_WITH(portno,4404,,)
AC_MY_ARG_WITH(udp-port,4404,,)
AC_MY_ARG_WITH(maxnumports,20,,)
AC_MY_ARG_WITH(max_net_connects,20,,)
AC_MY_ARG_WITH(size_socket_buffer,16384,,)
AC_MY_ARG_WITH(max-cost,1000000,,)
AC_MY_ARG_WITH(catch-reserved-cost,2000,,)
AC_MY_ARG_WITH(master-reserved-cost,0x200,,)
AC_MY_ARG_WITH(swap-file,LP_SWAP,,[name of the swap file])
AC_MY_ARG_WITH(max-array-size,5000,,[max number of array elements])
AC_MY_ARG_WITH(max-mapping-keys,5000,,[max number of mapping entries])
AC_MY_ARG_WITH(max-mapping-size,15000,,[max number of mapping elements])
AC_MY_ARG_WITH(max-callouts,0,,)
AC_MY_ARG_WITH(max-players,50,,)
AC_MY_ARG_WITH(max-local,50,,)
AC_MY_ARG_WITH(allowed-ed-cmds,20,,[number of ed commands per backend cycle])
AC_MY_ARG_WITH(reserved-user-size,700000,,)
AC_MY_ARG_WITH(reserved-master-size,100000,,)
AC_MY_ARG_WITH(reserved-system-size,200000,,)
AC_MY_ARG_WITH(htable-size,4096,,)
AC_MY_ARG_WITH(itable-size,256,,)
AC_MY_ARG_WITH(otable-size,1024,,)
AC_MY_ARG_WITH(defmax,65000,,)
AC_MY_ARG_WITH(apply-cache-bits,12,,)
AC_MY_ARG_WITH(rxcache-table,8192,,)
AC_MY_ARG_WITH(max-byte-transfer,50000,,)
AC_MY_ARG_WITH(catch-udp-port,4246,,)
AC_MY_ARG_WITH(set-buffer-size-max,65536,,)
AC_MY_ARG_WITH(malloc,default,[default/smalloc/slaballoc/sysmalloc/ptmalloc],[memory manager to use])
AC_MY_ARG_WITH(min-malloced,0,,)
AC_MY_ARG_WITH(min-small-malloced,0,,)
AC_MY_ARG_WITH(max-malloced,0x4000000,,)
AC_MY_ARG_WITH(total-trace-length,0x1000,,)
AC_MY_ARG_WITH(pcre-recursion-limit,3000,,[maximum number of recursions in PCRE package])
AC_MY_ARG_WITH(wizlist-file,WIZLIST,,[name of the wizlist file])
AC_MY_ARG_WITH(max_net_connects,10,,[maximum number of concurrent connection attempts])
AC_MY_ARG_WITH(random-period-length,19937,[607 / 1279 / 2281 / 4253 / 11213 / 19937 / 44497 / 86243 / 132049 / 216091],[period length of the random number generator])

AC_ARG_WITH(setting,[  --with-setting=SETTING  include a predefined setting],[
if test -f "settings/$withval" ; then
cat >conftest.sed <<\EOF
/^#.*/ d
/^[[ \t]]*$/ d
s/#.*$//
s/disable_\([[^= \t]]*\)/enable_\1=no/
/^enable_/ s/^/DEFAULT/p
/^with_/ s/^/DEFAULT/p
[]
EOF
eval `sed -n -f conftest.sed <settings/$withval`
rm conftest.sed
else
AC_MSG_ERROR(Setting \"$withval\" not available)
fi
])

dnl
dnl process package arguments
dnl (here the variable names are used; with a "_" instead of a dash "-" !)
dnl

AC_UPDATE_VAR(enable_erq)
if test "_$enable_erq" = "_erq" || test "x$enable_erq" = "xyes"; then
  cdef_erq_demon="#define"
  erq_sub=erq
  AC_DEFINE(ERQ_INCLUDE,"util/erq/erq.h",[define the erq include file.])
elif test "_$enable_erq" = "_xerq"; then
  cdef_erq_demon="#define"
  erq_sub=xerq
  AC_DEFINE(ERQ_INCLUDE,"util/xerq/erq.h")
else
  cdef_erq_demon="#undef"
  erq_sub=
fi

AC_UPDATE_VAR(enable_use_pcre)
if test "x$enable_use_pcre" = "x" || test "x$enable_use_pcre" = "xyes"; then
  cdef_use_pcre="#define"
  cdef_use_builtin_pcre="#undef"
  enable_use_builtin_pcre="no"
else
  cdef_use_pcre="#undef"
  cdef_use_builtin_pcre="#undef"
  enable_use_pcre="no"
  enable_use_builtin_pcre="no"
fi

AC_UPDATE_VAR(enable_use_mysql)
if test "x$enable_use_mysql" = "x" || test "x$enable_use_mysql" = "xyes"; then
  cdef_use_mysql="#define"
  mysql_path=
  enable_use_mysql="yes"
elif test "x$enable_use_mysql" = "xno"; then
  cdef_use_mysql="#undef"
  mysql_path=
else
  cdef_use_mysql="#define"
  mysql_path="$enable_use_mysql"
  enable_use_mysql="yes"
fi

AC_UPDATE_VAR(enable_use_pgsql)
if test "x$enable_use_pgsql" = "x" || test "x$enable_use_pgsql" = "xyes"; then
  cdef_use_pgsql="#define"
  pgsql_path=
  enable_use_pgsql="yes"
elif test "x$enable_use_pgsql" = "xno"; then
  cdef_use_pgsql="#undef"
  pgsql_path=
else
  cdef_use_pgsql="#define"
  pgsql_path="$enable_use_pgsql"
  enable_use_pgsql="yes"
fi

AC_UPDATE_VAR(enable_use_sqlite)
if test "x$enable_use_sqlite" = "x" || test "x$enable_use_sqlite" = "xyes"; then
  cdef_use_sqlite="#define"
  sqlite_path=
  enable_use_sqlite="yes"
elif test "x$enable_use_sqlite" = "xno"; then
  cdef_use_sqlite="#undef"
  sqlite_path=
else
  cdef_use_sqlite="#define"
  sqlite_path="$enable_use_sqlite"
  enable_use_sqlite="yes"
fi

AC_UPDATE_VAR(enable_use_psyc)
if test "x$enable_use_psyc" = "x" || test "x$enable_use_psyc" = "xyes"; then
  cdef_use_psyc="#define"
  psyc_path=
  enable_use_psyc="yes"
elif test "x$enable_use_psyc" = "xno"; then
  cdef_use_psyc="#undef"
  psyc_path=
else
  cdef_use_psyc="#define"
  psyc_path="$enable_use_psyc"
  enable_use_psyc="yes"
fi

AC_UPDATE_VAR(enable_use_json)
if test "x$enable_use_json" = "x" || test "x$enable_use_json" = "xyes"; then
  cdef_use_json="#define"
  json_path=
  enable_use_json="yes"
elif test "x$enable_use_json" = "xno"; then
  cdef_use_json="#undef"
  json_path=
else
  cdef_use_json="#define"
  json_path="$enable_use_json"
  enable_use_json="yes"
fi

AC_UPDATE_VAR(enable_use_expat)
if test "x$enable_use_expat" = "x" || test "x$enable_use_expat" = "xyes"; then
  cdef_use_expat="#define"
  expat_path=
  enable_use_expat="yes"
elif test "x$enable_use_expat" = "xno"; then
  cdef_use_expat="#undef"
  expat_path=
else
  cdef_use_expat="#define"
  expat_path="$enable_use_expat"
  enable_use_expat="yes"
fi

AC_UPDATE_VAR(enable_use_psyc)
if test "x$enable_use_psyc" = "x" || test "x$enable_use_psyc" = "xyes"; then
  cdef_use_psyc="#define"
  psyc_path=
  enable_use_psyc="yes"
elif test "x$enable_use_psyc" = "xno"; then
  cdef_use_psyc="#undef"
  psyc_path=
else
  cdef_use_psyc="#define"
  psyc_path="$enable_use_psyc"
  enable_use_psyc="yes"
fi

AC_UPDATE_VAR(enable_use_iksemel)
if test "x$enable_use_iksemel" = "x" || test "x$enable_use_iksemel" = "xyes"; then
  cdef_use_iksemel="#define"
  iksemel_path=
  enable_use_iksemel="yes"
elif test "x$enable_use_iksemel" = "xno"; then
  cdef_use_iksemel="#undef"
  iksemel_path=
else
  cdef_use_iksemel="#define"
  iksemel_path="$enable_use_iksemel"
  enable_use_iksemel="yes"
fi

# --- SRV ---
AC_CHECK_HEADER(arpa/nameser_compat.h, enable_use_srv=yes,enable_use_srv=no)

AC_UPDATE_VAR(enable_use_srv)
if test "x$enable_use_srv" = "x" || test "x$enable_use_srv" = "xyes"; then
  cdef_use_srv="#define"
  srv_path=
  enable_use_srv="yes"
elif test "x$enable_use_srv" = "xno"; then
  cdef_use_srv="#undef"
  srv_path=
else
  cdef_use_srv="#define"
  srv_path="$enable_use_srv"
  enable_use_srv="yes"
fi

AC_UPDATE_VAR(enable_use_tls)
if test "x$enable_use_tls" = "x" || test "x$enable_use_tls" = "xyes"; then
  cdef_use_tls="#define"
  tls_package="any"
  enable_use_tls="yes"
elif test "x$enable_use_tls" = "xno"; then
  cdef_use_tls="#undef"
  tls_package="any"
else
  cdef_use_tls="#define"
  tls_package="$enable_use_tls"
  enable_use_tls="yes"
fi
AC_UPDATE_VAR(with_tls_path)
if test "x$with_tls_path" = "x" -o "x$with_tls_path" = "xno" ; then
  tls_include_path=""
  tls_lib_path=""
else
  tls_include_path="${with_tls_path}/include"
  tls_lib_path="${with_tls_path}/lib"
fi

AC_CDEF_FROM_ENABLE(access_control)
AC_CDEF_FROM_ENABLE(access_log)
AC_CDEF_FROM_ENABLE(compat_mode)
AC_CDEF_FROM_ENABLE(strict_euids)
AC_CDEF_FROM_ENABLE(filename_spaces)
AC_CDEF_FROM_ENABLE(share_variables)
AC_CDEF_FROM_ENABLE(use_system_crypt)
AC_CDEF_FROM_ENABLE(use_alists)
AC_CDEF_FROM_ENABLE(use_authlocal)
AC_CDEF_FROM_ENABLE(use_mccp)
AC_CDEF_FROM_ENABLE(use_pthreads)
AC_CDEF_FROM_ENABLE(use_ipv6)
AC_CDEF_FROM_ENABLE(use_deprecated)
AC_CDEF_FROM_ENABLE(use_structs)
AC_CDEF_FROM_ENABLE(use_tls)
AC_CDEF_FROM_ENABLE(use_new_inlines)
AC_CDEF_FROM_ENABLE(use_set_light)
AC_CDEF_FROM_ENABLE(use_set_is_wizard)
AC_CDEF_FROM_ENABLE(use_parse_command)
AC_CDEF_FROM_ENABLE(use_process_string)
AC_CDEF_FROM_ENABLE(lpc_array_calls)
AC_CDEF_FROM_ENABLE(comm_stat)
AC_CDEF_FROM_ENABLE(apply_cache_stat)
AC_CDEF_FROM_ENABLE(malloc_sbrk)
AC_CDEF_FROM_ENABLE(malloc_check)
AC_CDEF_FROM_ENABLE(malloc_trace)
AC_CDEF_FROM_ENABLE(malloc_lpc_trace)
AC_CDEF_FROM_ENABLE(malloc_sbrk_trace)
AC_CDEF_FROM_ENABLE(dynamic_costs)
AC_CDEF_FROM_ENABLE(eval_cost_trace)
AC_CDEF_FROM_ENABLE(trace_code)

AC_CDEF_FROM_ENABLE(rxcache_table)
AC_CDEF_FROM_ENABLE(synchronous_heart_beat)

AC_CDEF_FROM_ENABLE(opcprof)
AC_CDEF_FROM_ENABLE(verbose_opcprof)
AC_CDEF_FROM_ENABLE(debug)
AC_CDEF_FROM_ENABLE(yydebug)
AC_CDEF_FROM_ENABLE(no_inlines)
AC_CDEF_FROM_ENABLE(debug_telnet)
AC_CDEF_FROM_ENABLE(debug_malloc_allocs)

AC_CDEF_FROM_ENABLE(check_object_stat)
AC_CDEF_FROM_ENABLE(check_mapping_total)
AC_CDEF_FROM_ENABLE(check_object_ref)
AC_CDEF_FROM_ENABLE(check_object_gc_ref)
AC_CDEF_FROM_ENABLE(dump_gc_refs)

# psyclpc extensions
#AC_CDEF_FROM_ENABLE(backtrace_always)
AC_CDEF_FROM_ENABLE(use_actions)
AC_CDEF_FROM_ENABLE(use_builtin_editor)
AC_CDEF_FROM_ENABLE(use_debug_log)
AC_CDEF_FROM_ENABLE(use_experimental)
AC_CDEF_FROM_ENABLE(use_inventories)
AC_CDEF_FROM_ENABLE(use_ldmud_compatibility)
AC_CDEF_FROM_ENABLE(use_paranoia)
AC_CDEF_FROM_ENABLE(use_restored_objects)
AC_CDEF_FROM_ENABLE(use_shadowing)
AC_CDEF_FROM_ENABLE(use_snooping)
AC_CDEF_FROM_ENABLE(use_socket_limits)
AC_CDEF_FROM_ENABLE(use_swap)

AC_TEXT_VAL_FROM_WITH(optimize)

AC_STRING_VAL_FROM_WITH(access_file)
AC_STRING_VAL_FROM_WITH(access_log)
AC_STRING_VAL_FROM_WITH(swap_file)
AC_STRING_VAL_FROM_WITH(wizlist_file)
AC_STRING_VAL_FROM_WITH(master_name)
AC_STRING_VAL_FROM_WITH(input_escape)

AC_TEXT_VAL_FROM_WITH(malloc)

AC_INT_VAL_FROM_WITH(pthreads_write_max_size)
AC_INT_VAL_FROM_WITH(erq_max_reply)
AC_INT_VAL_FROM_WITH(erq_max_send)
AC_INT_VAL_FROM_WITH(erq_debug)
AC_INT_VAL_FROM_WITH(read_file_max_size)
AC_INT_VAL_FROM_WITH(time_to_clean_up)
AC_INT_VAL_FROM_WITH(time_to_swap)
AC_INT_VAL_FROM_WITH(time_to_swap_variables)
AC_INT_VAL_FROM_WITH(time_to_reset)
AC_INT_VAL_FROM_WITH(alarm_time)
AC_INT_VAL_FROM_WITH(heart_beat_interval)
AC_INT_VAL_FROM_WITH(evaluator_stack_size)
AC_INT_VAL_FROM_WITH(max_user_trace)
AC_INT_VAL_FROM_WITH(max_trace)
AC_INT_VAL_FROM_WITH(compiler_stack_size)
AC_INT_VAL_FROM_WITH(max_bits)
AC_INT_VAL_FROM_WITH(portno)
AC_INT_VAL_FROM_WITH(maxnumports)
AC_INT_VAL_FROM_WITH(max_net_connects)
AC_INT_VAL_FROM_WITH(size_socket_buffer)
AC_INT_VAL_FROM_WITH(max_cost)
AC_INT_VAL_FROM_WITH(catch_reserved_cost)
AC_INT_VAL_FROM_WITH(master_reserved_cost)
AC_INT_VAL_FROM_WITH(max_array_size)
AC_INT_VAL_FROM_WITH(max_mapping_keys)
AC_INT_VAL_FROM_WITH(max_mapping_size)
AC_INT_VAL_FROM_WITH(max_callouts)
AC_INT_VAL_FROM_WITH(max_players)
AC_INT_VAL_FROM_WITH(max_local)
AC_INT_VAL_FROM_WITH(allowed_ed_cmds)
AC_INT_VAL_FROM_WITH(reserved_user_size)
AC_INT_VAL_FROM_WITH(reserved_master_size)
AC_INT_VAL_FROM_WITH(reserved_system_size)
AC_INT_VAL_FROM_WITH(htable_size)
AC_INT_VAL_FROM_WITH(itable_size)
AC_INT_VAL_FROM_WITH(otable_size)
AC_INT_VAL_FROM_WITH(defmax)
AC_INT_VAL_FROM_WITH(apply_cache_bits)
AC_INT_VAL_FROM_WITH(rxcache_table)
AC_INT_VAL_FROM_WITH(max_byte_transfer)
AC_INT_VAL_FROM_WITH(udp_port)
AC_INT_VAL_FROM_WITH(set_buffer_size_max)
AC_INT_VAL_FROM_WITH(min_malloced)
AC_INT_VAL_FROM_WITH(min_small_malloced)
AC_INT_VAL_FROM_WITH(max_malloced)
AC_INT_VAL_FROM_WITH(total_trace_length)
AC_INT_VAL_FROM_WITH(pcre_recursion_limit)
AC_INT_VAL_FROM_WITH(max_net_connects)
AC_INT_VAL_FROM_WITH(random_period_length)

if test "x$cdef_access_control" = "x#undef"; then
  cdef_access_log="#undef"
  val_access_log=
fi

if test "x$cdef_access_log" = "x#undef"; then
  val_access_log=
fi

if test "x$cdef_rxcache_table" = "x#undef"; then
  val_rxcache_table=
fi

if test "x$with_wizlist_file" != "xno"; then
  cdef_wizlist_file="#define"
  if test "x$with_wizlist_file" = "xyes"; then
    with_wizlist_file=""
  fi
else
  cdef_wizlist_file="#undef"
fi

if test "x$cdef_wizlist_file" = "x#undef"; then
  val_wizlist_file=
fi

if test "x$cdef_opcprof" = "x#undef"; then
  cdef_verbose_opcprof="#undef"
fi

val_optimize=`echo ${val_optimize} | tr '[a-z]' '[A-Z]'`


dnl
dnl select a C-Compiler
dnl
AC_PROG_CC

# The newer versions of gcc/egcs running on SunOS fall into catatonia when
# asked to compile this test with any optimisation. To be able to run
# configure at all, we fudge the CFLAGS a bit.

save_cflags=$CFLAGS
CFLAGS="-g"
echo "For this test, '$CFLAGS' instead of '$save_cflags' is used as compiler flags."

AC_CACHE_CHECK([gcc/assembler float/branch incompatibility, e.g. on AIX],
lp_cv_sys_float_branch_incompatible,
AC_TRY_LINK([int foo(), bar(), foobar();
#define x1 foobar();
#define x4 x1 x1 x1 x1
#define x10 x4 x4 x4 x4
#define x40 x10 x10 x10 x10
#define x100 x40 x40 x40 x40
#define x400 x100 x100 x100 x100
#define x1000 x400 x400 x400 x400
int long_branch(i)
    int i;
{
    if (i > 1) {
        x1000
    } else foo();
    return bar();
}
int foo(){ return 0; }
int bar(){ return 0; }
int foobar(){ return 0; }
double d = 4.5;],
[double e = 1.3; e/= 0.2;],
lp_cv_sys_float_branch_incompatible=no,
lp_cv_sys_float_branch_incompatible=yes
))
if test $lp_cv_sys_float_branch_incompatible = yes ; then
  CC="cc"
  GCC=""
  AC_MSG_WARN(falling back to cc)
fi

# Restore the CFLAGS
CFLAGS=$save_cflags

# check for ANSI-C  (for compiling LDMUD project)
AC_PROG_CC_STDC
if test "${ac_cv_prog_cc_stdc}" = no; then
  AC_MSG_ERROR(You need an ANSI-C89 or ISO-C (C99) compiler! sorry..)
fi


# does the compile have an inline keyword?
AC_C_INLINE
if test "x$ac_cv_c_inline" != "xno"; then
  AC_DEFINE(HAS_INLINE, 1, [Does the compiler provide inline functions?])
fi

# does the compile have an restrict keyword?
# temporarily deactivated because it introduces an #if defined x into
# machine.h and mkfunc.c can't deal with 'defined' without parentheses.
#AC_C_RESTRICT

# does the compile have an typeof keyword?
AC_C_TYPEOF

# does the preprocessor support the stringenizing operator?
AC_C_STRINGIZE

# check for some types
AC_TYPE_INT8_T
AC_TYPE_INT16_T
AC_TYPE_INT32_T
AC_TYPE_INT64_T
AC_TYPE_INTMAX_T
AC_TYPE_INTPTR_T
AC_TYPE_UINT8_T
AC_TYPE_UINT16_T
AC_TYPE_UINT32_T
AC_TYPE_UINT64_T
AC_TYPE_UINTMAX_T
AC_TYPE_UINTPTR_T
AC_TYPE_LONG_LONG_INT
AC_TYPE_UNSIGNED_LONG_LONG_INT
AC_TYPE_LONG_DOUBLE
AC_TYPE_LONG_DOUBLE_WIDER
AC_TYPE_SSIZE_T
AC_TYPE_SIZE_T
AC_TYPE_OFF_T
AC_TYPE_MODE_T
AC_TYPE_PID_T
AC_TYPE_SIGNAL

# Check some sizes
AC_CHECK_SIZEOF(char *)
AC_CHECK_SIZEOF(int)
AC_CHECK_SIZEOF(short)
AC_CHECK_SIZEOF(long)
AC_CHECK_SIZEOF(long long)
AC_CHECK_SIZEOF(intptr_t)
AC_CHECK_SIZEOF(intmax_t)


# Checking for programs
AC_PROG_INSTALL
AC_CONFIG_HEADERS(machine.h)
AC_CHECK_PROGS(YACC, byacc "bison -y", yacc)
AC_PROG_CPP

AH_TOP([
#ifndef MACHINE_H
#define MACHINE_H])
AH_BOTTOM([
#endif])

dnl Recognize some unusual systems.
dnl Not all checks happen here - the check for solaris for example requires
dnl some library checks first.

AC_EGREP_CPP(yes,[
#if defined(__EMX__)
yes
#endif
],
[ EXTRA_CFLAGS="${EXTRA_CFLAGS} -DOS2" ])

AC_EGREP_CPP(yes,[
#if defined(__CYGWIN32__) || defined(__CYGWIN__)
yes
#endif
],
[ EXTRA_CFLAGS="${EXTRA_CFLAGS} -DMSWIN" ])

dnl Checking for headers
AC_HEADER_STDBOOL
AC_CHECK_HEADERS(sys/rusage.h sys/time.h unistd.h stdlib.h libc.h memory.h)
AC_CHECK_HEADERS(string.h bstring.h netdb.h crypt.h sys/param.h sys/termios.h)

dnl extra check for <limits.h>; must be there!
AC_CHECK_HEADERS(limits.h)
AC_HEADER_DIRENT


dnl check for some functions
AC_FUNC_MKTIME
AC_FUNC_ALLOCA
AC_CHECK_FUNCS(fchmod getrusage bzero memset memcpy memmem strdup strcspn)
AC_CHECK_FUNCS(strchr strrchr getcwd memmove sysconf gettimeofday wait3 waitpid)
AC_CHECK_FUNCS(fcntl getdomainname poll strtoul trunc)


AC_CACHE_CHECK(for needed malloc() alignment,lp_cv_sys_malloc_align,
AC_TRY_COMPILE([struct ts {double d; char *p; double e;};
int i = 96/(sizeof(struct ts)-20);
],,
lp_cv_sys_malloc_align=8,
lp_cv_sys_malloc_align=4))
AC_DEFINE_UNQUOTED(MALLOC_ALIGN,$lp_cv_sys_malloc_align,[word alignment])


if test "x$ac_cv_type_signal" = "xvoid"; then
  AC_DEFINE(RETSIGTYPE_VOID, 1,                                                                                                                                                                                    
    [Set in response to the signal handler return type, since not all                                                                                                                                              
     compilers understand direct definition comparisons.                                                                                                                                                           
    ])                                                                                                                                                                                                             
fi

# --- Check for common system libraries ---

AC_CHECK_LIB(m,main)
AC_CHECK_LIB(socket,main)
AC_CHECK_LIB(nsl,main)

ERQ_LIBS="$LIBS"

AC_CHECK_LIB(ucb,main, LIBS="$LIBS -lc -lucb")
if test $ac_cv_lib_socket_main = "yes" || test $ac_cv_lib_ucb_main = "yes"; then
      AC_CHECK_LIB(nsl,main)
fi

# man herror says herror is obsolete.. but we use it in comm.c anyway...
AC_CACHE_CHECK(if -lresolv is needed, lp_cv_need_lib_resolv,
    AC_TRY_RUN([
#include <netdb.h>
void t (void)
{
    herror("foo");
}
int main(void)
{
    return 0;
}
    ],
    lp_cv_need_lib_resolv=no,
    lp_cv_need_lib_resolv=yes
))
if test "$lp_cv_need_lib_resolv" = "yes"; then
    AC_CHECK_LIB(resolv,main, LIBS="$LIBS -lresolv"; ERQ_LIBS="$LIBS")
else
    AC_CHECK_LIB(resolv,main, ERQ_LIBS="$LIBS -lresolv")
fi

# --- Check if we need the crypto libraries ---

if test "x$enable_use_system_crypt" = "x" || test "x$enable_use_system_crypt" = "xyes"; then
    AC_CHECK_FUNCS(crypt _crypt)

    for lp_lib in crypt crypto; do
        if test "$ac_cv_func_crypt" != "yes" -a "$ac_cv_func__crypt" != "yes"; then
            # Try linking with lib$lp_lib
            unset ac_cv_func_crypt
            unset ac_cv_func__crypt
            lp_save_libs="$LIBS"
            AC_CHECK_LIB($lp_lib,main, LIBS="$LIBS -l$lp_lib")

            if test "$SAVE_LIBS" != "$LIBS" ; then
                AC_CHECK_FUNCS(crypt _crypt)
                if test "$ac_cv_func_crypt" != "yes" -a "$ac_cv_func__crypt" != "yes"; then
                    # They are not in this library
                    LIBS="$lp_save_libs"
                else
                    eval "lp_cv_need_lib_${lp_lib}=yes"
                fi
            fi
        fi
    done

fi


AC_CACHE_CHECK(if inet_ntoa() ok,lp_cv_func_inet_ntoa_ok,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <netinet/in.h>
#include <arpa/inet.h>
main() {
    char addr1[[]] = "176.88.1.16";
    char addr2[[]] = "88.176.128.2";
    struct in_addr tmp;

#if SIZEOF_INT == 4
#define ADDR_TYPE unsigned int
#else
#define ADDR_TYPE unsigned long
#endif
    *((ADDR_TYPE *)&tmp) = inet_addr(addr1);
    if (strcmp(addr1, inet_ntoa(tmp)))
        exit(1);
    *((ADDR_TYPE *)&tmp) = inet_addr(addr2);
    if (strcmp(addr2, inet_ntoa(tmp)))
        exit(1);
    exit(0);
}
],lp_cv_func_inet_ntoa_ok=yes,
lp_cv_func_inet_ntoa_ok=no,
AC_TRY_COMPILE([
#if defined(sun) && !defined(__svr4__)
#include <sys/types.h> /* needed for netinet/in.h */
#include <netinet/in.h>
#include <arpa/inet.h>
char *inet_ntoa(ad)
    struct in_addr ad;
{
    static char addr[[[20]]];
    return addr;
}
#else
use inet_ntoa() from the library.
#endif
],,lp_cv_func_inet_ntoa_ok=no,
lp_cv_func_inet_ntoa_ok=yes
)))
if test $lp_cv_func_inet_ntoa_ok = yes ; then
dnl TODO: Is there any platform where this is not the case?
  AC_DEFINE(INET_NTOA_OK, 1, [Is the library function inet_ntoa() compatible with the compiler?])
fi

# --- IPV6 ---

AC_CACHE_CHECK(for IPv6 support,lp_cv_has_ipv6,
    saveflags="$CFLAGS"
    CFLAGS="$CFLAGS -I/usr/inet6/include"
    AC_TRY_COMPILE([
#include <sys/types.h>
#include <netinet/in.h>

struct sockaddr_in6 foo(void)
{
    static struct sockaddr_in6 ad;
    
    return ad;
}
    ],,lp_cv_has_ipv6=yes,
    lp_cv_has_ipv6=no
    CFLAGS="$saveflags"
))
if test $lp_cv_has_ipv6 = yes; then
    AC_DEFINE(HAS_IPV6, 1, [Does the machine offer IPv6?])
    if test $enable_use_ipv6 = yes; then
        AC_CACHE_CHECK(if -linet6 is needed, lp_cv_need_lib_inet6,
            AC_TRY_RUN([
#include <sys/types.h>
#include <netinet/in.h>
void t (void)
{
    struct sockaddr_in6 ad;
    inet6_ntoa(ad.sin_addr);
}
int main(void)
{
    return 0;
}
            ],
            lp_cv_need_lib_inet6=no,
            lp_cv_need_lib_inet6=yes
        ))
        if test "$lp_cv_need_lib_inet6" = "yes"; then
            AC_CHECK_LIB(inet6,main, LIBS="$LIBS -linet6")
        fi
    fi
else
    if test $enable_use_ipv6 = yes; then
        echo "IPV6 not supported - disabling IPV6 support."
        AC_NOT_AVAILABLE(use-ipv6)
    fi
    cdef_use_ipv6="#undef"
    enable_use_ipv6=no
fi

# --- TLS ---

has_tls=no

saveflags="$CFLAGS"
saveeflags="$EXTRA_CFLAGS"
savelibs="$LIBS"
savepkglibs="$PKGLIBS"

# Check for OpenSSL unless not desired
# Check for the libraries only if tls is actually enabled.

if test ! "x${tls_include_path}" = "x"; then
    CFLAGS="$CFLAGS -I${tls_include_path}"
    EXTRA_CFLAGS="$EXTRA_CFLAGS -I${tls_include_path}"
fi

if test ! "x${tls_lib_path}" = "x"; then
    LIBS="$LIBS -L${tls_lib_path}"
    PKGLIBS="$PKGLIBS -L${tls_lib_path}"
fi

if test "$tls_package" = "any" -o "$tls_package" = "ssl"; then

    AC_CACHE_CHECK(for OpenSSL support,lp_cv_has_openssl,
        AC_TRY_COMPILE([
    #include <openssl/ssl.h>

    void foo(void)
    {
        int i = SSL_MAX_SSL_SESSION_ID_LENGTH;
    }
        ],,lp_cv_has_openssl=yes,
        lp_cv_has_openssl=no
    ))

    if test $lp_cv_has_openssl = yes; then
        has_tls=yes
        tls_package=ssl
        AC_DEFINE(HAS_OPENSSL, 1, [Does the machine offer OpenSSL/SSL?])

        if test "$enable_use_tls" = "yes"; then
            AC_CACHE_CHECK(if -lssl or similar is needed, lp_cv_need_lib_ssl,
                AC_TRY_RUN([
    #include <openssl/ssl.h>
    void t (void)
    {
        SSL_library_init();
    }
    int main(void)
    {
        return 0;
    }
                ],
                lp_cv_need_lib_ssl=no,
                lp_cv_need_lib_ssl=yes
            ))
            if test "$lp_cv_need_lib_ssl" = "yes"; then
                lp_cv_has_lib_ssl=no
                AC_CHECK_LIB(ssl,SSL_library_init,
                             PKGLIBS="$PKGLIBS -lssl"
                             lp_cv_has_lib_ssl=yes
                            )
            fi

            if test "x$lp_cv_need_lib_crypto" != "xyes"; then
                AC_CACHE_CHECK(if -lcrypto is needed for SSL, lp_cv_need_lib_crypto,
                    AC_TRY_RUN([
#include <openssl/ssl.h>
void t (void)
{
    DH *dhe1024 = NULL;
    DH_free(dhe1024);
}
int main(void)
{
    return 0;
}
                    ],
                    lp_cv_need_lib_crypto=no,
                    lp_cv_need_lib_crypto=yes
                ))
                if test "$lp_cv_need_lib_crypto" = "yes"; then
                    AC_CHECK_LIB(crypto,main, PKGLIBS="$PKGLIBS -lcrypto")
                fi
            fi
        fi
    else
        has_tls=no
    fi
fi

# Check for GnuTLS unless not desired

if test "$tls_package" = "any" -o "$tls_package" = "gnu"; then

    AC_CACHE_CHECK(for GnuTLS support,lp_cv_has_gnutls,
        AC_TRY_COMPILE([
    #include <gnutls/gnutls.h>

    void foo(void)
    {
        int i = GNUTLS_CIPHER_RIJNDAEL_256_CBC;
    }
        ],,lp_cv_has_gnutls=yes,
        lp_cv_has_gnutls=no
    ))

    if test $lp_cv_has_gnutls = yes; then
        has_tls=yes
        tls_package=gnu
        AC_DEFINE(HAS_GNUTLS, 1, [Does the machine offer GnuTLS?])

        if test "$enable_use_tls" = "yes"; then
            AC_CACHE_CHECK(if -lgnutls or similar is needed, lp_cv_need_lib_gnutls,
                AC_TRY_RUN([
    #include <gnutls/gnutls.h>
    void t (void)
    {
        gnutls_global_init();
        gnutls_global_deinit();
    }
    int main(void)
    {
        return 0;
    }
                ],
                lp_cv_need_lib_gnutls=no,
                lp_cv_need_lib_gnutls=yes
            ))
            if test "$lp_cv_need_lib_gnutls" = "yes"; then
                lp_cv_has_lib_gnutls=no
                AC_CHECK_LIB(gnutls,gnutls_global_init,
                             PKGLIBS="$PKGLIBS -lgnutls"
                             lp_cv_has_lib_gnutls=yes
                            )
            fi
            AC_CACHE_CHECK(gnutls version, lp_cv_has_gnutls_version,
                savelibs="$LIBS"
                LIBS="$PKGLIBS"
                AC_TRY_RUN([
    #include <gnutls/gnutls.h>
    void t (void)
    {
	gnutls_dh_params dh_params;
	gnutls_dh_params_generate2( dh_params, 1024);
    }
    int main(void)
    {
        return 0;
    }
                ],
                lp_cv_has_gnutls_version=8,
                lp_cv_has_gnutls_version=7
            ))
            LIBS="$savelibs"
            AC_DEFINE_UNQUOTED(HAS_GNUTLS_VERSION, $lp_cv_has_gnutls_version, [version of GNUTLS library])
        fi

    else
        has_tls=no
    fi
fi

# Evaluate the results of the checks

if test "$has_tls" = no; then
    if test $enable_use_tls = yes; then
        echo "TLS not supported - disabling TLS support."
        AC_NOT_AVAILABLE(use-tls)
    fi
    cdef_use_tls="#undef"
    enable_use_tls=no
    EXTRA_CFLAGS="$saveeflags"
    PKGLIBS="$savepkglibs"
fi

CFLAGS="$saveflags"
LIBS="$savelibs"

# --- PThreads ---

AC_CACHE_CHECK(for pthreads support,lp_cv_has_pthreads,
    saveflags="$CFLAGS"
    savelibs="$LIBS"

    CFLAGS="$CFLAGS"
    AC_TRY_COMPILE([
#include <pthread.h>

void foo(void)
{
    int i = PTHREAD_CREATE_JOINABLE;
}
    ],,lp_cv_has_pthreads=yes,
    lp_cv_has_pthreads=no
    CFLAGS="$saveflags"
))

if test $lp_cv_has_pthreads = yes; then
    saveflags="$CFLAGS"
    savelibs="$LIBS"

    AC_DEFINE(HAS_PTHREADS, 1, [Does the machine offer pthreads?])

    AC_CACHE_CHECK(if -lpthread or similar is needed, lp_cv_need_lib_pthread,
        AC_TRY_RUN([
#include <pthread.h>
void t (void)
{
    pthread_t pid;
    pthread_cancel(pid);
}
int main(void)
{
    return 0;
}
        ],
        lp_cv_need_lib_pthread=no,
        lp_cv_need_lib_pthread=yes
    ))
    if test "$lp_cv_need_lib_pthread" = "yes"; then
        lp_cv_has_lib_pthread=no
        AC_CHECK_LIB(pthread,main,
                     LIBS="$savelibs -lpthread"
                     lp_cv_has_lib_pthread=yes
                    )
        if test "$lp_cv_has_lib_pthread" = "no"; then
            AC_CHECK_LIB(c_r,main,
                         LIBS="$savelibs -lc_r"
                         lp_cv_has_lib_pthread=yes
                        )
        fi
    fi

    AC_CACHE_CHECK(for pthread_atfork(),lp_cv_has_pthread_atfork,
        AC_TRY_RUN([
#include <pthread.h>
void t (void)
{
    pthread_atfork(0, 0, 0);
}
int main (void) {
    return 0;
}
        ],lp_cv_has_pthread_atfork=yes,
        lp_cv_has_pthread_atfork=no
        )
    )
    if test $lp_cv_has_pthread_atfork = yes; then
        AC_DEFINE(HAS_PTHREAD_ATFORK, 1, [Does the machine offer pthread_atfork()?])
    fi

    CFLAGS="$saveflags"

    if test $enable_use_pthreads = no; then
        LIBS="$savelibs"
    fi

else
    if test $enable_use_pthreads = yes; then
        echo "pthreads not supported - disabling pthreads support."
        AC_NOT_AVAILABLE(use-pthreads)
    fi
    cdef_use_pthreads="#undef"
    enable_use_pthreads=no
fi

# --- GNUnet ---

echo "--- GNUnet"

lp_cv_has_gnunet_lib="no"
AC_CHECK_LIB(gnunetcadet,main, lp_cv_has_gnunet_lib="yes")

if test $lp_cv_has_gnunet_lib = yes; then
    LIBS="-lgnunetutil -lgnunetcadet"
    AC_CACHE_CHECK(for GNUnet crypto,lp_cv_has_gnunet,
        AC_TRY_RUN([
#include <gnunet/platform.h>
#include <gnunet/gnunet_crypto_lib.h>
#include <gnunet/gnunet_common.h>
#include <gnunet/gnunet_util_lib.h>
#include <gnunet/gnunet_cadet_service.h>

int main(void) {
    const struct GNUNET_HashCode *hash = GC_u2h (4404);
    const char* expect = "VFQCGVPZJJ6PHN5DQ6NWH1BJY3Q3SNF0BVCT2B1S4Q915SMYHDRW1X2BFTEEWXG9ZC23PVH3Y1W6D4DRKRTHV2CFGHAW66W52QGM0B8";
    printf( "u2h(4404) = %s ... ", GNUNET_h2s( hash ) );
    if (strcmp(expect, GNUNET_h2s_full( hash ))) return -1;
    return 0;
}
            ],
            lp_cv_has_gnunet=yes,
            lp_cv_has_gnunet=no
        ))
    CFLAGS="$saveflags"

    if test $lp_cv_has_gnunet = yes; then
        AC_DEFINE(HAS_GNUNET, 1, [Does the machine offer GNUnet?])
        PKGLIBS="$PKGLIBS $LIBS"
	echo "	    >>> Congrats! GNUnet CADET is available."
    else
	echo "GNUnet CADET not available on this system yet."
    fi
fi

# --- libpsyc ---

echo "--- libpsyc"

lp_cv_has_psyc_lib="no"
AC_CHECK_LIB(psyc,main, lp_cv_has_psyc_lib="yes")

if test $lp_cv_has_psyc_lib = yes; then
    LIBS="-lpsyc"
    AC_CACHE_CHECK(for libpsyc functionality,lp_cv_has_psyc,
        AC_TRY_RUN([
#include <stdio.h>
#include <psyc.h>

int main(void) {
    size_t tlen = 0;
    const char *t = psyc_template(PSYC_MC_REQUEST_CONTEXT_ENTER, &tlen);
    printf("%s ... ", t);
    return PSYC_VERSION ? 0 : -1;
}
            ],
            lp_cv_has_psyc=yes,
            lp_cv_has_psyc=no
        ))
    CFLAGS="$saveflags"

    if test $lp_cv_has_psyc = yes; then
        AC_DEFINE(HAS_PSYC, 1, [Does the machine offer libpsyc?])
        PKGLIBS="$PKGLIBS $LIBS"
	echo "	    >>> Congrats! libpsyc is available on this system."
    else
	echo "libpsyc not available on this system yet."
    fi
fi

# --- PCRE ---

lp_cv_has_pcre_lib="no"
AC_CHECK_LIB(pcre,main, lp_cv_has_pcre_lib="yes")

if test $lp_cv_has_pcre_lib = yes; then
#   saveflags="$CFLAGS"
#   CFLAGS="$CFLAGS -lpcre"
    LIBS="-lpcre"
    AC_CACHE_CHECK(for PCRE functionality,lp_cv_has_pcre,
        AC_TRY_RUN([
#include <pcre.h>

pcre_extra foo(void)
{
    pcre_version();
}
int main(void)
{
    return 0;
}
            ],
            lp_cv_has_pcre=yes,
            lp_cv_has_pcre=no
        ))
    CFLAGS="$saveflags"

    if test $lp_cv_has_pcre = yes; then
        AC_DEFINE(HAS_PCRE, 1, [Does the machine offer PCRE?])
        PKGLIBS="$PKGLIBS -lpcre"
    else
	echo "PCRE not available in the system."
    fi
fi

# --- iconv ---

echo "--- libiconv"
# iconv in glibc 2.2.5 is broken - but not every system even
# uses glibc.
changequote(,)dnl
echo "$as_me:$LINENO: checking for broken iconv in glibc 2.0-2.2" >&5
echo $ECHO_N "checking for broken iconv in glibc 2.0-2.2... $ECHO_C" >&6
if test -f /usr/sbin/iconvconfig; then
    # omg, this was matching 2.10 and higher!
    # we could probably remove this whole check by now
    # thanks to spigot for figuring this one out!
    if /usr/sbin/iconvconfig -V | egrep ' 2\.[0-2]\.' >/dev/null 2>&1; then
        lp_cv_has_broken_iconv="yes"
        lp_cv_has_iconv="no"
    else
        lp_cv_has_broken_iconv="no"
    fi
else
    if test -f /usr/local/bin/iconv; then
        lp_cv_has_broken_iconv="no"
        lp_cv_has_iconv="yes"
    else
	lp_cv_has_broken_iconv="no"
        lp_cv_has_iconv="no"
    fi
fi
echo "$as_me:$LINENO: result: $lp_cv_has_broken_iconv" >&5
echo "${ECHO_T}$lp_cv_has_broken_iconv" >&6
changequote([,])dnl

AC_CACHE_CHECK(for iconv,lp_cv_has_iconv,
for TESTPATH in "" "/usr/local/include"; do
    saveflags="$CFLAGS"
    if test "x$TESTPATH" != "x"; then
        CFLAGS="-I$TESTPATH $saveflags"
    fi
AC_TRY_COMPILE([
#if defined(__linux__)
#include <iconv.h>
#else
#include <sys/iconv.h>
#endif

iconv_t * foo(void)
{
    return 0;
}
],,
lp_cv_has_iconv=yes
if test "x$TESTPATH" != "x"; then
    EXTRA_CFLAGS="-I$TESTPATH $EXTRA_CFLAGS"
fi
break;
,
lp_cv_has_iconv=no
CFLAGS="$saveflags"
)
done
)


# The system has the include files - now perform further checks
if test "x$lp_cv_has_iconv" = "xyes"; then
    saveflags="$CFLAGS"
   
    # Some systems define iconv() to take a non-const 'char**' as first arg.
    AC_MSG_CHECKING(if iconv takes a non-const char**)

    CFLAGS="$CFLAGS $EXTRA_CFLAGS"
    tcomp2='${CC-cc} ${CFLAGS} -o conftest.o -c conftest.c 2>&1'
    cat > conftest.c <<EOF
#include <stdlib.h>
#if defined(__linux__)
#include <iconv.h>
#else
#include <sys/iconv.h>
#endif

int foo(void)
{
    const char * in;

    return iconv(NULL, &in, NULL, NULL, NULL);
}
EOF

    changequote(,)dnl

    if echo `eval $tcomp2` | egrep '[a-z]' >/dev/null; then
      # Success means 'we got output' here :-(
        lp_cv_has_iconv_nonconst_in=yes
    else
        lp_cv_has_iconv_nonconst_in=no
    fi
    CFLAGS="$saveflags"

    changequote([,])dnl

    AC_MSG_RESULT($lp_cv_has_iconv_nonconst_in)

    # Does the system need to link in libiconv?
    AC_CACHE_CHECK(if -liconv is needed, lp_cv_need_lib_iconv,
        AC_TRY_RUN([
#include <stdlib.h>
#if defined(__linux__)
#include <iconv.h>
#else
#include <sys/iconv.h>
#endif

int t (void)
{
    return iconv(NULL, NULL, NULL, NULL, NULL);
}
int main(void)
{
    return 0;
}
        ],
        lp_cv_need_lib_iconv=no,
        lp_cv_need_lib_iconv=yes
    ))
    if test "$lp_cv_need_lib_iconv" = "yes"; then
        # Search the libraries
        tmp=""
        AC_CHECK_LIB(iconv,libiconv_close, tmp="-liconv")

        if test "x$tmp" = "x"; then
            CFLAGS="$saveflags -L/usr/local/lib"
            AC_CHECK_LIB(iconv,libiconv_close, tmp="-L/usr/local/lib -liconv")
        fi

        if test "x$tmp" = "x"; then
            echo "iconv library not found."
            lp_cv_has_iconv="no"
        else
            PKGLIBS="$PKGLIBS $tmp"
        fi
    fi
    CFLAGS="$saveflags"
fi

if test "x$lp_cv_has_iconv" = "xyes"; then
  AC_DEFINE(HAS_ICONV, 1, [Does the machine offer iconv?])
fi

if test "x$lp_cv_has_iconv_nonconst_in" = "xyes"; then
  AC_DEFINE(HAS_ICONV_NONCONST_IN, 1, [Does the machine's iconv take a non-const 'char**' as first arg?])
fi

# --- libidn ---
echo "--- libidn"

AC_CHECK_HEADER(idna.h, lp_cv_has_idn=yes,lp_cv_has_idn=no)
AC_CHECK_HEADER(stringprep.h, lp_cv_has_idn=yes,lp_cv_has_idn=no)
# used to check for stringprep_check_version() but we require newer calls
# on BSD it also needs -lintl
AC_CHECK_LIB(idn, idna_strerror,
	     [lp_cv_has_idn=yes LIBS="${LIBS} -lidn -lintl"],lp_cv_has_idn=no)
if test "x$lp_cv_has_idn" = "xyes"; then
    AC_DEFINE(HAS_IDN, 1, [Does the machine offer IDNA?])
fi

# --- mySQL ---

# Note: Some compilers don't have /usr/local/include in their standard
# searchpath.
# Note: Some systems require zlib together with mysqlclient, but don't
# like it if -lz precedes the -lmysqlclient in the link command.

AC_CACHE_CHECK(for mySQL,lp_cv_has_mysql,
for TESTPATH in "" "${mysql_path}/include/mysql" "${mysql_path}/include" "${mysql_path}" "/usr/local/mysql/include/mysql" "/usr/local/mysql/include" "/usr/local/include/mysql" "/usr/local/include" "/usr/lib/mysql/include" "/usr/lib/mysql/mysql" "/usr/lib/mysql" "/usr/include/mysql"; do
    saveflags="$CFLAGS"
    if test "x$TESTPATH" != "x"; then
        CFLAGS="-I$TESTPATH $saveflags"
    fi
AC_TRY_COMPILE([
#include <sys/types.h>
#include <mysql.h>
#include <errmsg.h>

struct MYSQL * foo(void)
{
    static MYSQL var;
    
    return &var;
}
],,
lp_cv_has_mysql=yes
if test "x$TESTPATH" != "x"; then
    EXTRA_CFLAGS="-I$TESTPATH $EXTRA_CFLAGS"
fi
break;
,
lp_cv_has_mysql=no
CFLAGS="$saveflags"
)
done
)

# The system has the include files - now search for the libraries.
if test $lp_cv_has_mysql = yes; then
  saveflags="$CFLAGS"
  AC_DEFINE(HAS_MYSQL, 1, [Does the machine offer mySQL?])

  if test $enable_use_mysql = yes; then
    tmp=""

    if test "x$mysql_path" = "x"; then
        AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -lmysqlclient")
        if test "x$tmp" = "x"; then
            if test -d "/usr/local/mysql/lib/mysql"; then
                unset ac_cv_lib_mysqlclient_main
                CFLAGS="$saveflags -L/usr/local/mysql/lib/mysql"
                AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L/usr/local/mysql/lib/mysql -lmysqlclient")
            elif test -d "/usr/local/mysql/lib"; then
                unset ac_cv_lib_mysqlclient_main
                CFLAGS="$saveflags -L/usr/local/mysql/lib"
                AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L/usr/local/mysql/lib -lmysqlclient")
            elif test -d "/usr/local/lib"; then
                unset ac_cv_lib_mysqlclient_main
                CFLAGS="$saveflags -L/usr/local/lib"
                AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L/usr/local/lib -lmysqlclient")
            elif test -d "/usr/lib/mysql/lib"; then
                unset ac_cv_lib_mysqlclient_main
                CFLAGS="$saveflags -L/usr/lib/mysql/lib"
                AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L/usr/lib/mysql/lib -lmysqlclient")
            fi
        fi
    else
        if test -d "${mysql_path}/lib/mysql"; then
            CFLAGS="$saveflags -L${mysql_path}/lib/mysql"
            AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L${mysql_path}/lib/mysql -lmysqlclient")
        elif test -d "${mysql_path}/lib"; then
            CFLAGS="$saveflags -L${mysql_path}/lib"
            AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L${mysql_path}/lib -lmysqlclient")
        else
            CFLAGS="$saveflags -L$mysql_path"
            AC_CHECK_LIB(mysqlclient,main, tmp="$PKGLIBS -L$mysql_path -lmysqlclient")
        fi
    fi

    if test "x$tmp" = "x"; then
        echo "mysqlclient library not found - disabling mySQL support"
        AC_NOT_AVAILABLE(use-mysql)
        cdef_use_mysql="#undef"
        enable_use_mysql="no"
        mysql_path=
        lp_cv_has_mysql="no"
    else
        PKGLIBS="$tmp"
    fi
  fi

  if test $enable_use_mysql = yes; then
      # Some systems need additional libraries
      savelibs="$LIBS"
      LIBS="$LIBS $PKGLIBS"

      AC_CACHE_CHECK(if -lz is needed, lp_cv_need_lib_z,
          AC_TRY_RUN([
#include <mysql/mysql.h>
void t (void)
{
    MYSQL *dat;

    mysql_real_connect(dat, "localhost", "user", "pwd", "db", 0, 0, 0);
}
int main(void)
{
    return 0;
}
          ],
          lp_cv_need_lib_z=no,
          lp_cv_need_lib_z=yes
      ))
      if test "$lp_cv_need_lib_z" = "yes"; then
          AC_CHECK_LIB(z,main, PKGLIBS="$PKGLIBS -lz")
      fi

      AC_CACHE_CHECK(if -lnsl is needed, lp_cv_need_lib_nsl,
          AC_TRY_RUN([
#include <mysql/mysql.h>
void t (void)
{
    MYSQL *dat;

    mysql_real_connect(dat, "localhost", "user", "pwd", "db", 0, 0, 0);
}
int main(void)
{
    return 0;
}
          ],
          lp_cv_need_lib_nsl=no,
          lp_cv_need_lib_nsl=yes
      ))
      if test "$lp_cv_need_lib_nsl" = "yes"; then
          AC_CHECK_LIB(nsl,main, PKGLIBS="$PKGLIBS -lnsl")
      fi

      LIBS="$savelibs"
  fi

  CFLAGS="$saveflags"
else
  if test $enable_use_mysql = yes; then
      AC_NOT_AVAILABLE(use-mysql)
      cdef_use_mysql="#undef"
      enable_use_mysql=no
  fi
fi

# ---

# --- PostgreSQL ---

# Note: Some compilers don't have /usr/local/include in their standard
# searchpath.

AC_CACHE_CHECK(for PostgresSQL,lp_cv_has_pgsql,
for TESTPATH in "" "$pgsql_path" "$pgsql_path/include" "/usr/local/pgsql/include" "/usr/local/include/pgsql" "/usr/include/pgsql" "/usr/lib/pgsql" "/usr/local/include"; do
    saveflags="$CFLAGS"
    if test "x$TESTPATH" != "x"; then
        CFLAGS="$saveflags -I$TESTPATH"
    fi
AC_TRY_COMPILE([
#include <libpq-fe.h>

PGconn * foo(void)
{
    static PGconn * var;
    
    return var;
}
],,
lp_cv_has_pgsql=yes
if test "x$TESTPATH" != "x"; then
    EXTRA_CFLAGS="-I$TESTPATH $EXTRA_CFLAGS"
fi
break;
,
lp_cv_has_pgsql=no
CFLAGS="$saveflags"
)
done
)

# The system has the include files - now search for the libraries.
if test $lp_cv_has_pgsql = yes; then
  saveflags="$CFLAGS"
  AC_DEFINE(HAS_PGSQL, 1, [Does the machine offer PostgreSQL?])

  if test $enable_use_pgsql = yes; then
    tmp=""

    AC_CHECK_LIB(pq,main, tmp="$PKGLIBS -lpq")

    if test "x$pgsql_path" == "x"; then
        unset ac_cv_lib_pq_main
        if test -d "${pgsql_path}/lib/pgsql"; then
            CFLAGS="$saveflags -L${pgsql_path}/lib/pgsql"
            AC_CHECK_LIB(pq,main, tmp="$PKGLIBS -L${pgsql_path}/lib/pgsql -lpq")
        elif test -d "${pgsql_path}/lib"; then
            CFLAGS="$saveflags -L${pgsql_path}/lib"
            AC_CHECK_LIB(pq,main, tmp="$PKGLIBS -L${pgsql_path}/lib -lpq")
        elif test -d "${pgsql_patch}"; then
            CFLAGS="$saveflags -L$pgsql_path"
            AC_CHECK_LIB(pq,main, tmp="$PKGLIBS -L$pgsql_path -lpq")
        fi
    fi

    if test "x$tmp" == "x"; then
        unset ac_cv_lib_pq_main
        if test -d "/usr/local/pgsql/lib"; then
            CFLAGS="$saveflags -L/usr/local/pgsql/lib"
            AC_CHECK_LIB(pq,main, tmp="$PKGLIBS -L/usr/local/pgsql/lib -lpq")
        fi
    fi

    if test "x$tmp" == "x"; then
        echo "libpq library not found - disabling PostgreSQL support"
        AC_NOT_AVAILABLE(use-pgsql)
        cdef_use_pgsql="#undef"
        enable_use_pgsql="no"
        pgsql_path=
        lp_cv_has_pgsql="no"
    else
        PKGLIBS="$tmp"
    fi
  fi

  if test "x$enable_use_pgsql" = "xyes"; then
      # Some systems need additional libraries
      savelibs="$LIBS"
      LIBS="$LIBS $PKGLIBS"

      AC_CACHE_CHECK(if -lssl is needed, lp_cv_need_lib_ssl,
          AC_TRY_RUN([
#include <libpq-fe.h>
void t (void)
{
    PQconnectStart("");
}
int main(void)
{
    return 0;
}
          ],
          lp_cv_need_lib_ssl=no,
          lp_cv_need_lib_ssl=yes
      ))
      if test "$lp_cv_need_lib_ssl" = "yes"; then
          AC_CHECK_LIB(ssl,main, PKGLIBS="$PKGLIBS -lssl")
      fi

      if test "x$lp_cv_need_lib_crypto" != "xyes"; then
          AC_CACHE_CHECK(if -lcrypto is needed, lp_cv_need_lib_crypto,
              AC_TRY_RUN([
#include <libpq-fe.h>
void t (void)
{
    PQconnectStart("");
}
int main(void)
{
    return 0;
}
              ],
              lp_cv_need_lib_crypto=no,
              lp_cv_need_lib_crypto=yes
          ))
          if test "$lp_cv_need_lib_crypto" = "yes"; then
              AC_CHECK_LIB(crypto,main, PKGLIBS="$PKGLIBS -lcrypto")
          fi
      fi

      LIBS="$savelibs"
  fi

  CFLAGS="$saveflags"
else
  if test $enable_use_pgsql = yes; then
      AC_NOT_AVAILABLE(use-pgsql)
      cdef_use_pgsql="#undef"
      enable_use_pgsql=no
  fi
fi

# --- SQLite3 ---

# Note: Some compilers don't have /usr/local/include in their standard
# searchpath.

AC_CACHE_CHECK(for SQLite3,lp_cv_has_sqlite3,
for TESTPATH in "" "$sqlite_path" "$sqlite_path/include" "/usr/local/include" ; do
    saveflags="$CFLAGS"
    if test "x$TESTPATH" != "x"; then
        CFLAGS="$saveflags -I$TESTPATH"
    fi
AC_TRY_COMPILE([
#include <sqlite3.h>

sqlite3 * foo(void)
{

    return (sqlite3*)0;
}
],,
lp_cv_has_sqlite3=yes
if test "x$TESTPATH" != "x"; then
    EXTRA_CFLAGS="-I$TESTPATH $EXTRA_CFLAGS"
fi
break;
,
lp_cv_has_sqlite3=no
CFLAGS="$saveflags"
)
done
)

# The system has the include files - now search for the libraries.
if test $lp_cv_has_sqlite3 = yes; then
  saveflags="$CFLAGS"
  AC_DEFINE(HAS_SQLITE3, 1, [Does the machine offer SQLite3?])

  if test $enable_use_sqlite = yes; then
    tmp=""

    AC_CHECK_LIB(sqlite3,main, tmp="$PKGLIBS -lsqlite3")

    if test "x$sqlite_path" == "x"; then
        unset ac_cv_lib_sqlite3_main
        if test -d "${sqlite_path}/lib/sqlite"; then
            CFLAGS="$saveflags -L${sqlite_path}/lib/sqlite"
            AC_CHECK_LIB(sqlite3,main, tmp="$PKGLIBS -L${sqlite_path}/lib/sqlite -lsqlite3")
        elif test -d "${sqlite_path}/lib"; then
            CFLAGS="$saveflags -L${sqlite_path}/lib"
            AC_CHECK_LIB(sqlite3,main, tmp="$PKGLIBS -L${sqlite_path}/lib -lsqlite3")
        elif test -d "${sqlite_patch}"; then
            CFLAGS="$saveflags -L$sqlite_path"
            AC_CHECK_LIB(sqlite3,main, tmp="$PKGLIBS -L$sqlite_path -lsqlite3")
        fi
    fi

    if test "x$tmp" == "x"; then
        unset ac_cv_lib_sqlite3_main
        if test -d "/usr/local/lib"; then
            CFLAGS="$saveflags -L/usr/local/pgsql/lib"
            AC_CHECK_LIB(sqlite3,main, tmp="$PKGLIBS -L/usr/local/lib -lsqlite3")
        fi
    fi

    if test "x$tmp" == "x"; then
        echo "libsqlite3 library not found - disabling SQLite support"
        AC_NOT_AVAILABLE(use-sqlite)
        cdef_use_sqlite="#undef"
        enable_use_sqlite="no"
        sqlite=
        lp_cv_has_sqlite="no"
    else
        PKGLIBS="$tmp"
    fi
  fi

  if test "x$enable_use_sqlite" = "xyes"; then
      savelibs="$LIBS"
      LIBS="$LIBS $PKGLIBS"
      
      # Check if it uses pthreads

      AC_CHECK_LIB(sqlite3, pthread_create,
      	   lp_cv_sqlite3_uses_pthreads=yes,
      	   lp_cv_sqlite3_uses_pthreads=no
      )

      if test $lp_cv_sqlite3_uses_pthreads = yes ; then
           AC_DEFINE(SQLITE3_USES_PTHREADS, 1, [Does SQLite3 use pthreads?])
      fi

      LIBS="$savelibs"
  fi

  CFLAGS="$saveflags"
else
  if test $enable_use_sqlite = yes; then
      AC_NOT_AVAILABLE(use-sqlite)
      cdef_use_sqlite="#undef"
      enable_use_sqlite=no
  fi
fi

# --- Iksemel ---

AC_CACHE_CHECK(for Iksemel,lp_cv_has_iksemel,
for TESTPATH in "" "$iksemel_path" "$iksemel_path/include" "/usr/local/include" ; do
    saveflags="$CFLAGS"
    if test "x$TESTPATH" != "x"; then
        CFLAGS="$saveflags -I$TESTPATH"
    fi
AC_TRY_COMPILE([
#include <iksemel.h>

iks * foo(void)
{

    return (iks*)0;
}
],,
lp_cv_has_iksemel=yes
if test "x$TESTPATH" != "x"; then
    EXTRA_CFLAGS="-I$TESTPATH $EXTRA_CFLAGS"
fi
break;
,
lp_cv_has_iksemel=no
CFLAGS="$saveflags"
)
done
)

# The system has the include files - now search for the libraries.
if test $lp_cv_has_iksemel = yes; then
  saveflags="$CFLAGS"
  AC_DEFINE(HAS_IKSEMEL, 1, [Does the machine offer iksemel?])

  if test $enable_use_iksemel = yes; then
    tmp=""

    AC_CHECK_LIB(iksemel,main, tmp="$PKGLIBS -liksemel")

    if test "x$iksemel_path" == "x"; then
        unset ac_cv_lib_iksemel_main
        if test -d "${iksemel_path}/lib/iksemel"; then
            CFLAGS="$saveflags -L${iksemel_path}/lib/iksemel"
            AC_CHECK_LIB(iksemel,main, tmp="$PKGLIBS -L${iksemel_path}/lib/iksemel -liksemel")
        elif test -d "${iksemel_path}/lib"; then
            CFLAGS="$saveflags -L${iksemel_path}/lib"
            AC_CHECK_LIB(iksemel,main, tmp="$PKGLIBS -L${iksemel_path}/lib -liksemel")
        elif test -d "${iksemel_patch}"; then
            CFLAGS="$saveflags -L$iksemel_path"
            AC_CHECK_LIB(iksemel,main, tmp="$PKGLIBS -L$iksemel_path -liksemel")
        fi
    fi

    if test "x$tmp" == "x"; then
        unset ac_cv_lib_iksemel_main
        if test -d "/usr/local/lib"; then
            CFLAGS="$saveflags -L/usr/local/lib"
            AC_CHECK_LIB(iksemel,main, tmp="$PKGLIBS -L/usr/local/lib -liksemel")
        fi
    fi

    if test "x$tmp" == "x"; then
        echo "libiksemel library not found - disabling Iksemel support"
        AC_NOT_AVAILABLE(use-iksemel)
        cdef_use_iksemel="#undef"
        enable_use_iksemel="no"
        iksemel=
        lp_cv_has_iksemel="no"
    else
        PKGLIBS="$tmp"
    fi
  fi

  CFLAGS="$saveflags"
else
  if test $enable_use_iksemel = yes; then
      AC_NOT_AVAILABLE(use-iksemel)
      cdef_use_iksemel="#undef"
      enable_use_iksemel=no
  fi
fi

# --- JSON ---
cdef_enable_use_json="#undef"
AC_CHECK_HEADER(json/json.h,,[
		enable_use_json=no
		lp_cv_has_json=no
		])

# The system has the json include files - now search for the libraries.
if test "x$enable_use_json" = "x" || test "x$enable_use_json" = "xyes"; then
    AC_CHECK_LIB(json, main, [
		 AC_DEFINE(HAS_JSON, 1, [Does the machine offer json-c support?])
		 PKGLIBS="$PKGLIBS -ljson"
		 lp_cv_has_json=yes
		 cdef_use_json="#define"
		 ])
fi

# --- expat ---
cdef_enable_use_expat="#undef"
AC_CHECK_HEADER(expat.h,,[
		enable_use_expat=no
		lp_cv_has_expat=no
		])

# search for the libraries
if test "x$enable_use_expat" = "x" || test "x$enable_use_expat" = "xyes"; then
    AC_CHECK_LIB(expat, XML_ParserCreate, [
		 AC_DEFINE(HAS_EXPAT, 1, [Does the machine offer expat?])
		 PKGLIBS="$PKGLIBS -lexpat"
		 lp_cv_has_expat=yes
		 cdef_use_expat="#define"
		 ])
fi

# --- Check if we need zlib libraries for mccp ---

if test "x$enable_use_mccp" = "x" || test "x$enable_use_mccp" = "xyes"; then
    if test "$lp_cv_need_lib_z" != "yes"; then
        AC_CHECK_LIB(z,main,
                     PKGLIBS="$PKGLIBS -lz"
                     lp_cv_need_lib_z="yes"
        )
    fi
    if test "$lp_cv_need_lib_z" != "yes"; then
        echo "libz library not found - disabling MCCP support"
        AC_NOT_AVAILABLE(use-mccp)
        cdef_use_mccp="#undef"
        enable_use_mccp="no"
    fi
fi

# ---

AC_CACHE_CHECK(if rename handles directories,
lp_cv_sys_rename_handles_directories,
AC_TRY_RUN([
main() {
    mkdir("conftestdirfrom", 0770);
    exit(rename("conftestdirfrom", "conftestdirto"));
}
],
lp_cv_sys_rename_handles_directories=yes,
lp_cv_sys_rename_handles_directories=no))
if test $lp_cv_sys_rename_handles_directories = yes; then
  AC_DEFINE(RENAME_HANDLES_DIRECTORIES, 1, [Can rename handle directories?])
fi
rmdir conftestdirfrom conftestdirto 2> /dev/null

if test $ac_cv_func_getrusage = "yes" ; then
AC_CACHE_CHECK(full availability of struct rusage members,
lp_cv_struct_rusage_full,
AC_TRY_COMPILE([
#include <sys/types.h> /* BSDI 2.0.1 / 2.1 needs this for resource.h */
#include <sys/time.h>
#ifdef HAVE_SYS_RUSAGE_H
#include <sys/rusage.h>
#endif
#include <sys/resource.h>
#ifndef RUSAGE_SELF
#define RUSAGE_SELF     0
#endif
],[
    struct rusage rus;
    long *v = (long *)main;
    getrusage(RUSAGE_SELF, &rus);
    *v++ = rus.ru_maxrss;
    *v++ = rus.ru_ixrss;
    *v++ = rus.ru_idrss;
    *v++ = rus.ru_isrss;
    *v++ = rus.ru_minflt;
    *v++ = rus.ru_majflt;
    *v++ = rus.ru_nswap;
    *v++ = rus.ru_inblock;
    *v++ = rus.ru_oublock;
    *v++ = rus.ru_msgsnd;
    *v++ = rus.ru_msgrcv;
    *v++ = rus.ru_nsignals;
    *v++ = rus.ru_nvcsw;
    *v++ = rus.ru_nivcsw;
],lp_cv_struct_rusage_full=yes,lp_cv_struct_rusage_full=no))
if test $lp_cv_struct_rusage_full = no; then
  AC_DEFINE(GETRUSAGE_RESTRICTED, 1, [If so, is it restricted to user and system time?])
fi
AC_CACHE_CHECK(struct rusage timeval members with tv_usec,
lp_cv_struct_rusage_usec,
AC_TRY_COMPILE([
#include <sys/types.h> /* BSDI 2.0.1 / 2.1 needs this for resource.h */
#include <sys/time.h>
#ifdef HAVE_SYS_RUSAGE_H
#include <sys/rusage.h>
#endif
#include <sys/resource.h>
#ifndef RUSAGE_SELF
#define RUSAGE_SELF     0
#endif
],[
    struct rusage rus;
    long *v = (long *)main;
    getrusage(RUSAGE_SELF, &rus);
    *v++ = rus.ru_utime.tv_sec * 1000 + rus.ru_utime.tv_usec / 1000;
    *v++ = rus.ru_stime.tv_sec * 1000 + rus.ru_stime.tv_usec / 1000;
], lp_cv_struct_rusage_usec=yes, lp_cv_struct_rusage_usec=no))
if test $lp_cv_struct_rusage_usec = yes; then
  AC_DEFINE(RUSAGE_USEC, 1, [Can ru_utime / ru_stime be accessed as a timeval with tv_sec and tv_usec?])
fi
else
AC_CACHE_CHECK(for getrusage() via syscall(),
lp_cv_func_getrusage_via_syscall,
AC_TRY_COMPILE([
#include <sys/types.h> /* BSDI 2.0.1 / 2.1 needs this for resource.h */
#include <sys/syscall.h>
#include <sys/resource.h>
#ifndef RUSAGE_SELF
#define RUSAGE_SELF     0
#endif
],[
struct rusage rus;
syscall(SYS_GETRUSAGE, RUSAGE_SELF, rus);
], lp_cv_func_getrusage_via_syscall=yes, lp_cv_func_getrusage_via_syscall=no))
if test $lp_cv_func_getrusage_via_syscall=yes; then
  AC_DEFINE(HAVE_GETRUSAGE, 1, [Does the system have a getrusage call?])
  AC_DEFINE(GETRUSAGE_VIA_SYSCALL, 1, [Is it available as a subfunction of syscall()?])
fi
fi

dnl I have seen malloc() being declared in <memory.h> on some machines.
AC_CACHE_CHECK(if return type of free is void,
lp_cv_prop_free_returns_void,
AC_TRY_COMPILE([
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
#include <memory.h>
#endif
void free();
],, lp_cv_prop_free_returns_void=yes, lp_cv_prop_free_returns_void=no))
if test $lp_cv_prop_free_returns_void = yes; then
  AC_DEFINE(FREE_RETURNS_VOID, 1, [does free() have void as its returntype?])
fi

AC_CACHE_CHECK(if void* or char* from malloc,
lp_cv_prop_malloc_return_type,
AC_TRY_COMPILE([
#include <sys/types.h>
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
#include <memory.h>
#endif
#ifdef __STDC__
#define PROT(x) x
#else
#define PROT(x) ()
#endif
#define POINTER void *
POINTER malloc(size_t);
#ifdef FREE_RETURNS_VOID
void free PROT((POINTER));
#else
int free PROT((POINTER));
#endif
],,lp_cv_prop_malloc_return_type="void *",
lp_cv_prop_malloc_return_type="char *"))
AC_DEFINE_UNQUOTED(POINTER,$lp_cv_prop_malloc_return_type,[what kind of pointer is used by malloc() et al])

AC_CACHE_CHECK(if CHAR_BIT == 8 or undef,
lp_cv_prop_charbits_eq_8,
AC_TRY_COMPILE([
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <limits.h>
#ifdef HAVE_VALUES_H
#include <values.h>
#endif
int i=[1/(CHAR_BIT-8)];
],,lp_cv_prop_charbits_eq_8=no, lp_cv_prop_charbits_eq_8=yes))
if test $lp_cv_prop_charbits_eq_8 = yes; then
  AC_DEFINE(CHARBIT_MASK, 0xff, [A mask that allows to extract an unsigned char from a signed])
else
dnl TODO: this is something I don't really understand... am I too stupid?
dnl TODO:: bitmask set to number of bits ?????? *shudder* [Mubo]
  AC_DEFINE(CHARBIT_MASK, CHAR_BIT)
fi

AC_CACHE_CHECK(if strtol broken, lp_cv_prop_strtol_broken,
dnl the quoting hell wants two start quotes here, but only one end quote...
dnl M4 can be wonderful... :-(  [Mubo]
AC_TRY_RUN([[
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
int main() {
    if (strtol("1]", (char **)0, 10) != 1) exit(1);
    exit(0);
}
], lp_cv_prop_strtol_broken=no,
lp_cv_prop_strtol_broken=yes))
if test $lp_cv_prop_strtol_broken = yes; then
  AC_DEFINE(STRTOL_BROKEN, 1, [the atari strtol() used to consider characters '9' < c < 'A' to be numeric])
fi

dnl the following three tests would better be nested, but it seems to overflow
dnl internal buffers of m4
AC_CACHE_CHECK(nonblocking using ioctl with FIONBIO,
lp_cv_prop_use_ioctl_fionbio,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <sys/ioctl.h>
#include <stdio.h>
#include <stdlib.h>
main() {
    int port, tmp, s;
    struct sockaddr_in my_sin;
    struct hostent *hp;
    char *host_name;

    host_name = malloc(100);
    if (gethostname(host_name, 100) == -1) exit(1);
    hp = gethostbyname(host_name);
    if (hp == 0) exit(1);
    memset((char *)&my_sin, '\0', sizeof my_sin);
    memcpy((char *)&my_sin.sin_addr, hp->h_addr, hp->h_length);
    my_sin.sin_family = hp->h_addrtype;
    my_sin.sin_addr.s_addr = INADDR_ANY;
    alarm(10);
    for (port = 2000; port < 10000; port++) {
        my_sin.sin_port = htons((u_short)port);
        s = socket(hp->h_addrtype, SOCK_STREAM, 0);
        if (s == -1) exit(1);
        tmp = 1;
        if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR,
                        (char *) &tmp, sizeof (tmp)) < 0)
            exit (1);
        if (bind(s, (struct sockaddr *)&my_sin, sizeof my_sin) == -1) {
            if (errno == EADDRINUSE) {
                close(s);
		continue;
            }
            exit(1);
        }
	if (listen(s, 5) == -1) exit(1);
	tmp = 1;
	if (ioctl(s, FIONBIO, &tmp) == -1) exit(1);
        tmp = sizeof my_sin;
        s = accept(s, (struct sockaddr *)&my_sin, &tmp);
	if (s == -1) {
	    if (errno == EWOULDBLOCK ||
		errno == EAGAIN)
	    {
		/* hpux has special problems with sockets from pipe() */
		int sockets[[2]];
		FILE *fp_read;

		if(pipe(sockets) < 0)
		    exit(1);
		fp_read = fdopen(sockets[[0]], "r");
		if (fp_read == NULL)
		    exit(1);
		if (ioctl(fileno(fp_read) , FIONBIO, &tmp) == -1)
		    exit(1);
		exit(0);
	    }
	    if (errno == EINTR) { close(s); continue; }
	}
	break;
    }
    exit(1);
}
],
lp_cv_prop_use_ioctl_fionbio=yes,
lp_cv_prop_use_ioctl_fionbio=no,
lp_cv_prop_use_ioctl_fionbio=unknown
AC_MSG_WARN(You have to supply the correct way to set sockets non-blocking by hand.)
))
if test $lp_cv_prop_use_ioctl_fionbio = yes; then
  AC_DEFINE(USE_IOCTL_FIONBIO, 1, [How to set a socket non-blocking])
fi

AC_CACHE_CHECK(nonblocking using fcntl with O_NDELAY,
lp_cv_prop_use_fnctl_o_ndelay,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
main() {
    int port, tmp, s;
    struct sockaddr_in my_sin;
    struct hostent *hp;
    char *host_name;

    host_name = malloc(100);
    if (gethostname(host_name, 100) == -1) exit(1);
    hp = gethostbyname(host_name);
    if (hp == 0) exit(1);
    memset((char *)&my_sin, '\0', sizeof my_sin);
    memcpy((char *)&my_sin.sin_addr, hp->h_addr, hp->h_length);
    my_sin.sin_family = hp->h_addrtype;
    my_sin.sin_addr.s_addr = INADDR_ANY;
    alarm(10);
    for (port = 2000; port < 10000; port++) {
        my_sin.sin_port = htons((u_short)port);
        s = socket(hp->h_addrtype, SOCK_STREAM, 0);
        if (s == -1) exit(1);
        tmp = 1;
        if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR,
                        (char *) &tmp, sizeof (tmp)) < 0)
            exit (1);
        if (bind(s, (struct sockaddr *)&my_sin, sizeof my_sin) == -1) {
            if (errno == EADDRINUSE) {
                close(s);
		continue;
            }
            exit(1);
        }
	if (listen(s, 5) == -1) exit(1);
	if (fcntl(s, F_SETFL, O_NDELAY) == -1) exit(1);
        tmp = sizeof my_sin;
        s = accept(s, (struct sockaddr *)&my_sin, &tmp);
	if (s == -1) {
	    if (errno == EWOULDBLOCK) exit(0);
	    if (errno == EAGAIN) exit(0);
	    if (errno == EINTR) { close(s); continue; }
	}
	break;
    }
    exit(1);
}
], lp_cv_prop_use_fnctl_o_ndelay=yes,
lp_cv_prop_use_fnctl_o_ndelay=no,
lp_cv_prop_use_fnctl_o_ndelay=unknown))
if test $lp_cv_prop_use_fnctl_o_ndelay = yes; then
  AC_DEFINE(USE_FCNTL_O_NDELAY, 1, [nonblocking using fcntl with O_NDELAY])
fi

AC_CACHE_CHECK(nonblocking using fcntl with FNDELAY,
lp_cv_prop_use_fcntl_fndelay,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
main() {
    int port, tmp, s;
    struct sockaddr_in my_sin;
    struct hostent *hp;
    char *host_name;

    host_name = malloc(100);
    if (gethostname(host_name, 100) == -1) exit(1);
    hp = gethostbyname(host_name);
    if (hp == 0) exit(1);
    memset((char *)&my_sin, '\0', sizeof my_sin);
    memcpy((char *)&my_sin.sin_addr, hp->h_addr, hp->h_length);
    my_sin.sin_family = hp->h_addrtype;
    my_sin.sin_addr.s_addr = INADDR_ANY;
    alarm(10);
    for (port = 2000; port < 10000; port++) {
        my_sin.sin_port = htons((u_short)port);
        s = socket(hp->h_addrtype, SOCK_STREAM, 0);
        if (s == -1) exit(1);
        tmp = 1;
        if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR,
                        (char *) &tmp, sizeof (tmp)) < 0)
            exit (1);
        if (bind(s, (struct sockaddr *)&my_sin, sizeof my_sin) == -1) {
            if (errno == EADDRINUSE) {
                close(s);
		continue;
            }
            exit(1);
        }
	if (listen(s, 5) == -1) exit(1);
	if (fcntl(s, F_SETFL, FNDELAY) == -1) exit(1);
        tmp = sizeof my_sin;
        s = accept(s, (struct sockaddr *)&my_sin, &tmp);
	if (s == -1) {
	    if (errno == EWOULDBLOCK) exit(0);
	    if (errno == EAGAIN) exit(0);
	    if (errno == EINTR) { close(s); continue; }
	}
	break;
    }
    exit(1);
}
],lp_cv_prop_use_fcntl_fndelay=yes,
lp_cv_prop_use_fcntl_fndelay=no,
lp_cv_prop_use_fcntl_fndelay=unknown))
if test $lp_cv_prop_use_fcntl_fndelay = yes; then
  AC_DEFINE(USE_FCNTL_FNDELAY, 1, [nonblocking using fcntl with FNDELAY])
fi


AC_CACHE_CHECK(if fcntl with SETOWN works,
lp_cv_prop_use_fcntl_setown,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
main() {
    int port, tmp, s;
    struct sockaddr_in my_sin;
    struct hostent *hp;
    char *host_name;

    host_name = malloc(100);
    if (gethostname(host_name, 100) == -1) exit(1);
    hp = gethostbyname(host_name);
    if (hp == 0) exit(1);
    memset((char *)&my_sin, '\0', sizeof my_sin);
    memcpy((char *)&my_sin.sin_addr, hp->h_addr, hp->h_length);
    my_sin.sin_family = hp->h_addrtype;
    my_sin.sin_addr.s_addr = INADDR_ANY;
    alarm(10);
    for (port = 2000; port < 10000; port++) {
        my_sin.sin_port = htons((u_short)port);
        s = socket(hp->h_addrtype, SOCK_STREAM, 0);
        if (s == -1) exit(1);
        tmp = 1;
        if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR,
                        (char *) &tmp, sizeof (tmp)) < 0)
            exit (1);
        if (bind(s, (struct sockaddr *)&my_sin, sizeof my_sin) == -1) {
            if (errno == EADDRINUSE) {
                close(s);
		continue;
            }
            exit(1);
        }
	if (listen(s, 5) == -1) exit(1);
#ifndef F_SETOWN
        exit(1);
#else
	if (fcntl(s, F_SETOWN, getpid()) == -1) exit(1);
        exit(0);
#endif
    }
    exit(1);
}
],lp_cv_prop_use_fcntl_setown=yes,
lp_cv_prop_use_fcntl_setown=no,
lp_cv_prop_use_fcntl_setown=unknown))
if test $lp_cv_prop_use_fcntl_setown = yes; then
  AC_DEFINE(USE_FCNTL_SETOWN, 1, [Can F_SETOWN be used on a socket?])
fi

AC_CACHE_CHECK(if OOBINLINE works,
lp_cv_prop_use_oobinline,
AC_TRY_RUN([
#include <sys/types.h> /* needed for netinet/in.h */
#include <sys/socket.h>
#include <netinet/in.h>
#include <netdb.h>
#include <errno.h>
#include <fcntl.h>
#include <stdlib.h>
main() {
    int port, tmp, s;
    struct sockaddr_in my_sin;
    struct hostent *hp;
    char *host_name;

    host_name = malloc(100);
    if (gethostname(host_name, 100) == -1) exit(1);
    hp = gethostbyname(host_name);
    if (hp == 0) exit(1);
    memset((char *)&my_sin, '\0', sizeof my_sin);
    memcpy((char *)&my_sin.sin_addr, hp->h_addr, hp->h_length);
    my_sin.sin_family = hp->h_addrtype;
    my_sin.sin_addr.s_addr = INADDR_ANY;
    alarm(10);
    for (port = 2000; port < 10000; port++) {
        int on;
        my_sin.sin_port = htons((u_short)port);
        s = socket(hp->h_addrtype, SOCK_STREAM, 0);
        if (s == -1) exit(1);
        tmp = 1;
        if (setsockopt (s, SOL_SOCKET, SO_REUSEADDR,
                        (char *) &tmp, sizeof (tmp)) < 0)
            exit (1);
        if (bind(s, (struct sockaddr *)&my_sin, sizeof my_sin) == -1) {
            if (errno == EADDRINUSE) {
                close(s);
		continue;
            }
            exit(1);
        }
	if (listen(s, 5) == -1) exit(1);
#ifndef SO_OOBINLINE
        exit(1);
#else
        on = 1;
        if (setsockopt(s, SOL_SOCKET, SO_OOBINLINE, (char *)&on, sizeof on) == -1)
            exit(1);
        exit(0);
#endif
    }
    exit(1);
}
],lp_cv_prop_use_oobinline=yes,
lp_cv_prop_use_oobinline=no,
lp_cv_prop_use_oobinline=unknown))
if test $lp_cv_prop_use_oobinline = yes; then
  AC_DEFINE(USE_OOBINLINE, 1, [Can SO_OOBINLINE be used on a socket?])
fi


AC_CACHE_CHECK(for overlapping bcopy,
lp_cv_prop_overlapping_bcopy,
AC_TRY_RUN([
main(){
    char str[[99]] = "hello world";
    bcopy(str, str+2, 12);
    if(strcmp("hehello world", str))
	exit(1);
    bcopy(str+2, str, 11);
    if(strcmp("hello worldld", str))
	exit(1);
    exit(0);
}
], lp_cv_prop_overlapping_bcopy=yes,
lp_cv_prop_overlapping_bcopy=no,
lp_cv_prop_overlapping_bcopy=yes))
if test $lp_cv_prop_overlapping_bcopy = yes; then
  AC_DEFINE(OVERLAPPING_BCOPY, 1, [Define if you have bcopy, and it handles overlapping ranges correctly.])
fi

AC_CACHE_CHECK(if strtol needs const char*,
lp_cv_prop_strtol_const_charp,
AC_TRY_COMPILE([#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
long strtol(str, ptr, base) char *str; char **ptr; int base; { return 0; }
],,lp_cv_prop_strtol_const_charp=no,
lp_cv_prop_strtol_const_charp=yes))
if test $lp_cv_prop_strtol_const_charp = yes; then
  AC_DEFINE(STRTOL_CONST_CHARP, 1, [needs the first argument of strtol be declared as const?])
fi

# --- Check for compiler options ---

tcomp='${CC-cc} ${CFLAGS} ${TESTFLAG} -o conftest conftest.c >/dev/null 2>&1'
tcomp2='${CC-cc} ${CFLAGS} ${TESTFLAG} -o conftest conftest.c 2>&1'
tcomp3='${CC-cc} ${CFLAGS} ${TESTFLAG} -c conftest.c >/dev/null 2>&1'

cat > conftest.c <<EOF
#include <stdio.h>
#include <math.h>
double d = 4.5;
int main(void) { printf("hello world\n"); return 0; }
EOF

AC_MSG_CHECKING(warning CFLAGS)
changequote(,)dnl
CFLAGS=

# according to https://gcc.gnu.org/bugzilla/show_bug.cgi?id=25509
# excess complaints by -Wwarn_unused_result are considered a feature,
# not a bug. i think, casting to (void) must not be ignored. so we
# are forced to turn off that gcc warning.	--lynX 2016
#
for TESTFLAG in -Wall -Wno-unused-result -Wparentheses -Wshadow; do
  if eval $tcomp; then
    # The option is recognized, but if it generates warnings on the
    # above correct program, we still can't use it. So check for that.
    if echo `eval $tcomp2` | egrep '[a-z]' >/dev/null; then
      :
      # Success means 'we got output' here :-(
    else
        CFLAGS="$CFLAGS $TESTFLAG"
    fi
  fi
done
changequote([,])dnl
WCFLAGS=$CFLAGS
AC_MSG_RESULT($WCFLAGS)

AC_MSG_CHECKING(low optimization CFLAGS)
changequote(,)dnl
for TESTFLAG in -O; do
  if eval $tcomp; then
    if echo `eval $tcomp2` | egrep '[uU]n(recognized|known) [oO]ption' >/dev/null; then
      :
      #the [e]grep option -v will not give a failure exit status on the atari
    else
      if eval $tcomp; then
        CFLAGS=$TESTFLAG
        break
      fi
    fi
  fi
done
changequote([,])dnl
for TESTFLAG in -g; do
  if eval $tcomp; then
    CFLAGS="$CFLAGS $TESTFLAG"
  fi
done
LCFLAGS=$CFLAGS
AC_MSG_RESULT($LCFLAGS)

AC_MSG_CHECKING(medium optimization CFLAGS)
changequote(,)dnl
for TESTFLAG in -O2 -O; do
  if eval $tcomp; then
    if echo `eval $tcomp2` | egrep '[uU]n(recognized|known) [oO]ption' >/dev/null; then
      :
      #the [e]grep option -v will not give a failure exit status on the atari
    else
      if eval $tcomp; then
        CFLAGS=$TESTFLAG
        break
      fi
    fi
  fi
done
for TESTFLAG in -g; do
  if eval $tcomp; then
    OPTFLAGS="$OPTFLAGS $TESTFLAG"
    CFLAGS="$CFLAGS $TESTFLAG"
  fi
done
changequote([,])dnl
MCFLAGS=$CFLAGS
AC_MSG_RESULT($MCFLAGS)

AC_MSG_CHECKING(highest optimization CFLAGS)
changequote(,)dnl
for TESTFLAG in -O4 -O3 -O2 -O; do
  if eval $tcomp; then
    if echo `eval $tcomp2` | egrep '[uU]n(recognized|known) [oO]ption' >/dev/null; then
      :
      #the [e]grep option -v will not give a failure exit status on the atari
    else
      if eval $tcomp; then
        CFLAGS=$TESTFLAG
        break
      fi
    fi
  fi
done
if test "$ac_cv_c_compiler_gnu" = "no"; then
  for TESTFLAG in -qstrict -qipa -ipo; do
    if eval $tcomp; then
      if echo `eval $tcomp2` | egrep '[uU]n(recognized|known) [oO]ption' >/dev/null; then
        :
        #the [e]grep option -v will not give a failure exit status on the atari
      else
        if eval $tcomp; then
          CFLAGS="$CFLAGS $TESTFLAG"
          break
        fi
      fi
    fi
  done
fi
changequote([,])dnl
# -funroll-all-loops causes some versions of gcc to produce buggy code
for TESTFLAG in -fomit-frame-pointer; do
  if eval $tcomp; then
    CFLAGS="$CFLAGS $TESTFLAG"
  fi
done
OCFLAGS="$CFLAGS $OPTFLAGS"
AC_MSG_RESULT($OCFLAGS)
if ${CC-cc} -g -c conftest.c ; then
  DCFLAGS='-g'
else
  DCFLAGS=''
fi
OPTIMIZE_LINKING=''
if ${CC-cc} $OFLAGS -o conftest conftest.c ; then
  OPTIMIZE_LINKING='$(OPTIMIZE)'
fi

rm -f conftest.c

if test $ac_cv_lib_socket_main = "yes"; then
AC_EGREP_CPP(yes,[
#if defined(sun)
yes
#endif
],
[ EXTRA_CFLAGS="${EXTRA_CFLAGS} -Dsolaris" ])
fi

AC_ARG_WITH(target,[  --with-target    ??], EXTRA_CFLAGS="${EXTRA_CFLAGS} -D${withval}")

# Some Unixes require the -n parameter for tail to work properly
AC_MSG_CHECKING(if tail accepts the -n parameter)
TAIL_N=""
if tail -n +2 confdefs.h > /dev/null 2>&1; then
    AC_MSG_RESULT(yes)
    TAIL_N="-n"
else
    AC_MSG_RESULT(no)
fi

AC_MSG_CHECKING(if ${YACC} includes bogus malloc prototypes)
cat > conftest.y <<EOF
%{
#include "confdefs.h"
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
#include <memory.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
%}
%%
all: 'a';
%%
int main(){ return 0; }
int yyerror(){}
int yylex(){ return 0; }
EOF
rm -f y.tab.c y_tab.c
${YACC} conftest.y
if mv y.tab.c conftest.c > /dev/null 2>&1; then
  YACCTAB=y.tab.
else
  mv y_tab.c conftest.c
  YACCTAB=y_tab.
fi
if eval $ac_compile 2>&5; then
  MOVE_YACC_TAB='$(MV) $(YACCTAB)c'
  CLEAN_YACC_TAB=''
  AC_MSG_RESULT(no)
else
  MOVE_YACC_TAB='tail $TAIL_N +2 $(YACCTAB)c >'
  CLEAN_YACC_TAB='$(RM) $(YACCTAB)c'
  AC_MSG_RESULT(yes)
fi
rm -f conftest*

AC_MSG_CHECKING(for ${YACC} / <malloc.h> / -DSGI_SOURCE / afree name clash)
cat > conftest.y <<EOF
%{
#include "confdefs.h"
#define afree free
%}
%%
all: 'a';
%%
int main(){ return 0; }
int yyerror(){}
int yylex(){ return 0; }
EOF
rm -f y.tab.c y_tab.c
${YACC} conftest.y
if mv y.tab.c conftest.c > /dev/null 2>&1; then
  YACCTAB=y.tab.
else
  mv y_tab.c conftest.c
  YACCTAB=y_tab.
fi
if eval $ac_compile 2>&5 ; then
  AC_MSG_RESULT(no)
else
  EXTRA_CFLAGS="${EXTRA_CFLAGS} -U_SGI_SOURCE"
  AC_MSG_RESULT(yes)
fi
rm -f conftest*


SAVE_LIBS="${LIBS}"
SAVE_CFLAGS="${CFLAGS}"
CFLAGS=''
for TESTFLAG in '' -static -Bstatic -n; do


AC_MSG_CHECKING(malloc redefinition with linking flag ${TESTFLAG})
LIBS="${SAVE_LIBS} ${TESTFLAG}"
cat > conftest.data <<EOF
42
EOF
AC_TRY_RUN([
#include <sys/types.h>
#include <stdio.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STDLIB_H
#include <stdlib.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#else
#include <strings.h>
#endif
#if !defined(STDC_HEADERS) && defined(HAVE_MEMORY_H)
#include <memory.h>
#endif
#undef malloc
#undef calloc
int my_malloc_used;
int main() {
    int i, j;
    FILE *f;

    alarm(10); /* a crash can be an infinite loop... */
    for (i = 0; i < 100; i++) {
	my_malloc_used = 0;
	/* strdup seems to be partially unavailable */
	f = fopen("conftest.data", "r");
	fscanf(f, "%d", &j);
	fclose(f);
	if (!my_malloc_used || j != 6*7) exit(1);
    }
    /* linking in printf called with variable format makes shared libs
     * worthwhile. Moreover, calling it is a good test
     */
    printf(f?"%f%% successful\n":(char*)f, 100.);
    exit(0);
}
POINTER malloc(size)
    size_t size;
{
    size_t size2;
    static char *current_break = 0;
    char *q;

    my_malloc_used = 1;
    if (!current_break)
      current_break = sbrk(0);
    size2 = sizeof size + size+7 & ~7;
    q = current_break;
    if (brk(current_break+=size2)) exit(1);
    *(size_t *)q = size;
    return q + sizeof size;
}
POINTER calloc(size, num)
    size_t size, num;
{
    char *q;
    q = malloc(size*num);
    memset(q, 0, size);
}
POINTER realloc(p, size)
    POINTER p;
    size_t size;
{
    char *q;
    if (*(size_t *)p >= size)
        return p;
    q = malloc(size);
#ifdef HAVE_MEMCPY
    memcpy(q, p, size);
#else
    bcopy(p, q, size);
#endif
    *(size_t *)q = size;
    return q + sizeof size;
}
#ifdef FREE_RETURNS_VOID
void free(p)
    POINTER p;
{}
#else
int free(p)
    POINTER p;
{ return 1; }
#endif
],SBRK_OK=1)
if test -n "${SBRK_OK}"; then
  if test -z "${TESTFLAG}"; then
    AC_DEFINE(SBRK_OK, 1, [can we define our own malloc() safely?])
  else
    LDFLAGS="${LDFLAGS} ${TESTFLAG}"
    EXTRA_CFLAGS="${EXTRA_CFLAGS} -DSBRK_OK"
  fi
  break
  AC_MSG_RESULT(ok)
else
  AC_MSG_RESULT(failed)
fi
done

LIBS="${SAVE_LIBS}"
CFLAGS="${SAVE_CFLAGS}"

case "$EXTRA_CFLAGS" in
 *-Dsolaris*)
  if test $ac_cv_lib_ucb_main = "yes"; then
      LIBS="${LDFLAGS} -lm -lgcc -lc -lnsl -lgcc -lc -ldl_stubs\
        -lnswnis -lnswnisplus -lnswfiles -lnswcompat -lstraddr -lswitch\
        -ltcpip -lsocket -lnsl -lgcc -lc /usr/ucblib/libucb.a"
      LDFLAGS= "-u dgettext -lintl"
  fi ;;
 *-DOS2*)
      LDFLAGS= "$LDFLAGS -Zbsd-signals -Zexe"
      ;;
 *-MSWIN*)
      LDFLAGS= "$LDFLAGS -luser32 -lwinmm -lkernel32 -lwsock32"
      ;;
esac

AC_CACHE_CHECK(malloc overhead,lp_cv_sys_malloc_overhead,
cat > conftest.c <<EOF
#include "confdefs.h"
#include "${srcdir}/util/overhead.c"
EOF
${CC-cc} -o conftest conftest.c
lp_cv_sys_malloc_overhead=`./conftest --terse`
rm -f conftest*
)
AC_DEFINE_UNQUOTED(EXTERN_MALLOC_OVERHEAD,$lp_cv_sys_malloc_overhead,                                                                                                                                              
    [The following is needed for smalloc without SBRK_OK to use memory                                                                                                                                             
     efficiently. smalloc will malloc blocks that are a large power of                                                                                                                                             
     two, minus EXTERN_MALLOC_OVERHEAD. If you have no idea what number to                                                                                                                                         
     choose, compile & run util/overhead.c                                                                                                                                                                         
    ])                                                                                                                                                                                                             

PROGNAME=psyclpc

if test -z "${CONFIG_SHELL}"; then
  CONFIG_SHELL='/bin/sh'
fi
if test "${OSTYPE}" = 'win32'; then
  EXEEXT='.exe'
  AC_DEFINE(HOST_INCLUDE,"hosts/GnuWin32/GnuWin32.h",[define the host-specific include file])
fi


dnl
dnl --- Postprocessing of settings ---
dnl

AC_UPDATE_VAR(with_malloc)
if test "x$with_malloc" = "x" || test "x$with_malloc" = "xdefault"; then
    with_malloc="sysmalloc"
    AC_TEXT_VAL_FROM_WITH(malloc)
fi


dnl
dnl Standard Replacements:
dnl

AC_SUBST(val_optimize)
AC_SUBST(WCFLAGS)
AC_SUBST(OCFLAGS)
AC_SUBST(LCFLAGS)
AC_SUBST(MCFLAGS)
AC_SUBST(DCFLAGS)
AC_SUBST(LDFLAGS)
AC_SUBST(EXTRA_CFLAGS)
AC_SUBST(OPTIMIZE_LINKING)
AC_SUBST(MOVE_YACC_TAB)
AC_SUBST(CLEAN_YACC_TAB)
AC_SUBST(YACCTAB)
AC_SUBST(CONFIG_SHELL)
AC_SUBST(EXEEXT)
AC_SUBST(PROGNAME)

dnl
dnl additional replacements:
dnl

dnl first: the conditional defines:
dnl
AC_SUBST(cdef_erq_demon)
AC_SUBST(cdef_access_control)
AC_SUBST(cdef_access_log)
AC_SUBST(cdef_compat_mode)
AC_SUBST(cdef_strict_euids)
AC_SUBST(cdef_filename_spaces)
AC_SUBST(cdef_share_variables)
AC_SUBST(cdef_use_system_crypt)
AC_SUBST(cdef_use_ipv6)
AC_SUBST(cdef_use_mysql)
AC_SUBST(cdef_use_pgsql)
AC_SUBST(cdef_use_sqlite)
AC_SUBST(cdef_use_iksemel)
AC_SUBST(cdef_use_pthreads)
AC_SUBST(cdef_use_alists)
AC_SUBST(cdef_use_psyc)
AC_SUBST(cdef_use_mccp)
AC_SUBST(cdef_use_pcre)
AC_SUBST(cdef_use_deprecated)
AC_SUBST(cdef_use_structs)
AC_SUBST(cdef_use_tls)
AC_SUBST(cdef_use_new_inlines)
AC_SUBST(cdef_use_set_light)
AC_SUBST(cdef_use_set_is_wizard)
AC_SUBST(cdef_use_parse_command)
AC_SUBST(cdef_use_process_string)
AC_SUBST(cdef_lpc_array_calls)
AC_SUBST(cdef_comm_stat)
AC_SUBST(cdef_trace_code)
AC_SUBST(cdef_apply_cache_stat)
AC_SUBST(cdef_malloc_sbrk)
AC_SUBST(cdef_malloc_check)
AC_SUBST(cdef_malloc_trace)
AC_SUBST(cdef_malloc_lpc_trace)
AC_SUBST(cdef_malloc_sbrk_trace)
AC_SUBST(cdef_dynamic_costs)
AC_SUBST(cdef_eval_cost_trace)

AC_SUBST(cdef_rxcache_table)
AC_SUBST(cdef_wizlist_file)
AC_SUBST(cdef_synchronous_heart_beat)

AC_SUBST(cdef_opcprof)
AC_SUBST(cdef_verbose_opcprof)
AC_SUBST(cdef_debug)
AC_SUBST(cdef_yydebug)
AC_SUBST(cdef_no_inlines)
AC_SUBST(cdef_debug_telnet)
AC_SUBST(cdef_debug_malloc_allocs)

AC_SUBST(cdef_check_object_stat)
AC_SUBST(cdef_check_mapping_total)
AC_SUBST(cdef_check_object_ref)
AC_SUBST(cdef_check_object_gc_ref)
AC_SUBST(cdef_dump_gc_refs)

# psyclpc extensions
AC_SUBST(cdef_use_authlocal)
AC_SUBST(cdef_use_json)
AC_SUBST(cdef_use_expat)
AC_SUBST(cdef_use_srv)
#AC_SUBST(cdef_backtrace_always)
AC_SUBST(cdef_use_actions)
AC_SUBST(cdef_use_builtin_editor)
AC_SUBST(cdef_use_debug_log)
AC_SUBST(cdef_use_experimental)
AC_SUBST(cdef_use_inventories)
AC_SUBST(cdef_use_ldmud_compatibility)
AC_SUBST(cdef_use_paranoia)
AC_SUBST(cdef_use_restored_objects)
AC_SUBST(cdef_use_shadowing)
AC_SUBST(cdef_use_snooping)
AC_SUBST(cdef_use_socket_limits)
AC_SUBST(cdef_use_swap)

dnl second: valued defines
dnl
AC_SUBST(val_access_file)
AC_SUBST(val_access_log)
AC_SUBST(val_erq_max_reply)
AC_SUBST(val_erq_max_send)
AC_SUBST(val_erq_debug)
AC_SUBST(val_pthreads_write_max_size)
AC_SUBST(val_read_file_max_size)
AC_SUBST(val_time_to_clean_up)
AC_SUBST(val_time_to_swap)
AC_SUBST(val_time_to_swap_variables)
AC_SUBST(val_time_to_reset)
AC_SUBST(val_alarm_time)
AC_SUBST(val_heart_beat_interval)
AC_SUBST(val_evaluator_stack_size)
AC_SUBST(val_max_user_trace)
AC_SUBST(val_max_trace)
AC_SUBST(val_compiler_stack_size)
AC_SUBST(val_max_bits)
AC_SUBST(val_portno)
AC_SUBST(val_maxnumports)
AC_SUBST(val_max_net_connects)
AC_SUBST(val_size_socket_buffer)
AC_SUBST(val_max_cost)
AC_SUBST(val_max_local)
AC_SUBST(val_catch_reserved_cost)
AC_SUBST(val_master_reserved_cost)
AC_SUBST(val_swap_file)
AC_SUBST(val_max_array_size)
AC_SUBST(val_max_mapping_keys)
AC_SUBST(val_max_mapping_size)
AC_SUBST(val_max_callouts)
AC_SUBST(val_max_players)
AC_SUBST(val_allowed_ed_cmds)
AC_SUBST(val_reserved_user_size)
AC_SUBST(val_reserved_master_size)
AC_SUBST(val_reserved_system_size)
AC_SUBST(val_htable_size)
AC_SUBST(val_itable_size)
AC_SUBST(val_otable_size)
AC_SUBST(val_defmax)
AC_SUBST(val_apply_cache_bits)
AC_SUBST(val_rxcache_table)
AC_SUBST(val_master_name)
AC_SUBST(val_input_escape)
AC_SUBST(val_max_byte_transfer)
AC_SUBST(val_udp_port)
AC_SUBST(val_set_buffer_size_max)
AC_SUBST(val_malloc)
AC_SUBST(val_min_malloced)
AC_SUBST(val_min_small_malloced)
AC_SUBST(val_max_malloced)
AC_SUBST(val_total_trace_length)
AC_SUBST(val_wizlist_file)
AC_SUBST(val_pcre_recursion_limit)
AC_SUBST(val_max_net_connects)
AC_SUBST(val_random_period_length)

dnl finally: some remaining stuff
dnl
AC_SUBST(erq_sub)
AC_SUBST(PKGLIBS)
AC_SUBST(ERQ_LIBS)

dnl
dnl Ok. now lets make the Makefiles; also these in subdirs! [Mubo]
dnl make config.h, too. [Mubo]
dnl
AC_OUTPUT(Makefile config.h util/Makefile util/erq/Makefile)
dnl util/xerq/Makefile util/indent/Makefile

dnl
dnl At last, warn if any feature could not be enabled
dnl
if test "x$not_available" != "x"; then
    echo ""
    echo "WARNING: The following options were disabled because the system"
    echo "lacked the necessary support: $not_available."
    exit 1
fi