/src/configure.in

https://bitbucket.org/ultra_iter/vim-qt · Autoconf · 3806 lines · 2900 code · 341 blank · 565 comment · 519 complexity · 3055817faa3ce25a05873cf8685f5136 MD5 · raw file

Large files are truncated click here to view the full file

    

  1. dnl configure.in: autoconf script for Vim
    2. 

  2. 

  3. dnl Process this file with autoconf 2.12 or 2.13 to produce "configure".
    4. 

  4. dnl Should also work with autoconf 2.54 and later.
    5. 

  5. 

  6. AC_INIT(vim.h)
    7. 

  7. AC_CONFIG_HEADER(auto/config.h:config.h.in)
    8. 

  8. 

  9. dnl Being able to run configure means the system is Unix (compatible).
    10. 

  10. AC_DEFINE(UNIX)
    11. 

  11. AC_PROG_MAKE_SET
    12. 

  12. 

  13. dnl Checks for programs.
    14. 

  14. AC_PROG_CC	dnl required by almost everything
    15. 

  15. AC_PROG_CPP	dnl required by header file checks
    16. 

  16. AC_PROGRAM_EGREP dnl required by AC_EGREP_CPP
    17. 

  17. AC_ISC_POSIX	dnl required by AC_C_CROSS
    18. 

  18. AC_PROG_AWK	dnl required for "make html" in ../doc
    19. 

  19. 

  20. dnl Don't strip if we don't have it
    21. 

  21. AC_CHECK_PROG(STRIP, strip, strip, :)
    22. 

  22. 

  23. dnl Check for extension of executables
    24. 

  24. AC_EXEEXT
    25. 

  25. 

  26. dnl Check for standard headers.  We don't use this in Vim but other stuff
    27. 

  27. dnl in autoconf needs it, where it uses STDC_HEADERS.
    28. 

  28. AC_HEADER_STDC
    29. 

  29. AC_HEADER_SYS_WAIT
    30. 

  30. 

  31. dnl Check for the flag that fails if stuff are missing.
    32. 

  32. 

  33. AC_MSG_CHECKING(--enable-fail-if-missing argument)
    34. 

  34. AC_ARG_ENABLE(fail_if_missing,
    35. 

  35. 	[  --enable-fail-if-missing    Fail if dependencies on additional features
    36. 

  36.      specified on the command line are missing.], 
    37. 

  37. 	[fail_if_missing="yes"],
    38. 

  38. 	[fail_if_missing="no"])
    39. 

  39. AC_MSG_RESULT($fail_if_missing)
    40. 

  40. 

  41. dnl Set default value for CFLAGS if none is defined or it's empty
    42. 

  42. if test -z "$CFLAGS"; then
    43. 

  43.   CFLAGS="-O"
    44. 

  44.   test "$GCC" = yes && CFLAGS="-O2 -fno-strength-reduce -Wall"
    45. 

  45. fi
    46. 

  46. if test "$GCC" = yes; then
    47. 

  47.   dnl method that should work for nearly all versions
    48. 

  48.   gccversion=`"$CC" -dumpversion`
    49. 

  49.   if test "x$gccversion" = "x"; then
    50. 

  50.     dnl old method; fall-back for when -dumpversion doesn't work
    51. 

  51.     gccversion=`"$CC" --version | sed -e '2,$d' -e 's/darwin.//' -e 's/^[[^0-9]]*\([[0-9]]\.[[0-9.]]*\).*$/\1/g'`
    52. 

  52.   fi
    53. 

  53.   dnl version 4.0.1 was reported to cause trouble on Macintosh by Marcin Dalecki
    54. 

  54.   if test "$gccversion" = "3.0.1" -o "$gccversion" = "3.0.2" -o "$gccversion" = "4.0.1"; then
    55. 

  55.     echo 'GCC [[34]].0.[[12]] has a bug in the optimizer, disabling "-O#"'
    56. 

  56.     CFLAGS=`echo "$CFLAGS" | sed 's/-O[[23456789]]/-O/'`
    57. 

  57.   else
    58. 

  58.     if test "$gccversion" = "3.1" -o "$gccversion" = "3.2" -o "$gccversion" = "3.2.1" && `echo "$CFLAGS" | grep -v fno-strength-reduce >/dev/null`; then
    59. 

  59.       echo 'GCC 3.1 and 3.2 have a bug in the optimizer, adding "-fno-strength-reduce"'
    60. 

  60.       CFLAGS="$CFLAGS -fno-strength-reduce"
    61. 

  61.     fi
    62. 

  62.   fi
    63. 

  63. fi
    64. 

  64. 

  65. dnl If configure thinks we are cross compiling, there might be something
    66. 

  66. dnl wrong with the CC or CFLAGS settings, give a useful warning message
    67. 

  67. if test "$cross_compiling" = yes; then
    68. 

  68.   AC_MSG_RESULT([cannot compile a simple program; if not cross compiling check CC and CFLAGS])
    69. 

  69. fi
    70. 

  70. 

  71. dnl gcc-cpp has the wonderful -MM option to produce nicer dependencies.
    72. 

  72. dnl But gcc 3.1 changed the meaning!  See near the end.
    73. 

  73. test "$GCC" = yes && CPP_MM=M; AC_SUBST(CPP_MM)
    74. 

  74. 

  75. if test -f ./toolcheck; then
    76. 

  76.   AC_CHECKING(for buggy tools)
    77. 

  77.   sh ./toolcheck 1>&AC_FD_MSG
    78. 

  78. fi
    79. 

  79. 

  80. OS_EXTRA_SRC=""; OS_EXTRA_OBJ=""
    81. 

  81. 

  82. dnl Check for BeOS, which needs an extra source file
    83. 

  83. AC_MSG_CHECKING(for BeOS)
    84. 

  84. case `uname` in
    85. 

  85.     BeOS)	OS_EXTRA_SRC=os_beos.c; OS_EXTRA_OBJ=objects/os_beos.o
    86. 

  86. 		BEOS=yes; AC_MSG_RESULT(yes);;
    87. 

  87.     *)		BEOS=no; AC_MSG_RESULT(no);;
    88. 

  88. esac
    89. 

  89. 

  90. dnl If QNX is found, assume we don't want to use Xphoton
    91. 

  91. dnl unless it was specifically asked for (--with-x)
    92. 

  92. AC_MSG_CHECKING(for QNX)
    93. 

  93. case `uname` in
    94. 

  94.     QNX)	OS_EXTRA_SRC=os_qnx.c; OS_EXTRA_OBJ=objects/os_qnx.o
    95. 

  95. 		test -z "$with_x" && with_x=no
    96. 

  96. 		QNX=yes; AC_MSG_RESULT(yes);;
    97. 

  97.     *)		QNX=no; AC_MSG_RESULT(no);;
    98. 

  98. esac
    99. 

  99. 

  100. dnl Check for Darwin and MacOS X
    101. 

  101. dnl We do a check for MacOS X in the very beginning because there
    102. 

  102. dnl are a lot of other things we need to change besides GUI stuff
    103. 

  103. AC_MSG_CHECKING([for Darwin (Mac OS X)])
    104. 

  104. if test "`(uname) 2>/dev/null`" = Darwin; then
    105. 

  105.   AC_MSG_RESULT(yes)
    106. 

  106. 

  107.   AC_MSG_CHECKING(--disable-darwin argument)
    108. 

  108.   AC_ARG_ENABLE(darwin,
    109. 

  109. 	  [  --disable-darwin        Disable Darwin (Mac OS X) support.],
    110. 

  110. 	  , [enable_darwin="yes"])
    111. 

  111.   if test "$enable_darwin" = "yes"; then
    112. 

  112.     AC_MSG_RESULT(no)
    113. 

  113.     AC_MSG_CHECKING(if Darwin files are there)
    114. 

  114.     if test -f os_macosx.m; then
    115. 

  115.       AC_MSG_RESULT(yes)
    116. 

  116.     else
    117. 

  117.       AC_MSG_RESULT([no, Darwin support disabled])
    118. 

  118.       enable_darwin=no
    119. 

  119.     fi
    120. 

  120.   else
    121. 

  121.     AC_MSG_RESULT([yes, Darwin support excluded])
    122. 

  122.   fi
    123. 

  123. 

  124.   AC_MSG_CHECKING(--with-mac-arch argument)
    125. 

  125.   AC_ARG_WITH(mac-arch, [  --with-mac-arch=ARCH    current, intel, ppc or both],
    126. 

  126. 	MACARCH="$withval"; AC_MSG_RESULT($MACARCH),
    127. 

  127. 	MACARCH="current"; AC_MSG_RESULT(defaulting to $MACARCH))
    128. 

  128. 

  129.   AC_MSG_CHECKING(--with-developer-dir argument)
    130. 

  130.   AC_ARG_WITH(developer-dir, [  --with-developer-dir=PATH    use PATH as location for Xcode developer tools],
    131. 

  131. 	DEVELOPER_DIR="$withval"; AC_MSG_RESULT($DEVELOPER_DIR),
    132. 

  132.         DEVELOPER_DIR=""; AC_MSG_RESULT(not present))
    133. 

  133.   
    134. 

  134.   if test "x$DEVELOPER_DIR" = "x"; then
    135. 

  135.     AC_PATH_PROG(XCODE_SELECT, xcode-select)
    136. 

  136.     if test "x$XCODE_SELECT" != "x"; then
    137. 

  137.       AC_MSG_CHECKING(for developer dir using xcode-select)
    138. 

  138.       DEVELOPER_DIR=`$XCODE_SELECT -print-path`
    139. 

  139.       AC_MSG_RESULT([$DEVELOPER_DIR])
    140. 

  140.     else
    141. 

  141.       DEVELOPER_DIR=/Developer
    142. 

  142.     fi
    143. 

  143.   fi
    144. 

  144. 

  145.   if test "x$MACARCH" = "xboth"; then
    146. 

  146.     AC_MSG_CHECKING(for 10.4 universal SDK)
    147. 

  147.     dnl There is a terrible inconsistency (but we appear to get away with it):
    148. 

  148.     dnl $CFLAGS uses the 10.4u SDK library for the headers, while $CPPFLAGS
    149. 

  149.     dnl doesn't, because "gcc -E" doesn't grok it.  That means the configure
    150. 

  150.     dnl tests using the preprocessor are actually done with the wrong header
    151. 

  151.     dnl files. $LDFLAGS is set at the end, because configure uses it together
    152. 

  152.     dnl with $CFLAGS and we can only have one -sysroot argument.
    153. 

  153.     save_cppflags="$CPPFLAGS"
    154. 

  154.     save_cflags="$CFLAGS"
    155. 

  155.     save_ldflags="$LDFLAGS"
    156. 

  156.     CFLAGS="$CFLAGS -isysroot $DEVELOPER_DIR/SDKs/MacOSX10.4u.sdk -arch i386 -arch ppc"
    157. 

  157.     AC_TRY_LINK([ ], [ ],
    158. 

  158. 	AC_MSG_RESULT(found, will make universal binary),
    159. 

  159. 

  160. 	AC_MSG_RESULT(not found)
    161. 

  161. 	CFLAGS="$save_cflags"
    162. 

  162. 	AC_MSG_CHECKING(if Intel architecture is supported)
    163. 

  163. 	CPPFLAGS="$CPPFLAGS -arch i386"
    164. 

  164. 	LDFLAGS="$save_ldflags -arch i386"
    165. 

  165. 	AC_TRY_LINK([ ], [ ],
    166. 

  166. 	    AC_MSG_RESULT(yes); MACARCH="intel",
    167. 

  167. 	    AC_MSG_RESULT(no, using PowerPC)
    168. 

  168. 		MACARCH="ppc"
    169. 

  169. 		CPPFLAGS="$save_cppflags -arch ppc"
    170. 

  170. 		LDFLAGS="$save_ldflags -arch ppc"))
    171. 

  171.   elif test "x$MACARCH" = "xintel"; then
    172. 

  172.     CPPFLAGS="$CPPFLAGS -arch intel"
    173. 

  173.     LDFLAGS="$LDFLAGS -arch intel"
    174. 

  174.   elif test "x$MACARCH" = "xppc"; then
    175. 

  175.     CPPFLAGS="$CPPFLAGS -arch ppc"
    176. 

  176.     LDFLAGS="$LDFLAGS -arch ppc"
    177. 

  177.   fi
    178. 

  178. 

  179.   if test "$enable_darwin" = "yes"; then
    180. 

  180.     MACOSX=yes
    181. 

  181.     OS_EXTRA_SRC="os_macosx.m os_mac_conv.c";
    182. 

  182.     OS_EXTRA_OBJ="objects/os_macosx.o objects/os_mac_conv.o"
    183. 

  183.     dnl TODO: use -arch i386 on Intel machines
    184. 

  184.     CPPFLAGS="$CPPFLAGS -DMACOS_X_UNIX -no-cpp-precomp"
    185. 

  185. 

  186.     dnl If Carbon is found, assume we don't want X11
    187. 

  187.     dnl unless it was specifically asked for (--with-x)
    188. 

  188.     dnl or Motif, Athena or GTK GUI is used.
    189. 

  189.     AC_CHECK_HEADER(Carbon/Carbon.h, CARBON=yes)
    190. 

  190.     if test "x$CARBON" = "xyes"; then
    191. 

  191.       if test -z "$with_x" -a "X$enable_gui" != Xmotif -a "X$enable_gui" != Xathena -a "X$enable_gui" != Xgtk2; then
    192. 

  192. 	with_x=no
    193. 

  193.       fi
    194. 

  194.     fi
    195. 

  195.   fi
    196. 

  196. 

  197.   dnl Avoid a bug with -O2 with gcc 4.0.1.  Symptom: malloc() reports double
    198. 

  198.   dnl free.  This happens in expand_filename(), because the optimizer swaps
    199. 

  199.   dnl two blocks of code, both using "repl", that can't be swapped.
    200. 

  200.   if test "$MACARCH" = "intel" -o "$MACARCH" = "both"; then
    201. 

  201.     CFLAGS=`echo "$CFLAGS" | sed 's/-O[[23456789]]/-Oz/'`
    202. 

  202.   fi
    203. 

  203. 

  204. else
    205. 

  205.   AC_MSG_RESULT(no)
    206. 

  206. fi
    207. 

  207. 

  208. AC_SUBST(OS_EXTRA_SRC)
    209. 

  209. AC_SUBST(OS_EXTRA_OBJ)
    210. 

  210. 

  211. dnl Add /usr/local/lib to $LDFLAGS and /usr/local/include to CFLAGS.
    212. 

  212. dnl Only when the directory exists and it wasn't there yet.
    213. 

  213. dnl For gcc don't do this when it is already in the default search path.
    214. 

  214. dnl Skip all of this when cross-compiling.
    215. 

  215. if test "$cross_compiling" = no; then
    216. 

  216.   AC_MSG_CHECKING(--with-local-dir argument)
    217. 

  217.   have_local_include=''
    218. 

  218.   have_local_lib=''
    219. 

  219.   AC_ARG_WITH([local-dir], [  --with-local-dir=PATH   search PATH instead of /usr/local for local libraries.
    220. 

  220.   --without-local-dir     do not search /usr/local for local libraries.], [
    221. 

  221.     local_dir="$withval"
    222. 

  222.     case "$withval" in
    223. 

  223.     */*) ;;
    224. 

  224.     no)
    225. 

  225.       # avoid adding local dir to LDFLAGS and CPPFLAGS
    226. 

  226.       have_local_include=yes
    227. 

  227.       have_local_lib=yes
    228. 

  228.       ;;
    229. 

  229.     *) AC_MSG_ERROR(must pass path argument to --with-local-dir) ;;
    230. 

  230.     esac
    231. 

  231. 	AC_MSG_RESULT($local_dir)
    232. 

  232.   ], [
    233. 

  233.     local_dir=/usr/local
    234. 

  234.     AC_MSG_RESULT(Defaulting to $local_dir)
    235. 

  235.   ])
    236. 

  236.   if test "$GCC" = yes -a "$local_dir" != no; then
    237. 

  237.     echo 'void f(){}' > conftest.c
    238. 

  238.     dnl -no-cpp-precomp is needed for OS X 10.2 (Ben Fowler)
    239. 

  239.     have_local_include=`${CC-cc} -no-cpp-precomp -c -v conftest.c 2>&1 | grep "${local_dir}/include"`
    240. 

  240.     have_local_lib=`${CC-cc} -c -v conftest.c 2>&1 | grep "${local_dir}/lib"`
    241. 

  241.     rm -f conftest.c conftest.o
    242. 

  242.   fi
    243. 

  243.   if test -z "$have_local_lib" -a -d "${local_dir}/lib"; then
    244. 

  244.     tt=`echo "$LDFLAGS" | sed -e "s+-L${local_dir}/lib ++g" -e "s+-L${local_dir}/lib$++g"`
    245. 

  245.     if test "$tt" = "$LDFLAGS"; then
    246. 

  246.       LDFLAGS="$LDFLAGS -L${local_dir}/lib"
    247. 

  247.     fi
    248. 

  248.   fi
    249. 

  249.   if test -z "$have_local_include" -a -d "${local_dir}/include"; then
    250. 

  250.     tt=`echo "$CPPFLAGS" | sed -e "s+-I${local_dir}/include ++g" -e "s+-I${local_dir}/include$++g"`
    251. 

  251.     if test "$tt" = "$CPPFLAGS"; then
    252. 

  252.       CPPFLAGS="$CPPFLAGS -I${local_dir}/include"
    253. 

  253.     fi
    254. 

  254.   fi
    255. 

  255. fi
    256. 

    257. 

  257. AC_MSG_CHECKING(--with-vim-name argument)
    258. 

  258. AC_ARG_WITH(vim-name, [  --with-vim-name=NAME    what to call the Vim executable],
    259. 

  259. 	VIMNAME="$withval"; AC_MSG_RESULT($VIMNAME),
    260. 

  260. 	VIMNAME="vim"; AC_MSG_RESULT(Defaulting to $VIMNAME))
    261. 

  261. AC_SUBST(VIMNAME)
    262. 

  262. AC_MSG_CHECKING(--with-ex-name argument)
    263. 

  263. AC_ARG_WITH(ex-name, [  --with-ex-name=NAME     what to call the Ex executable],
    264. 

  264. 	EXNAME="$withval"; AC_MSG_RESULT($EXNAME),
    265. 

  265. 	EXNAME="ex"; AC_MSG_RESULT(Defaulting to ex))
    266. 

  266. AC_SUBST(EXNAME)
    267. 

  267. AC_MSG_CHECKING(--with-view-name argument)
    268. 

  268. AC_ARG_WITH(view-name, [  --with-view-name=NAME   what to call the View executable],
    269. 

  269. 	VIEWNAME="$withval"; AC_MSG_RESULT($VIEWNAME),
    270. 

  270. 	VIEWNAME="view"; AC_MSG_RESULT(Defaulting to view))
    271. 

  271. AC_SUBST(VIEWNAME)
    272. 

    273. 

  273. AC_MSG_CHECKING(--with-global-runtime argument)
    274. 

  274. AC_ARG_WITH(global-runtime, [  --with-global-runtime=DIR    global runtime directory in 'runtimepath'],
    275. 

  275. 	AC_MSG_RESULT($withval); AC_DEFINE_UNQUOTED(RUNTIME_GLOBAL, "$withval"),
    276. 

  276. 	AC_MSG_RESULT(no))
    277. 

    278. 

  278. AC_MSG_CHECKING(--with-modified-by argument)
    279. 

  279. AC_ARG_WITH(modified-by, [  --with-modified-by=NAME       name of who modified a release version],
    280. 

  280. 	AC_MSG_RESULT($withval); AC_DEFINE_UNQUOTED(MODIFIED_BY, "$withval"),
    281. 

  281. 	AC_MSG_RESULT(no))
    282. 

    283. 

  283. dnl Check for EBCDIC stolen from the LYNX port to z/OS Unix
    284. 

  284. AC_MSG_CHECKING(if character set is EBCDIC)
    285. 

  285. AC_TRY_COMPILE([ ],
    286. 

  286. [ /* TryCompile function for CharSet.
    287. 

  287.    Treat any failure as ASCII for compatibility with existing art.
    288. 

  288.    Use compile-time rather than run-time tests for cross-compiler
    289. 

  289.    tolerance.  */
    290. 

  290. #if '0'!=240
    291. 

  291. make an error "Character set is not EBCDIC"
    292. 

  292. #endif ],
    293. 

  293. [ # TryCompile action if true
    294. 

  294. cf_cv_ebcdic=yes ],
    295. 

  295. [ # TryCompile action if false
    296. 

  296. cf_cv_ebcdic=no])
    297. 

  297. # end of TryCompile ])
    298. 

  298. # end of CacheVal CvEbcdic
    299. 

  299. AC_MSG_RESULT($cf_cv_ebcdic)
    300. 

  300. case "$cf_cv_ebcdic" in  #(vi
    301. 

  301.     yes)	AC_DEFINE(EBCDIC)
    302. 

  302. 		line_break='"\\n"'
    303. 

  303. 		;;
    304. 

  304.     *)		line_break='"\\012"';;
    305. 

  305. esac
    306. 

  306. AC_SUBST(line_break)
    307. 

  307. 

  308. if test "$cf_cv_ebcdic" = "yes"; then
    309. 

  309. dnl If we have EBCDIC we most likley have z/OS Unix, let's test it!
    310. 

  310. AC_MSG_CHECKING(for z/OS Unix)
    311. 

  311. case `uname` in
    312. 

  312.     OS/390)	zOSUnix="yes";
    313. 

  313. 		dnl If using cc the environment variable _CC_CCMODE must be
    314. 

  314. 		dnl set to "1", so that some compiler extensions are enabled.
    315. 

  315. 		dnl If using c89 the environment variable is named _CC_C89MODE.
    316. 

  316. 		dnl Note: compile with c89 never tested.
    317. 

  317. 		if test "$CC" = "cc"; then
    318. 

  318. 		  ccm="$_CC_CCMODE"
    319. 

  319. 		  ccn="CC"
    320. 

  320. 		else
    321. 

  321. 		  if test "$CC" = "c89"; then
    322. 

  322. 		    ccm="$_CC_C89MODE"
    323. 

  323. 		    ccn="C89"
    324. 

  324. 		  else
    325. 

  325. 		    ccm=1
    326. 

  326. 		  fi
    327. 

  327. 		fi
    328. 

  328. 		if test "$ccm" != "1"; then
    329. 

  329. 		  echo ""
    330. 

  330. 		  echo "------------------------------------------"
    331. 

  331. 		  echo " On z/OS Unix, the environment variable"
    332. 

  332. 		  echo " __CC_${ccn}MODE must be set to \"1\"!"
    333. 

  333. 		  echo " Do:"
    334. 

  334. 		  echo "    export _CC_${ccn}MODE=1"
    335. 

  335. 		  echo " and then call configure again."
    336. 

  336. 		  echo "------------------------------------------"
    337. 

  337. 		  exit 1
    338. 

  338. 		fi
    339. 

  339. 		CFLAGS="$CFLAGS -D_ALL_SOURCE -Wc,float\\(IEEE\\)";
    340. 

  340.                 LDFLAGS="$LDFLAGS -Wl,EDIT=NO"
    341. 

  341. 		AC_MSG_RESULT(yes)
    342. 

  342. 		;;
    343. 

  343.     *)		zOSUnix="no";
    344. 

  344. 		AC_MSG_RESULT(no)
    345. 

  345. 		;;
    346. 

  346. esac
    347. 

  347. fi
    348. 

  348. 

  349. dnl Set QUOTESED. Needs additional backslashes on zOS
    350. 

  350. if test "$zOSUnix" = "yes"; then
    351. 

  351.     QUOTESED="sed -e 's/[[\\\\\"]]/\\\\\\\\&/g' -e 's/\\\\\\\\\"/\"/' -e 's/\\\\\\\\\";\$\$/\";/'"
    352. 

  352. else
    353. 

  353.     QUOTESED="sed -e 's/[[\\\\\"]]/\\\\&/g' -e 's/\\\\\"/\"/' -e 's/\\\\\";\$\$/\";/'"
    354. 

  354. fi
    355. 

  355. AC_SUBST(QUOTESED)
    356. 

  356. 

  357. 

  358. dnl Link with -lselinux for SELinux stuff; if not found
    359. 

  359. AC_MSG_CHECKING(--disable-selinux argument)
    360. 

  360. AC_ARG_ENABLE(selinux,
    361. 

  361. 	[  --disable-selinux	  Don't check for SELinux support.],
    362. 

  362. 	, enable_selinux="yes")
    363. 

  363. if test "$enable_selinux" = "yes"; then
    364. 

  364.   AC_MSG_RESULT(no)
    365. 

  365.   AC_CHECK_LIB(selinux, is_selinux_enabled,
    366. 

  366. 	  [LIBS="$LIBS -lselinux"
    367. 

  367. 	   AC_DEFINE(HAVE_SELINUX)])
    368. 

  368. else
    369. 

  369.    AC_MSG_RESULT(yes)
    370. 

  370. fi
    371. 

  371. 

  372. dnl Check user requested features.
    373. 

  373. 

  374. AC_MSG_CHECKING(--with-features argument)
    375. 

  375. AC_ARG_WITH(features, [  --with-features=TYPE    tiny, small, normal, big or huge (default: normal)],
    376. 

  376. 	features="$withval"; AC_MSG_RESULT($features),
    377. 

  377. 	features="normal"; AC_MSG_RESULT(Defaulting to normal))
    378. 

  378. 

  379. dovimdiff=""
    380. 

  380. dogvimdiff=""
    381. 

  381. case "$features" in
    382. 

  382.   tiny)		AC_DEFINE(FEAT_TINY) ;;
    383. 

  383.   small)	AC_DEFINE(FEAT_SMALL) ;;
    384. 

  384.   normal)	AC_DEFINE(FEAT_NORMAL) dovimdiff="installvimdiff";
    385. 

  385. 			dogvimdiff="installgvimdiff" ;;
    386. 

  386.   big)		AC_DEFINE(FEAT_BIG) dovimdiff="installvimdiff";
    387. 

  387. 			dogvimdiff="installgvimdiff" ;;
    388. 

  388.   huge)		AC_DEFINE(FEAT_HUGE) dovimdiff="installvimdiff";
    389. 

  389. 			dogvimdiff="installgvimdiff" ;;
    390. 

  390.   *)		AC_MSG_RESULT([Sorry, $features is not supported]) ;;
    391. 

  391. esac
    392. 

  392. 

  393. AC_SUBST(dovimdiff)
    394. 

  394. AC_SUBST(dogvimdiff)
    395. 

  395. 

  396. AC_MSG_CHECKING(--with-compiledby argument)
    397. 

  397. AC_ARG_WITH(compiledby, [  --with-compiledby=NAME  name to show in :version message],
    398. 

  398. 	compiledby="$withval"; AC_MSG_RESULT($withval),
    399. 

  399. 	compiledby=""; AC_MSG_RESULT(no))
    400. 

  400. AC_SUBST(compiledby)
    401. 

  401. 

  402. AC_MSG_CHECKING(--disable-xsmp argument)
    403. 

  403. AC_ARG_ENABLE(xsmp,
    404. 

  404. 	[  --disable-xsmp          Disable XSMP session management],
    405. 

  405. 	, enable_xsmp="yes")
    406. 

  406. 

  407. if test "$enable_xsmp" = "yes"; then
    408. 

  408.   AC_MSG_RESULT(no)
    409. 

  409.   AC_MSG_CHECKING(--disable-xsmp-interact argument)
    410. 

  410.   AC_ARG_ENABLE(xsmp-interact,
    411. 

  411. 	  [  --disable-xsmp-interact Disable XSMP interaction],
    412. 

  412. 	  , enable_xsmp_interact="yes")
    413. 

  413.   if test "$enable_xsmp_interact" = "yes"; then
    414. 

  414.     AC_MSG_RESULT(no)
    415. 

  415.     AC_DEFINE(USE_XSMP_INTERACT)
    416. 

  416.   else
    417. 

  417.     AC_MSG_RESULT(yes)
    418. 

  418.   fi
    419. 

  419. else
    420. 

  420.   AC_MSG_RESULT(yes)
    421. 

  421. fi
    422. 

  422. 

  423. dnl Check for Lua feature.
    424. 

  424. AC_MSG_CHECKING(--enable-luainterp argument)
    425. 

  425. AC_ARG_ENABLE(luainterp,
    426. 

  426. 	[  --enable-luainterp[=OPTS]     Include Lua interpreter.  [default=no] [OPTS=no/yes/dynamic]], ,
    427. 

  427. 	[enable_luainterp="no"])
    428. 

  428. AC_MSG_RESULT($enable_luainterp)
    429. 

  429. 

  430. if test "$enable_luainterp" = "yes" -o "$enable_luainterp" = "dynamic"; then
    431. 

  431.   dnl -- find the lua executable
    432. 

  432.   AC_SUBST(vi_cv_path_lua)
    433. 

  433. 

  434.   AC_MSG_CHECKING(--with-lua-prefix argument)
    435. 

  435.   AC_ARG_WITH(lua_prefix,
    436. 

  436. 	[  --with-lua-prefix=PFX   Prefix where Lua is installed.],
    437. 

  437. 	with_lua_prefix="$withval"; AC_MSG_RESULT($with_lua_prefix),
    438. 

  438. 	with_lua_prefix="";AC_MSG_RESULT(no))
    439. 

  439. 

  440.   if test "X$with_lua_prefix" != "X"; then
    441. 

  441.        vi_cv_path_lua_pfx="$with_lua_prefix"
    442. 

  442.   else
    443. 

  443.     AC_MSG_CHECKING(LUA_PREFIX environment var)
    444. 

  444.     if test "X$LUA_PREFIX" != "X"; then
    445. 

  445. 	AC_MSG_RESULT("$LUA_PREFIX")
    446. 

  446. 	vi_cv_path_lua_pfx="$LUA_PREFIX"
    447. 

  447.     else
    448. 

  448. 	AC_MSG_RESULT([not set, default to /usr])
    449. 

  449. 	vi_cv_path_lua_pfx="/usr"
    450. 

  450.     fi
    451. 

  451.   fi
    452. 

  452. 

  453.   LUA_INC=
    454. 

  454.   if test "X$vi_cv_path_lua_pfx" != "X"; then
    455. 

  455.     AC_MSG_CHECKING(if lua.h can be found in $vi_cv_path_lua_pfx/include)
    456. 

  456.     if test -f $vi_cv_path_lua_pfx/include/lua.h; then
    457. 

  457.       AC_MSG_RESULT(yes)
    458. 

  458.     else
    459. 

  459.       AC_MSG_RESULT(no)
    460. 

  460.       dnl -- try to find Lua executable
    461. 

  461.       AC_PATH_PROG(vi_cv_path_lua, lua)
    462. 

  462.       if test "X$vi_cv_path_lua" != "X"; then
    463. 

  463.         dnl -- find Lua version
    464. 

  464.         AC_CACHE_CHECK(Lua version, vi_cv_version_lua,
    465. 

  465.         [ vi_cv_version_lua=`${vi_cv_path_lua} -e "print(_VERSION)" | sed 's/.* //'` ])
    466. 

  466.         AC_MSG_CHECKING(if lua.h can be found in $vi_cv_path_lua_pfx/include/lua$vi_cv_version_lua)
    467. 

  467.         if test -f $vi_cv_path_lua_pfx/include/lua$vi_cv_version_lua/lua.h; then
    468. 

  468.           AC_MSG_RESULT(yes)
    469. 

  469.           LUA_INC=/lua$vi_cv_version_lua
    470. 

  470.         else
    471. 

  471.           AC_MSG_RESULT(no)
    472. 

  472.           vi_cv_path_lua_pfx=
    473. 

  473.         fi
    474. 

  474.       fi
    475. 

  475.     fi
    476. 

  476.   fi
    477. 

  477. 

  478.   if test "X$vi_cv_path_lua_pfx" != "X"; then
    479. 

  479.     if test "X$vi_cv_version_lua" != "X"; then
    480. 

  480.       dnl Test alternate location using version
    481. 

  481.       LUA_LIBS="-L${vi_cv_path_lua_pfx}/lib -llua$vi_cv_version_lua"
    482. 

  482.     else
    483. 

  483.       LUA_LIBS="-L${vi_cv_path_lua_pfx}/lib -llua"
    484. 

  484.     fi
    485. 

  485.     LUA_CFLAGS="-I${vi_cv_path_lua_pfx}/include${LUA_INC}"
    486. 

  486.     LUA_SRC="if_lua.c"
    487. 

  487.     LUA_OBJ="objects/if_lua.o"
    488. 

  488.     LUA_PRO="if_lua.pro"
    489. 

  489.     AC_DEFINE(FEAT_LUA)
    490. 

  490.     if test "$enable_luainterp" = "dynamic"; then
    491. 

  491.       dnl Determine the SONAME for the current version, but fallback to
    492. 

  492.       dnl liblua${vi_cv_version_lua}.so if no SONAME-versioned file is found.
    493. 

  493.       for i in 0 1 2 3 4 5 6 7 8 9; do
    494. 

  494. 	if test -f "${vi_cv_path_lua_pfx}/lib/liblua${vi_cv_version_lua}.so.$i"; then
    495. 

  495. 	  LUA_SONAME=".$i"
    496. 

  496. 	  break
    497. 

  497. 	fi
    498. 

  498.       done
    499. 

  499.       AC_DEFINE(DYNAMIC_LUA)
    500. 

  500.       LUA_LIBS=""
    501. 

  501.       LUA_CFLAGS="-DDYNAMIC_LUA_DLL=\\\"liblua${vi_cv_version_lua}.so$LUA_SONAME\\\" $LUA_CFLAGS"
    502. 

  502.     fi
    503. 

  503.   fi
    504. 

  504.   if test "$fail_if_missing" = "yes" -a -z "$LUA_SRC"; then
    505. 

  505.     AC_MSG_ERROR([could not configure lua])
    506. 

  506.   fi
    507. 

  507.   AC_SUBST(LUA_SRC)
    508. 

  508.   AC_SUBST(LUA_OBJ)
    509. 

  509.   AC_SUBST(LUA_PRO)
    510. 

  510.   AC_SUBST(LUA_LIBS)
    511. 

  511.   AC_SUBST(LUA_CFLAGS)
    512. 

  512. fi
    513. 

  513. 

  514. 

  515. dnl Check for MzScheme feature.
    516. 

  516. AC_MSG_CHECKING(--enable-mzschemeinterp argument)
    517. 

  517. AC_ARG_ENABLE(mzschemeinterp,
    518. 

  518. 	[  --enable-mzschemeinterp   Include MzScheme interpreter.], ,
    519. 

  519. 	[enable_mzschemeinterp="no"])
    520. 

  520. AC_MSG_RESULT($enable_mzschemeinterp)
    521. 

  521. 

  522. if test "$enable_mzschemeinterp" = "yes"; then
    523. 

  523.   dnl -- find the mzscheme executable
    524. 

  524.   AC_SUBST(vi_cv_path_mzscheme)
    525. 

  525. 

  526.   AC_MSG_CHECKING(--with-plthome argument)
    527. 

  527.   AC_ARG_WITH(plthome,
    528. 

  528. 	[  --with-plthome=PLTHOME   Use PLTHOME.],
    529. 

  529. 	with_plthome="$withval"; AC_MSG_RESULT($with_plthome),
    530. 

  530. 	with_plthome="";AC_MSG_RESULT("no"))
    531. 

  531. 

  532.   if test "X$with_plthome" != "X"; then
    533. 

  533.        vi_cv_path_mzscheme_pfx="$with_plthome"
    534. 

  534.   else
    535. 

  535.     AC_MSG_CHECKING(PLTHOME environment var)
    536. 

  536.     if test "X$PLTHOME" != "X"; then
    537. 

  537. 	AC_MSG_RESULT("$PLTHOME")
    538. 

  538. 	vi_cv_path_mzscheme_pfx="$PLTHOME"
    539. 

  539.     else
    540. 

  540. 	AC_MSG_RESULT(not set)
    541. 

  541. 	dnl -- try to find MzScheme executable
    542. 

  542. 	AC_PATH_PROG(vi_cv_path_mzscheme, mzscheme)
    543. 

  543. 

  544. 	dnl resolve symbolic link, the executable is often elsewhere and there
    545. 

  545. 	dnl are no links for the include files.
    546. 

  546. 	if test "X$vi_cv_path_mzscheme" != "X"; then
    547. 

  547. 	  lsout=`ls -l $vi_cv_path_mzscheme`
    548. 

  548. 	  if echo "$lsout" | grep -e '->' >/dev/null 2>/dev/null; then
    549. 

  549. 	    vi_cv_path_mzscheme=`echo "$lsout" | sed 's/.*-> \(.*\)/\1/'`
    550. 

  550. 	  fi
    551. 

  551. 	fi
    552. 

  552. 

  553. 	if test "X$vi_cv_path_mzscheme" != "X"; then
    554. 

  554. 	    dnl -- find where MzScheme thinks it was installed
    555. 

  555. 	    AC_CACHE_CHECK(MzScheme install prefix,vi_cv_path_mzscheme_pfx,
    556. 

  556. 	    dnl different versions of MzScheme differ in command line processing
    557. 

  557. 	    dnl use universal approach
    558. 

  558. 	    echo "(display (simplify-path		\
    559. 

  559. 	       (build-path (call-with-values	\
    560. 

  560. 		(lambda () (split-path (find-system-path (quote exec-file)))) \
    561. 

  561. 		(lambda (base name must-be-dir?) base)) (quote up))))" > mzdirs.scm
    562. 

  562. 	    dnl Remove a trailing slash
    563. 

  563. 	    [ vi_cv_path_mzscheme_pfx=`${vi_cv_path_mzscheme} -r mzdirs.scm | \
    564. 

  564. 		sed -e 's+/$++'` ])
    565. 

  565. 	    rm -f mzdirs.scm
    566. 

  566. 	fi
    567. 

  567.     fi
    568. 

  568.   fi
    569. 

  569. 

  570.   SCHEME_INC=
    571. 

  571.   if test "X$vi_cv_path_mzscheme_pfx" != "X"; then
    572. 

  572.     AC_MSG_CHECKING(if scheme.h can be found in $vi_cv_path_mzscheme_pfx/include)
    573. 

  573.     if test -f $vi_cv_path_mzscheme_pfx/include/scheme.h; then
    574. 

  574.       SCHEME_INC=${vi_cv_path_mzscheme_pfx}/include
    575. 

  575.       AC_MSG_RESULT(yes)
    576. 

  576.     else
    577. 

  577.       AC_MSG_RESULT(no)
    578. 

  578.       AC_MSG_CHECKING(if scheme.h can be found in $vi_cv_path_mzscheme_pfx/include/plt)
    579. 

  579.       if test -f $vi_cv_path_mzscheme_pfx/include/plt/scheme.h; then
    580. 

  580. 	AC_MSG_RESULT(yes)
    581. 

  581. 	SCHEME_INC=${vi_cv_path_mzscheme_pfx}/include/plt
    582. 

  582.       else
    583. 

  583. 	AC_MSG_RESULT(no)
    584. 

  584. 	AC_MSG_CHECKING(if scheme.h can be found in $vi_cv_path_mzscheme_pfx/include/racket)
    585. 

  585. 	if test -f $vi_cv_path_mzscheme_pfx/include/racket/scheme.h; then
    586. 

  586. 	  AC_MSG_RESULT(yes)
    587. 

  587. 	  SCHEME_INC=${vi_cv_path_mzscheme_pfx}/include/racket
    588. 

  588. 	else
    589. 

  589. 	  AC_MSG_RESULT(no)
    590. 

  590. 	  AC_MSG_CHECKING(if scheme.h can be found in /usr/include/plt/)
    591. 

  591. 	  if test -f /usr/include/plt/scheme.h; then
    592. 

  592. 	    AC_MSG_RESULT(yes)
    593. 

  593. 	    SCHEME_INC=/usr/include/plt
    594. 

  594. 	  else
    595. 

  595. 	    AC_MSG_RESULT(no)
    596. 

  596. 	    AC_MSG_CHECKING(if scheme.h can be found in /usr/include/racket/)
    597. 

  597. 	    if test -f /usr/include/racket/scheme.h; then
    598. 

  598. 	      AC_MSG_RESULT(yes)
    599. 

  599. 	      SCHEME_INC=/usr/include/racket
    600. 

  600. 	    else
    601. 

  601. 	      AC_MSG_RESULT(no)
    602. 

  602. 	      vi_cv_path_mzscheme_pfx=
    603. 

  603. 	    fi
    604. 

  604. 	  fi
    605. 

  605. 	fi
    606. 

  606.       fi
    607. 

  607.     fi
    608. 

  608.   fi
    609. 

  609. 

  610.   if test "X$vi_cv_path_mzscheme_pfx" != "X"; then
    611. 

  611.     if test "x$MACOSX" = "xyes"; then
    612. 

  612.       MZSCHEME_LIBS="-framework PLT_MzScheme"
    613. 

  613.     elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzscheme3m.a"; then
    614. 

  614.       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libmzscheme3m.a"
    615. 

  615.       MZSCHEME_CFLAGS="-DMZ_PRECISE_GC"
    616. 

  616.     elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libracket3m.a"; then
    617. 

  617.       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libracket3m.a"
    618. 

  618.       MZSCHEME_CFLAGS="-DMZ_PRECISE_GC"
    619. 

  619.     elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libracket.a"; then
    620. 

  620.       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libracket.a ${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"
    621. 

  621.     elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzscheme.a"; then
    622. 

  622.       MZSCHEME_LIBS="${vi_cv_path_mzscheme_pfx}/lib/libmzscheme.a ${vi_cv_path_mzscheme_pfx}/lib/libmzgc.a"
    623. 

  623.     else
    624. 

  624.       dnl Using shared objects
    625. 

  625.       if test -f "${vi_cv_path_mzscheme_pfx}/lib/libmzscheme3m.so"; then
    626. 

  626.         MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lmzscheme3m"
    627. 

  627. 	MZSCHEME_CFLAGS="-DMZ_PRECISE_GC"
    628. 

  628.       elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libracket3m.so"; then
    629. 

  629.         MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lracket3m"
    630. 

  630. 	MZSCHEME_CFLAGS="-DMZ_PRECISE_GC"
    631. 

  631.       elif test -f "${vi_cv_path_mzscheme_pfx}/lib/libracket.so"; then
    632. 

  632.         MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lracket -lmzgc"
    633. 

  633.       else
    634. 

  634.         MZSCHEME_LIBS="-L${vi_cv_path_mzscheme_pfx}/lib -lmzscheme -lmzgc"
    635. 

  635.       fi
    636. 

  636.       if test "$GCC" = yes; then
    637. 

  637. 	dnl Make Vim remember the path to the library.  For when it's not in
    638. 

  638. 	dnl $LD_LIBRARY_PATH.
    639. 

  639. 	MZSCHEME_LIBS="${MZSCHEME_LIBS} -Wl,-rpath -Wl,${vi_cv_path_mzscheme_pfx}/lib"
    640. 

  640.       elif test "`(uname) 2>/dev/null`" = SunOS &&
    641. 

  641. 			       uname -r | grep '^5' >/dev/null; then
    642. 

  642. 	MZSCHEME_LIBS="${MZSCHEME_LIBS} -R ${vi_cv_path_mzscheme_pfx}/lib"
    643. 

  643.       fi
    644. 

  644.     fi
    645. 

  645.     if test -d $vi_cv_path_mzscheme_pfx/lib/plt/collects; then
    646. 

  646.       SCHEME_COLLECTS=lib/plt/
    647. 

  647.     else
    648. 

  648.       if test -d $vi_cv_path_mzscheme_pfx/lib/racket/collects; then
    649. 

  649. 	SCHEME_COLLECTS=lib/racket/
    650. 

  650.       fi
    651. 

  651.     fi
    652. 

  652.     if test -f "${vi_cv_path_mzscheme_pfx}/${SCHEME_COLLECTS}collects/scheme/base.ss" ; then
    653. 

  653.       MZSCHEME_EXTRA="mzscheme_base.c"
    654. 

  654.     else
    655. 

  655.       if test -f "${vi_cv_path_mzscheme_pfx}/${SCHEME_COLLECTS}collects/scheme/base.rkt" ; then
    656. 

  656. 	MZSCHEME_EXTRA="mzscheme_base.c"
    657. 

  657.       fi
    658. 

  658.     fi
    659. 

  659.     if test "X$MZSCHEME_EXTRA" != "X" ; then
    660. 

  660.       dnl need to generate bytecode for MzScheme base
    661. 

  661.       MZSCHEME_CFLAGS="${MZSCHEME_CFLAGS} -DINCLUDE_MZSCHEME_BASE"
    662. 

  662.       MZSCHEME_MZC="${vi_cv_path_mzscheme_pfx}/bin/mzc"
    663. 

  663.     fi
    664. 

  664.     MZSCHEME_CFLAGS="${MZSCHEME_CFLAGS} -I${SCHEME_INC} \
    665. 

  665.       -DMZSCHEME_COLLECTS='\"${vi_cv_path_mzscheme_pfx}/${SCHEME_COLLECTS}collects\"'"
    666. 

  666.     MZSCHEME_SRC="if_mzsch.c"
    667. 

  667.     MZSCHEME_OBJ="objects/if_mzsch.o"
    668. 

  668.     MZSCHEME_PRO="if_mzsch.pro"
    669. 

  669.     AC_DEFINE(FEAT_MZSCHEME)
    670. 

  670.   fi
    671. 

  671.   AC_SUBST(MZSCHEME_SRC)
    672. 

  672.   AC_SUBST(MZSCHEME_OBJ)
    673. 

  673.   AC_SUBST(MZSCHEME_PRO)
    674. 

  674.   AC_SUBST(MZSCHEME_LIBS)
    675. 

  675.   AC_SUBST(MZSCHEME_CFLAGS)
    676. 

  676.   AC_SUBST(MZSCHEME_EXTRA)
    677. 

  677.   AC_SUBST(MZSCHEME_MZC)
    678. 

  678. fi
    679. 

  679. 

  680. 

  681. AC_MSG_CHECKING(--enable-perlinterp argument)
    682. 

  682. AC_ARG_ENABLE(perlinterp,
    683. 

  683. 	[  --enable-perlinterp[=OPTS]     Include Perl interpreter.  [default=no] [OPTS=no/yes/dynamic]], ,
    684. 

  684. 	[enable_perlinterp="no"])
    685. 

  685. AC_MSG_RESULT($enable_perlinterp)
    686. 

  686. if test "$enable_perlinterp" = "yes" -o "$enable_perlinterp" = "dynamic"; then
    687. 

  687.   AC_SUBST(vi_cv_path_perl)
    688. 

  688.   AC_PATH_PROG(vi_cv_path_perl, perl)
    689. 

  689.   if test "X$vi_cv_path_perl" != "X"; then
    690. 

  690.     AC_MSG_CHECKING(Perl version)
    691. 

  691.     if $vi_cv_path_perl -e 'require 5.003_01' >/dev/null 2>/dev/null; then
    692. 

  692.      eval `$vi_cv_path_perl -V:usethreads`
    693. 

  693.      eval `$vi_cv_path_perl -V:libperl`
    694. 

  694.      if test "X$usethreads" = "XUNKNOWN" -o "X$usethreads" = "Xundef"; then
    695. 

  695.        badthreads=no
    696. 

  696.      else
    697. 

  697.        if $vi_cv_path_perl -e 'require 5.6.0' >/dev/null 2>/dev/null; then
    698. 

  698. 	 eval `$vi_cv_path_perl -V:use5005threads`
    699. 

  699. 	 if test "X$use5005threads" = "XUNKNOWN" -o "X$use5005threads" = "Xundef"; then
    700. 

  700. 	   badthreads=no
    701. 

  701. 	 else
    702. 

  702. 	   badthreads=yes
    703. 

  703. 	   AC_MSG_RESULT(>>> Perl > 5.6 with 5.5 threads cannot be used <<<)
    704. 

  704. 	 fi
    705. 

  705.        else
    706. 

  706. 	 badthreads=yes
    707. 

  707. 	 AC_MSG_RESULT(>>> Perl 5.5 with threads cannot be used <<<)
    708. 

  708.        fi
    709. 

  709.      fi
    710. 

  710.      if test $badthreads = no; then
    711. 

  711.       AC_MSG_RESULT(OK)
    712. 

  712.       eval `$vi_cv_path_perl -V:shrpenv`
    713. 

  713.       if test "X$shrpenv" = "XUNKNOWN"; then # pre 5.003_04
    714. 

  714. 	shrpenv=""
    715. 

  715.       fi
    716. 

  716.       vi_cv_perllib=`$vi_cv_path_perl -MConfig -e 'print $Config{privlibexp}'`
    717. 

  717.       AC_SUBST(vi_cv_perllib)
    718. 

  718.       dnl Remove "-fno-something", it breaks using cproto.
    719. 

  719.       perlcppflags=`$vi_cv_path_perl -Mlib=$srcdir -MExtUtils::Embed \
    720. 

  720. 	      -e 'ccflags;perl_inc;print"\n"' | sed -e 's/-fno[[^ ]]*//'`
    721. 

  721.       dnl Remove "-lc", it breaks on FreeBSD when using "-pthread".
    722. 

  722.       perllibs=`cd $srcdir; $vi_cv_path_perl -MExtUtils::Embed -e 'ldopts' | \
    723. 

  723. 		sed -e '/Warning/d' -e '/Note (probably harmless)/d' \
    724. 

  724. 			-e 's/-bE:perl.exp//' -e 's/-lc //'`
    725. 

  725.       dnl Don't add perl lib to $LIBS: if it's not in LD_LIBRARY_PATH
    726. 

  726.       dnl a test in configure may fail because of that.
    727. 

  727.       perlldflags=`cd $srcdir; $vi_cv_path_perl -MExtUtils::Embed \
    728. 

  728. 		-e 'ccdlflags' | sed -e 's/-bE:perl.exp//'`
    729. 

  729. 

  730.       dnl check that compiling a simple program still works with the flags
    731. 

  731.       dnl added for Perl.
    732. 

  732.       AC_MSG_CHECKING([if compile and link flags for Perl are sane])
    733. 

  733.       cflags_save=$CFLAGS
    734. 

  734.       libs_save=$LIBS
    735. 

  735.       ldflags_save=$LDFLAGS
    736. 

  736.       CFLAGS="$CFLAGS $perlcppflags"
    737. 

  737.       LIBS="$LIBS $perllibs"
    738. 

  738.       LDFLAGS="$perlldflags $LDFLAGS"
    739. 

  739.       AC_TRY_LINK(,[ ],
    740. 

  740. 	     AC_MSG_RESULT(yes); perl_ok=yes,
    741. 

  741. 	     AC_MSG_RESULT(no: PERL DISABLED); perl_ok=no)
    742. 

  742.       CFLAGS=$cflags_save
    743. 

  743.       LIBS=$libs_save
    744. 

  744.       LDFLAGS=$ldflags_save
    745. 

  745.       if test $perl_ok = yes; then
    746. 

  746. 	if test "X$perlcppflags" != "X"; then
    747. 

  747. 	  dnl remove -pipe and -Wxxx, it confuses cproto
    748. 

  748. 	  PERL_CFLAGS=`echo "$perlcppflags" | sed -e 's/-pipe //' -e 's/-W[[^ ]]*//'`
    749. 

  749. 	fi
    750. 

  750. 	if test "X$perlldflags" != "X"; then
    751. 

  751. 	  LDFLAGS="$perlldflags $LDFLAGS"
    752. 

  752. 	fi
    753. 

  753. 	PERL_LIBS=$perllibs
    754. 

  754. 	PERL_SRC="auto/if_perl.c if_perlsfio.c"
    755. 

  755. 	PERL_OBJ="objects/if_perl.o objects/if_perlsfio.o"
    756. 

  756. 	PERL_PRO="if_perl.pro if_perlsfio.pro"
    757. 

  757. 	AC_DEFINE(FEAT_PERL)
    758. 

  758.       fi
    759. 

  759.      fi
    760. 

  760.     else
    761. 

  761.       AC_MSG_RESULT(>>> too old; need Perl version 5.003_01 or later <<<)
    762. 

  762.     fi
    763. 

  763.   fi
    764. 

  764. 

  765.   if test "x$MACOSX" = "xyes"; then
    766. 

  766.     dnl Mac OS X 10.2 or later
    767. 

  767.     dir=/System/Library/Perl
    768. 

  768.     darwindir=$dir/darwin
    769. 

  769.     if test -d $darwindir; then
    770. 

  770.       PERL=/usr/bin/perl
    771. 

  771.     else
    772. 

  772.       dnl Mac OS X 10.3
    773. 

  773.       dir=/System/Library/Perl/5.8.1
    774. 

  774.       darwindir=$dir/darwin-thread-multi-2level
    775. 

  775.       if test -d $darwindir; then
    776. 

  776. 	PERL=/usr/bin/perl
    777. 

  777.       fi
    778. 

  778.     fi
    779. 

  779.     if test -n "$PERL"; then
    780. 

  780.       PERL_DIR="$dir"
    781. 

  781.       PERL_CFLAGS="-DFEAT_PERL -I$darwindir/CORE"
    782. 

  782.       PERL_OBJ="objects/if_perl.o objects/if_perlsfio.o $darwindir/auto/DynaLoader/DynaLoader.a"
    783. 

  783.       PERL_LIBS="-L$darwindir/CORE -lperl"
    784. 

  784.     fi
    785. 

  785.     dnl Perl on Mac OS X 10.5 adds "-arch" flags but these should only
    786. 

  786.     dnl be included if requested by passing --with-mac-arch to
    787. 

  787.     dnl configure, so strip these flags first (if present)
    788. 

  788.     PERL_LIBS=`echo "$PERL_LIBS" | sed -e 's/-arch\ ppc//' -e 's/-arch\ i386//' -e 's/-arch\ x86_64//'`
    789. 

  789.     PERL_CFLAGS=`echo "$PERL_CFLAGS" | sed -e 's/-arch\ ppc//' -e 's/-arch\ i386//' -e 's/-arch\ x86_64//'`
    790. 

  790.   fi
    791. 

  791.   if test "$enable_perlinterp" = "dynamic"; then
    792. 

  792.     if test "$perl_ok" = "yes" -a "X$libperl" != "X"; then
    793. 

  793.       AC_DEFINE(DYNAMIC_PERL)
    794. 

  794.       PERL_CFLAGS="-DDYNAMIC_PERL_DLL=\\\"$libperl\\\" $PERL_CFLAGS"
    795. 

  795.     fi
    796. 

  796.   fi
    797. 

  797. 

  798.   if test "$fail_if_missing" = "yes" -a "$perl_ok" != "yes"; then
    799. 

  799.     AC_MSG_ERROR([could not configure perl])
    800. 

  800.   fi
    801. 

  801. fi
    802. 

  802. AC_SUBST(shrpenv)
    803. 

  803. AC_SUBST(PERL_SRC)
    804. 

  804. AC_SUBST(PERL_OBJ)
    805. 

  805. AC_SUBST(PERL_PRO)
    806. 

  806. AC_SUBST(PERL_CFLAGS)
    807. 

  807. AC_SUBST(PERL_LIBS)
    808. 

  808. 

  809. AC_MSG_CHECKING(--enable-pythoninterp argument)
    810. 

  810. AC_ARG_ENABLE(pythoninterp,
    811. 

  811. 	[  --enable-pythoninterp[=OPTS]   Include Python interpreter. [default=no] [OPTS=no/yes/dynamic]], ,
    812. 

  812. 	[enable_pythoninterp="no"])
    813. 

  813. AC_MSG_RESULT($enable_pythoninterp)
    814. 

  814. if test "$enable_pythoninterp" = "yes" -o "$enable_pythoninterp" = "dynamic"; then
    815. 

  815.   dnl -- find the python executable
    816. 

  816.   AC_PATH_PROG(vi_cv_path_python, python)
    817. 

  817.   if test "X$vi_cv_path_python" != "X"; then
    818. 

  818. 

  819.     dnl -- get its version number
    820. 

  820.     AC_CACHE_CHECK(Python version,vi_cv_var_python_version,
    821. 

  821.     [[vi_cv_var_python_version=`
    822. 

  822. 	    ${vi_cv_path_python} -c 'import sys; print sys.version[:3]'`
    823. 

  823.     ]])
    824. 

  824. 

  825.     dnl -- it must be at least version 1.4
    826. 

  826.     AC_MSG_CHECKING(Python is 1.4 or better)
    827. 

  827.     if ${vi_cv_path_python} -c \
    828. 

  828. 	"import sys; sys.exit(${vi_cv_var_python_version} < 1.4)"
    829. 

  829.     then
    830. 

  830.       AC_MSG_RESULT(yep)
    831. 

  831. 

  832.       dnl -- find where python thinks it was installed
    833. 

  833.       AC_CACHE_CHECK(Python's install prefix,vi_cv_path_python_pfx,
    834. 

  834.       [ vi_cv_path_python_pfx=`
    835. 

  835. 	    ${vi_cv_path_python} -c \
    836. 

  836. 		"import sys; print sys.prefix"` ])
    837. 

  837. 

  838.       dnl -- and where it thinks it runs
    839. 

  839.       AC_CACHE_CHECK(Python's execution prefix,vi_cv_path_python_epfx,
    840. 

  840.       [ vi_cv_path_python_epfx=`
    841. 

  841. 	    ${vi_cv_path_python} -c \
    842. 

  842. 		"import sys; print sys.exec_prefix"` ])
    843. 

  843. 

  844.       dnl -- python's internal library path
    845. 

    846. 

  846.       AC_CACHE_VAL(vi_cv_path_pythonpath,
    847. 

  847.       [ vi_cv_path_pythonpath=`
    848. 

  848. 	    unset PYTHONPATH;
    849. 

  849. 	    ${vi_cv_path_python} -c \
    850. 

  850. 		"import sys, string; print string.join(sys.path,':')"` ])
    851. 

  851. 

  852.       dnl -- where the Python implementation library archives are
    853. 

  853. 

  854.       AC_ARG_WITH(python-config-dir,
    855. 

  855. 	[  --with-python-config-dir=PATH  Python's config directory],
    856. 

  856. 	[ vi_cv_path_python_conf="${withval}" ] )
    857. 

  857. 

  858.       AC_CACHE_CHECK(Python's configuration directory,vi_cv_path_python_conf,
    859. 

  859.       [
    860. 

  860. 	vi_cv_path_python_conf=
    861. 

  861. 	for path in "${vi_cv_path_python_pfx}" "${vi_cv_path_python_epfx}"; do
    862. 

  862. 	  for subdir in lib64 lib share; do
    863. 

  863. 	    d="${path}/${subdir}/python${vi_cv_var_python_version}/config"
    864. 

  864. 	    if test -d "$d" && test -f "$d/config.c"; then
    865. 

  865. 	      vi_cv_path_python_conf="$d"
    866. 

  866. 	    fi
    867. 

  867. 	  done
    868. 

  868. 	done
    869. 

  869.       ])
    870. 

  870. 

  871.       PYTHON_CONFDIR="${vi_cv_path_python_conf}"
    872. 

  872. 

  873.       if test "X$PYTHON_CONFDIR" = "X"; then
    874. 

  874. 	AC_MSG_RESULT([can't find it!])
    875. 

  875.       else
    876. 

  876. 

  877. 	dnl -- we need to examine Python's config/Makefile too
    878. 

  878. 	dnl    see what the interpreter is built from
    879. 

  879. 	AC_CACHE_VAL(vi_cv_path_python_plibs,
    880. 

  880. 	[
    881. 

  881. 	    pwd=`pwd`
    882. 

  882. 	    tmp_mkf="$pwd/config-PyMake$$"
    883. 

  883. 	    cat -- "${PYTHON_CONFDIR}/Makefile" - <<'eof' >"${tmp_mkf}"
    884. 

  884. __:
    885. 

  885. 	@echo "python_BASEMODLIBS='$(BASEMODLIBS)'"
    886. 

  886. 	@echo "python_LIBS='$(LIBS)'"
    887. 

  887. 	@echo "python_SYSLIBS='$(SYSLIBS)'"
    888. 

  888. 	@echo "python_LINKFORSHARED='$(LINKFORSHARED)'"
    889. 

  889. 	@echo "python_INSTSONAME='$(INSTSONAME)'"
    890. 

  890. eof
    891. 

  891. 	    dnl -- delete the lines from make about Entering/Leaving directory
    892. 

  892. 	    eval "`cd ${PYTHON_CONFDIR} && make -f "${tmp_mkf}" __ | sed '/ directory /d'`"
    893. 

  893. 	    rm -f -- "${tmp_mkf}"
    894. 

  894. 	    if test "x$MACOSX" = "xyes" && ${vi_cv_path_python} -c \
    895. 

  895. 		"import sys; sys.exit(${vi_cv_var_python_version} < 2.3)"; then
    896. 

  896. 	      vi_cv_path_python_plibs="-framework Python"
    897. 

  897. 	    else
    898. 

  898. 	      if test "${vi_cv_var_python_version}" = "1.4"; then
    899. 

  899. 		  vi_cv_path_python_plibs="${PYTHON_CONFDIR}/libModules.a ${PYTHON_CONFDIR}/libPython.a ${PYTHON_CONFDIR}/libObjects.a ${PYTHON_CONFDIR}/libParser.a"
    900. 

  900. 	      else
    901. 

  901. 		  vi_cv_path_python_plibs="-L${PYTHON_CONFDIR} -lpython${vi_cv_var_python_version}"
    902. 

  902. 	      fi
    903. 

  903. 	      vi_cv_path_python_plibs="${vi_cv_path_python_plibs} ${python_BASEMODLIBS} ${python_LIBS} ${python_SYSLIBS} ${python_LINKFORSHARED}"
    904. 

  904. 	      dnl remove -ltermcap, it can conflict with an earlier -lncurses
    905. 

  905. 	      vi_cv_path_python_plibs=`echo $vi_cv_path_python_plibs | sed s/-ltermcap//`
    906. 

  906. 	    fi
    907. 

  907. 	])
    908. 

  908. 

  909. 	PYTHON_LIBS="${vi_cv_path_python_plibs}"
    910. 

  910. 	if test "${vi_cv_path_python_pfx}" = "${vi_cv_path_python_epfx}"; then
    911. 

  911. 	  PYTHON_CFLAGS="-I${vi_cv_path_python_pfx}/include/python${vi_cv_var_python_version} -DPYTHON_HOME=\\\"${vi_cv_path_python_pfx}\\\""
    912. 

  912. 	else
    913. 

  913. 	  PYTHON_CFLAGS="-I${vi_cv_path_python_pfx}/include/python${vi_cv_var_python_version} -I${vi_cv_path_python_epfx}/include/python${vi_cv_var_python_version} -DPYTHON_HOME=\\\"${vi_cv_path_python_pfx}\\\""
    914. 

  914. 	fi
    915. 

  915. 	PYTHON_SRC="if_python.c"
    916. 

  916. 	dnl For Mac OSX 10.2 config.o is included in the Python library.
    917. 

  917. 	if test "x$MACOSX" = "xyes"; then
    918. 

  918. 	  PYTHON_OBJ="objects/if_python.o"
    919. 

  919. 	else
    920. 

  920. 	  PYTHON_OBJ="objects/if_python.o objects/py_config.o"
    921. 

  921. 	fi
    922. 

  922. 	if test "${vi_cv_var_python_version}" = "1.4"; then
    923. 

  923. 	   PYTHON_OBJ="$PYTHON_OBJ objects/py_getpath.o"
    924. 

  924. 	fi
    925. 

  925.     PYTHON_GETPATH_CFLAGS="-DPYTHONPATH='\"${vi_cv_path_pythonpath}\"' -DPREFIX='\"${vi_cv_path_python_pfx}\"' -DEXEC_PREFIX='\"${vi_cv_path_python_epfx}\"'"
    926. 

  926. 

  927. 	dnl On FreeBSD linking with "-pthread" is required to use threads.
    928. 

  928. 	dnl _THREAD_SAFE must be used for compiling then.
    929. 

  929. 	dnl The "-pthread" is added to $LIBS, so that the following check for
    930. 

  930. 	dnl sigaltstack() will look in libc_r (it's there in libc!).
    931. 

  931. 	dnl Otherwise, when using GCC, try adding -pthread to $CFLAGS.  GCC
    932. 

  932. 	dnl will then define target-specific defines, e.g., -D_REENTRANT.
    933. 

  933. 	dnl Don't do this for Mac OSX, -pthread will generate a warning.
    934. 

  934. 	AC_MSG_CHECKING([if -pthread should be used])
    935. 

  935. 	threadsafe_flag=
    936. 

  936. 	thread_lib=
    937. 

  937. 	dnl if test "x$MACOSX" != "xyes"; then
    938. 

  938.         if test "`(uname) 2>/dev/null`" != Darwin; then
    939. 

  939. 	  test "$GCC" = yes && threadsafe_flag="-pthread"
    940. 

  940. 	  if test "`(uname) 2>/dev/null`" = FreeBSD; then
    941. 

  941. 	    threadsafe_flag="-D_THREAD_SAFE"
    942. 

  942. 	    thread_lib="-pthread"
    943. 

  943. 	  fi
    944. 

  944. 	fi
    945. 

  945. 	libs_save_old=$LIBS
    946. 

  946. 	if test -n "$threadsafe_flag"; then
    947. 

  947. 	  cflags_save=$CFLAGS
    948. 

  948. 	  CFLAGS="$CFLAGS $threadsafe_flag"
    949. 

  949. 	  LIBS="$LIBS $thread_lib"
    950. 

  950. 	  AC_TRY_LINK(,[ ],
    951. 

  951. 	     AC_MSG_RESULT(yes); PYTHON_CFLAGS="$PYTHON_CFLAGS $threadsafe_flag",
    952. 

  952. 	     AC_MSG_RESULT(no); LIBS=$libs_save_old
    953. 

  953. 	     )
    954. 

  954. 	  CFLAGS=$cflags_save
    955. 

  955. 	else
    956. 

  956. 	  AC_MSG_RESULT(no)
    957. 

  957. 	fi
    958. 

  958. 

  959. 	dnl Check that compiling a simple program still works with the flags
    960. 

  960. 	dnl added for Python.
    961. 

  961. 	AC_MSG_CHECKING([if compile and link flags for Python are sane])
    962. 

  962. 	cflags_save=$CFLAGS
    963. 

  963. 	libs_save=$LIBS
    964. 

  964. 	CFLAGS="$CFLAGS $PYTHON_CFLAGS"
    965. 

  965. 	LIBS="$LIBS $PYTHON_LIBS"
    966. 

  966. 	AC_TRY_LINK(,[ ],
    967. 

  967. 	       AC_MSG_RESULT(yes); python_ok=yes,
    968. 

  968. 	       AC_MSG_RESULT(no: PYTHON DISABLED); python_ok=no)
    969. 

  969. 	CFLAGS=$cflags_save
    970. 

  970. 	LIBS=$libs_save
    971. 

  971. 	if test $python_ok = yes; then
    972. 

  972. 	  AC_DEFINE(FEAT_PYTHON)
    973. 

  973. 	else
    974. 

  974. 	  LIBS=$libs_save_old
    975. 

  975. 	  PYTHON_SRC=
    976. 

  976. 	  PYTHON_OBJ=
    977. 

  977. 	  PYTHON_LIBS=
    978. 

  978. 	  PYTHON_CFLAGS=
    979. 

  979. 	fi
    980. 

  980. 

  981.       fi
    982. 

  982.     else
    983. 

  983.       AC_MSG_RESULT(too old)
    984. 

  984.     fi
    985. 

  985.   fi
    986. 

  986. 

  987.   if test "$fail_if_missing" = "yes" -a "$python_ok" != "yes"; then
    988. 

  988.     AC_MSG_ERROR([could not configure python])
    989. 

  989.   fi
    990. 

  990. fi
    991. 

  991. 

  992. AC_SUBST(PYTHON_CONFDIR)
    993. 

  993. AC_SUBST(PYTHON_LIBS)
    994. 

  994. AC_SUBST(PYTHON_GETPATH_CFLAGS)
    995. 

  995. AC_SUBST(PYTHON_CFLAGS)
    996. 

  996. AC_SUBST(PYTHON_SRC)
    997. 

  997. AC_SUBST(PYTHON_OBJ)
    998. 

  998. 

  999. 

  1000. AC_MSG_CHECKING(--enable-python3interp argument)
    1001. 

  1001. AC_ARG_ENABLE(python3interp,
    1002. 

  1002. 	[  --enable-python3interp[=OPTS]   Include Python3 interpreter. [default=no] [OPTS=no/yes/dynamic]], ,
    1003. 

  1003. 	[enable_python3interp="no"])
    1004. 

  1004. AC_MSG_RESULT($enable_python3interp)
    1005. 

  1005. if test "$enable_python3interp" = "yes" -o "$enable_python3interp" = "dynamic"; then
    1006. 

  1006.   dnl -- find the python3 executable
    1007. 

  1007.   AC_PATH_PROG(vi_cv_path_python3, python3)
    1008. 

  1008.   if test "X$vi_cv_path_python3" != "X"; then
    1009. 

  1009. 

  1010.     dnl -- get its version number
    1011. 

  1011.     AC_CACHE_CHECK(Python version,vi_cv_var_python3_version,
    1012. 

  1012.     [[vi_cv_var_python3_version=`
    1013. 

  1013.           ${vi_cv_path_python3} -c 'import sys; print(sys.version[:3])'`
    1014. 

  1014.     ]])
    1015. 

  1015. 

  1016.     dnl -- get abiflags for python 3.2 or higher (PEP 3149)
    1017. 

  1017.     AC_CACHE_CHECK(Python's abiflags,vi_cv_var_python3_abiflags,
    1018. 

  1018.     [
    1019. 

  1019.      vi_cv_var_python3_abiflags=
    1020. 

  1020.      if ${vi_cv_path_python3} -c \
    1021. 

  1021.          "import sys; sys.exit(${vi_cv_var_python3_version} < 3.2)"
    1022. 

  1022.      then
    1023. 

  1023.        vi_cv_var_python3_abiflags=`${vi_cv_path_python3} -c \    
    1024. 

  1024.          "import sys; print(sys.abiflags)"`
    1025. 

  1025.      fi ])
    1026. 

  1026. 

  1027.     dnl -- find where python3 thinks it was installed
    1028. 

  1028.     AC_CACHE_CHECK(Python's install prefix,vi_cv_path_python3_pfx,
    1029. 

  1029.     [ vi_cv_path_python3_pfx=`
    1030. 

  1030.      ${vi_cv_path_python3} -c \
    1031. 

  1031.      "import sys; print(sys.prefix)"` ])
    1032. 

  1032. 

  1033.     dnl -- and where it thinks it runs
    1034. 

  1034.     AC_CACHE_CHECK(Python's execution prefix,vi_cv_path_python3_epfx,
    1035. 

  1035.     [ vi_cv_path_python3_epfx=`
    1036. 

  1036.      ${vi_cv_path_python3} -c \
    1037. 

  1037.      "import sys; print(sys.exec_prefix)"` ])
    1038. 

  1038. 

  1039.     dnl -- python3's internal library path
    1040. 

    1041. 

  1041.     AC_CACHE_VAL(vi_cv_path_python3path,
    1042. 

  1042.     [ vi_cv_path_python3path=`
    1043. 

  1043.      unset PYTHONPATH;
    1044. 

  1044.      ${vi_cv_path_python3} -c \
    1045. 

  1045.      "import sys, string; print(':'.join(sys.path))"` ])
    1046. 

  1046. 

  1047.     dnl -- where the Python implementation library archives are
    1048. 

  1048. 

  1049.     AC_ARG_WITH(python3-config-dir,
    1050. 

  1050.      [  --with-python3-config-dir=PATH  Python's config directory],
    1051. 

  1051.      [ vi_cv_path_python3_conf="${withval}" ] )
    1052. 

  1052. 

  1053.     AC_CACHE_CHECK(Python's configuration directory,vi_cv_path_python3_conf,
    1054. 

  1054.     [
    1055. 

  1055.      vi_cv_path_python3_conf=
    1056. 

  1056.      config_dir="config"
    1057. 

  1057.      if test "${vi_cv_var_python3_abiflags}" != ""; then
    1058. 

  1058.        config_dir="${config_dir}-${vi_cv_var_python3_version}${vi_cv_var_python3_abiflags}"
    1059. 

  1059.      fi
    1060. 

  1060.      for path in "${vi_cv_path_python3_pfx}" "${vi_cv_path_python3_epfx}"; do
    1061. 

  1061.        for subdir in lib64 lib share; do
    1062. 

  1062.          d="${path}/${subdir}/python${vi_cv_var_python3_version}/${config_dir}"
    1063. 

  1063.          if test -d "$d" && test -f "$d/config.c"; then
    1064. 

  1064.            vi_cv_path_python3_conf="$d"
    1065. 

  1065.          fi
    1066. 

  1066.        done
    1067. 

  1067.      done
    1068. 

  1068.     ])
    1069. 

  1069. 

  1070.     PYTHON3_CONFDIR="${vi_cv_path_python3_conf}"
    1071. 

  1071. 

  1072.     if test "X$PYTHON3_CONFDIR" = "X"; then
    1073. 

  1073.       AC_MSG_RESULT([can't find it!])
    1074. 

  1074.     else
    1075. 

  1075. 

  1076.       dnl -- we need to examine Python's config/Makefile too
    1077. 

  1077.       dnl    see what the interpreter is built from
    1078. 

  1078.       AC_CACHE_VAL(vi_cv_path_python3_plibs,
    1079. 

  1079.       [
    1080. 

  1080.           pwd=`pwd`
    1081. 

  1081.           tmp_mkf="$pwd/config-PyMake$$"
    1082. 

  1082.           cat -- "${PYTHON3_CONFDIR}/Makefile" - <<'eof' >"${tmp_mkf}"
    1083. 

  1083. __:
    1084. 

  1084. 	@echo "python3_BASEMODLIBS='$(BASEMODLIBS)'"
    1085. 

  1085. 	@echo "python3_LIBS='$(LIBS)'"
    1086. 

  1086. 	@echo "python3_SYSLIBS='$(SYSLIBS)'"
    1087. 

  1087. 	@echo "python3_INSTSONAME='$(INSTSONAME)'"
    1088. 

  1088. eof
    1089. 

  1089.           dnl -- delete the lines from make about Entering/Leaving directory
    1090. 

  1090.           eval "`cd ${PYTHON3_CONFDIR} && make -f "${tmp_mkf}" __ | sed '/ directory /d'`"
    1091. 

  1091.           rm -f -- "${tmp_mkf}"
    1092. 

  1092. 	  vi_cv_path_python3_plibs="-L${PYTHON3_CONFDIR} -lpython${vi_cv_var_python3_version}${vi_cv_var_python3_abiflags}"
    1093. 

  1093.           vi_cv_path_python3_plibs="${vi_cv_path_python3_plibs} ${python3_BASEMODLIBS} ${python3_LIBS} ${python3_SYSLIBS}"
    1094. 

  1094.           dnl remove -ltermcap, it can conflict with an earlier -lncurses
    1095. 

  1095.           vi_cv_path_python3_plibs=`echo $vi_cv_path_python3_plibs | sed s/-ltermcap//`
    1096. 

  1096.           vi_cv_path_python3_plibs=`echo $vi_cv_path_python3_plibs | sed s/-lffi//`
    1097. 

  1097.       ])
    1098. 

  1098. 

  1099.       PYTHON3_LIBS="${vi_cv_path_python3_plibs}"
    1100. 

  1100.       if test "${vi_cv_path_python3_pfx}" = "${vi_cv_path_python3_epfx}"; then
    1101. 

  1101.         PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python${vi_cv_var_python3_version}${vi_cv_var_python3_abiflags} -DPYTHON3_HOME=L\\\"${vi_cv_path_python3_pfx}\\\""
    1102. 

  1102.       else
    1103. 

  1103.         PYTHON3_CFLAGS="-I${vi_cv_path_python3_pfx}/include/python${vi_cv_var_python3_version}${vi_cv_var_python3_abiflags} -I${vi_cv_path_python3_epfx}/include/python${vi_cv_var_python3_version}${vi_cv_var_python3_abiflags} -DPYTHON3_HOME=L\\\"${vi_cv_path_python3_pfx}\\\""
    1104. 

  1104.       fi
    1105. 

  1105.       PYTHON3_SRC="if_python3.c"
    1106. 

  1106.       dnl For Mac OSX 10.2 config.o is included in the Python library.
    1107. 

  1107.       if test "x$MACOSX" = "xyes"; then
    1108. 

  1108.         PYTHON3_OBJ="objects/if_python3.o"
    1109. 

  1109.       else
    1110. 

  1110.         PYTHON3_OBJ="objects/if_python3.o objects/py3_config.o"
    1111. 

  1111.       fi
    1112. 

  1112. 

  1113.       dnl On FreeBSD linking with "-pthread" is required to use threads.
    1114. 

  1114.       dnl _THREAD_SAFE must be used for compiling then.
    1115. 

  1115.       dnl The "-pthread" is added to $LIBS, so that the following check for
    1116. 

  1116.       dnl sigaltstack() will look in libc_r (it's there in libc!).
    1117. 

  1117.       dnl Otherwise, when using GCC, try adding -pthread to $CFLAGS.  GCC
    1118. 

  1118.       dnl will then define target-specific defines, e.g., -D_REENTRANT.
    1119. 

  1119.       dnl Don't do this for Mac OSX, -pthread will generate a warning.
    1120. 

  1120.       AC_MSG_CHECKING([if -pthread should be used])
    1121. 

  1121.       threadsafe_flag=
    1122. 

  1122.       thread_lib=
    1123. 

  1123.       dnl if test "x$MACOSX" != "xyes"; then
    1124. 

  1124.       if test "`(uname) 2>/dev/null`" != Darwin; then
    1125. 

  1125.         test "$GCC" = yes && threadsafe_flag="-pthread"
    1126. 

  1126.         if test "`(uname) 2>/dev/null`" = FreeBSD; then
    1127. 

  1127.           threadsafe_flag="-D_THREAD_SAFE"
    1128. 

  1128.           thread_lib="-pthread"
    1129. 

  1129.         fi
    1130. 

  1130.       fi
    1131. 

  1131.       libs_save_old=$LIBS
    1132. 

  1132.       if test -n "$threadsafe_flag"; then
    1133. 

  1133.         cflags_save=$CFLAGS
    1134. 

  1134.         CFLAGS="$CFLAGS $threadsafe_flag"
    1135. 

  1135.         LIBS="$LIBS $thread_lib"
    1136. 

  1136.         AC_TRY_LINK(,[ ],
    1137. 

  1137.            AC_MSG_RESULT(yes); PYTHON3_CFLAGS="$PYTHON3_CFLAGS $threadsafe_flag",
    1138. 

  1138.            AC_MSG_RESULT(no); LIBS=$libs_save_old
    1139. 

  1139.            )
    1140. 

  1140.         CFLAGS=$cflags_save
    1141. 

  1141.       else
    1142. 

  1142.         AC_MSG_RESULT(no)
    1143. 

  1143.       fi
    1144. 

  1144. 

  1145.       dnl check that compiling a simple program still works with the flags
    1146. 

  1146.       dnl added for Python.
    1147. 

  1147.       AC_MSG_CHECKING([if compile and link flags for Python 3 are sane])
    1148. 

  1148.       cflags_save=$CFLAGS
    1149. 

  1149.       libs_save=$LIBS
    1150. 

  1150.       CFLAGS="$CFLAGS $PYTHON3_CFLAGS"
    1151. 

  1151.       LIBS="$LIBS $PYTHON3_LIBS"
    1152. 

  1152.       AC_TRY_LINK(,[ ],
    1153. 

  1153.              AC_MSG_RESULT(yes); python3_ok=yes,
    1154. 

  1154.              AC_MSG_RESULT(no: PYTHON3 DISABLED); python3_ok=no)
    1155. 

  1155.       CFLAGS=$cflags_save
    1156. 

  1156.       LIBS=$libs_save
    1157. 

  1157.       if test "$python3_ok" = yes; then
    1158. 

  1158.         AC_DEFINE(FEAT_PYTHON3)
    1159. 

  1159.       else
    1160. 

  1160.         LIBS=$libs_save_old
    1161. 

  1161.         PYTHON3_SRC=
    1162. 

  1162.         PYTHON3_OBJ=
    1163. 

  1163.         PYTHON3_LIBS=
    1164. 

  1164.         PYTHON3_CFLAGS=
    1165. 

  1165.       fi
    1166. 

  1166.     fi
    1167. 

  1167.   fi
    1168. 

  1168. fi
    1169. 

  1169. 

  1170. AC_SUBST(PYTHON3_CONFDIR)
    1171. 

  1171. AC_SUBST(PYTHON3_LIBS)
    1172. 

  1172. AC_SUBST(PYTHON3_CFLAGS)
    1173. 

  1173. AC_SUBST(PYTHON3_SRC)
    1174. 

  1174. AC_SUBST(PYTHON3_OBJ)
    1175. 

  1175. 

  1176. dnl if python2.x and python3.x are enabled one can only link in code
    1177. 

  1177. dnl with dlopen(), dlsym(), dlclose() 
    1178. 

  1178. if test "$python_ok" = yes && test "$python3_ok" = yes; then
    1179. 

  1179.   AC_DEFINE(DYNAMIC_PYTHON)
    1180. 

  1180.   AC_DEFINE(DYNAMIC_PYTHON3)
    1181. 

  1181.   AC_MSG_CHECKING(whether we can do without RTLD_GLOBAL for Python)
    1182. 

  1182.   cflags_save=$CFLAGS
    1183. 

  1183.   CFLAGS="$CFLAGS $PYTHON_CFLAGS"
    1184. 

  1184.   ldflags_save=$LDFLAGS
    1185. 

  1185.   dnl -ldl must go first to make this work on Archlinux (Roland Puntaier)
    1186. 

  1186.   LDFLAGS="-ldl $LDFLAGS"
    1187. 

  1187.   AC_RUN_IFELSE([
    1188. 

  1188.     #include <dlfcn.h>
    1189. 

  1189.     /* If this program fails, then RTLD_GLOBAL is needed.
    1190. 

  1190.      * RTLD_GLOBAL will be used and then it is not possible to
    1191. 

  1191.      * have both python versions enabled in the same vim instance.
    1192. 

  1192.      * Only the first pyhton version used will be switched on.
    1193. 

  1193.      */
    1194. 

  1194. 

  1195.     int no_rtl_global_needed_for(char *python_instsoname, char *prefix)
    1196. 

  1196.     {
    1197. 

  1197.       int needed = 0;
    1198. 

  1198.       void* pylib = dlopen(python_instsoname, RTLD_LAZY);
    1199. 

  1199.       if (pylib != 0)
    1200. 

  1200.       {
    1201. 

  1201.           void (*pfx)(char *home) = dlsym(pylib, "Py_SetPythonHome");
    1202. 

  1202.           void (*init)(void) = dlsym(pylib, "Py_Initialize");
    1203. 

  1203.           int (*simple)(char*) = dlsym(pylib, "PyRun_SimpleString");
    1204. 

  1204.           void (*final)(void) = dlsym(pylib, "Py_Finalize");
    1205. 

  1205.           (*pfx)(prefix);
    1206. 

  1206.           (*init)();
    1207. 

  1207.           needed = (*simple)("import termios") == -1;
    1208. 

  1208.           (*final)();
    1209. 

  1209.           dlclose(pylib);
    1210. 

  1210.       }
    1211. 

  1211.       return !needed;
    1212. 

  1212.     }
    1213. 

  1213. 

  1214.     int main(int argc, char** argv)
    1215. 

  1215.     {
    1216. 

  1216.       int not_needed = 0;
    1217. 

  1217.       if (no_rtl_global_needed_for("${python_INSTSONAME}", "${vi_cv_path_python_pfx}"))
    1218. 

  1218.             not_needed = 1;
    1219. 

  1219.       return !not_needed;
    1220. 

  1220.     }],
    1221. 

  1221.     [AC_MSG_RESULT(yes);AC_DEFINE(PY_NO_RTLD_GLOBAL)], [AC_MSG_RESULT(no)])
    1222. 

  1222. 

  1223.   CFLAGS=$cflags_save
    1224. 

  1224.   LDFLAGS=$ldflags_save
    1225. 

  1225. 

  1226.   AC_MSG_CHECKING(whether we can do without RTLD_GLOBAL for Python3)
    1227. 

  1227.   cflags_save=$CFLAGS
    1228. 

  1228.   CFLAGS="$CFLAGS $PYTHON3_CFLAGS"
    1229. 

  1229.   ldflags_save=$LDFLAGS
    1230. 

  1230.   dnl -ldl must go first to make this work on Archlinux (Roland Puntaier)
    1231. 

  1231.   LDFLAGS="-ldl $LDFLAGS"
    1232. 

  1232.   AC_RUN_IFELSE([
    1233. 

  1233.     #include <dlfcn.h>
    1234. 

  1234.     #include <wchar.h>
    1235. 

  1235.     /* If this program fails, then RTLD_GLOBAL is needed.
    1236. 

  1236.      * RTLD_GLOBAL will be used and then it is not possible to
    1237. 

  1237.      * have both python versions enabled in the same vim instance.
    1238. 

  1238.      * Only the first pyhton version used will be switched on.
    1239. 

  1239.      */
    1240. 

  1240. 

  1241.     int no_rtl_global_needed_for(char *python_instsoname, wchar_t *prefix)
    1242. 

  1242.     {
    1243. 

  1243.       int needed = 0;
    1244. 

  1244.       void* pylib = dlopen(python_instsoname, RTLD_LAZY);
    1245. 

  1245.       if (pylib != 0)
    1246. 

  1246.       {
    1247. 

  1247.           void (*pfx)(wchar_t *home) = dlsym(pylib, "Py_SetPythonHome");
    1248. 

  1248.           void (*init)(void) = dlsym(pylib, "Py_Initialize");
    1249. 

  1249.           int (*simple)(char*) = dlsym(pylib, "PyRun_SimpleString");
    1250. 

  1250.           void (*final)(void) = dlsym(pylib, "Py_Finalize");
    1251. 

  1251.           (*pfx)(prefix);
    1252. 

  1252.           (*init)();
    1253. 

  1253.           needed = (*simple)("import termios") == -1;
    1254. 

  1254.           (*final)();
    1255. 

  1255.           dlclose(pylib);
    1256. 

  1256.       }
    1257. 

  1257.       return !needed;
    1258. 

  1258.     }
    1259. 

  1259. 

  1260.     int main(int argc, char** argv)
    1261. 

  1261.     {
    1262. 

  1262.       int not_needed = 0;
    1263. 

  1263.       if (no_rtl_global_needed_for("${python3_INSTSONAME}", L"${vi_cv_path_python3_pfx}"))
    1264. 

  1264.             not_needed = 1;
    1265. 

  1265.       return !not_needed;
    1266. 

  1266.     }],
    1267. 

  1267.     [AC_MSG_RESULT(yes);AC_DEFINE(PY3_NO_RTLD_GLOBAL)], [AC_MSG_RESULT(no)])
    1268. 

  1268. 

  1269.   CFLAGS=$cflags_save
    1270. 

  1270.   LDFLAGS=$ldflags_save
    1271. 

  1271. 

  1272.   PYTHON_SRC="if_python.c"
    1273. 

  1273.   PYTHON_OBJ="objects/if_python.o"
    1274. 

  1274.   PYTHON_CFLAGS="$PYTHON_CFLAGS -DDYNAMIC_PYTHON_DLL=\\\"${python_INSTSONAME}\\\""
    1275. 

  1275.   PYTHON_LIBS=
    1276. 

  1276.   PYTHON3_SRC="if_python3.c"
    1277. 

  1277.   PYTHON3_OBJ="objects/if_python3.o"
    1278. 

  1278.   PYTHON3_CFLAGS="$PYTHON3_CFLAGS -DDYNAMIC_PYTHON3_DLL=\\\"${python3_INSTSONAME}\\\""
    1279. 

  1279.   PYTHON3_LIBS=
    1280. 

  1280. elif test "$python_ok" = yes && test "$enable_pythoninterp" = "dynamic"; then
    1281. 

  1281.   AC_DEFINE(DYNAMIC_PYTHON)
    1282. 

  1282.   PYTHON_SRC="if_python.c"
    1283. 

  1283.   PYTHON_OBJ="objects/if_python.o"
    1284. 

  1284.   PYTHON_CFLAGS="$PYTHON_CFLAGS -DDYNAMIC_PYTHON_DLL=\\\"${python_INSTSONAME}\\\""
    1285. 

  1285.   PYTHON_LIBS=
    1286. 

  1286. elif test "$python3_ok" = yes && test "$enable_python3interp" = "dynamic"; then
    1287. 

  1287.   AC_DEFINE(DYNAMIC_PYTHON3)
    1288. 

  1288.   PYTHON3_SRC="if_python3.c"
    1289. 

  1289.   PYTHON3_OBJ="objects/if_python3.o"
    1290. 

  1290.   PYTHON3_CFLAGS="$PYTHON3_CFLAGS -DDYNAMIC_PYTHON3_DLL=\\\"${python3_INSTSONAME}\\\""
    1291. 

  1291.   PYTHON3_LIBS=
    1292. 

  1292. fi
    1293. 

  1293. 

  1294. AC_MSG_CHECKING(--enable-tclinterp argument)
    1295. 

  1295. AC_ARG_ENABLE(tclinterp,
    1296. 

  1296. 	[  --enable-tclinterp      Include Tcl interpreter.], ,
    1297. 

  1297. 	[enable_tclinterp="no"])
    1298. 

  1298. AC_MSG_RESULT($enable_tclinterp)
    1299. 

  1299. 

  1300. if test "$enable_tclinterp" = "yes"; then
    1301. 

  1301. 

  1302.   dnl on FreeBSD tclsh is a silly script, look for tclsh8.[5420]
    1303. 

  1303.   AC_MSG_CHECKING(--with-tclsh argument)
    1304. 

  1304.   AC_ARG_WITH(tclsh, [  --with-tclsh=PATH       which tclsh to use (default: tclsh8.0)],
    1305. 

  1305. 	tclsh_name="$withval"; AC_MSG_RESULT($tclsh_name),
    1306. 

  1306. 	tclsh_name="tclsh8.5"; AC_MSG_RESULT(no))
    1307. 

  1307.   AC_PATH_PROG(vi_cv_path_tcl, $tclsh_name)
    1308. 

  1308.   AC_SUBST(vi_cv_path_tcl)
    1309. 

  1309. 

  1310.   dnl when no specific version specified, also try 8.4, 8.2 and 8.0
    1311. 

  1311.   if test "X$vi_cv_path_tcl" = "X" -a $tclsh_name = "tclsh8.5"; then
    1312. 

  1312.     tclsh_name="tclsh8.4"
    1313. 

  1313.     AC_PATH_PROG(vi_cv_path_tcl, $tclsh_name)
    1314. 

  1314.   fi
    1315. 

  1315.   if test "X$vi_cv_path_tcl" = "X" -a $tclsh_name = "tclsh8.4"; then
    1316. 

  1316.     tclsh_name="tclsh8.2"
    1317. 

  1317.     AC_PATH_PROG(vi_cv_path_tcl, $tclsh_name)
    1318. 

  1318.   fi
    1319. 

  1319.   if test "X$vi_cv_path_tcl" = "X" -a $tclsh_name = "tclsh8.2"; then
    1320. 

  1320.     tclsh_name="tclsh8.0"
    1321. 

  1321.     AC_PATH_PROG(vi_cv_path_tcl, $tclsh_name)
    1322. 

  1322.   fi
    1323. 

  1323.   dnl still didn't find it, try without version number
    1324. 

  1324.   if test "X$vi_cv_path_tcl" = "X"; then
    1325. 

  1325.     tclsh_name="tclsh"
    1326. 

  1326.     AC_PATH_PROG(vi_cv_path_tcl, $tclsh_name)
    1327. 

  1327.   fi
    1328. 

  1328.   if test "X$vi_cv_path_tcl" != "X"; then
    1329. 

  1329.     AC_MSG_CHECKING(Tcl version)
    1330. 

  1330.     if echo 'exit [[expr [info tclversion] < 8.0]]' | $vi_cv_path_tcl - ; then
    1331. 

  1331.       tclver=`echo 'puts [[info tclversion]]' | $vi_cv_path_tcl -`
    1332. 

  1332.       AC_MSG_RESULT($tclver - OK);
    1333. 

  1333.       tclloc=`echo 'set l [[info library]];set i [[string last lib $l]];incr i -2;puts [[string range $l 0 $i]]' | $vi_cv_path_tcl -`
    1334. 

  1334. 

  1335.       AC_MSG_CHECKING(for location of Tcl include)
    1336. 

  1336.       if test "x$MACOSX" != "xyes"; then
    1337. 

  1337. 	tclinc="$tclloc/include $tclloc/include/tcl $tclloc/include/tcl$tclver /usr/local/include /usr/local/include/tcl$tclver /usr/include /usr/include/tcl$tclver"
    1338. 

  1338.       else
    1339. 

  1339. 	dnl For Mac OS X 10.3, use the OS-provided framework location
    1340. 

  1340. 	tclinc="/System/Library/Frameworks/Tcl.framework/Headers"
    1341. 

  1341.       fi
    1342. 

  1342.       TCL_INC=
    1343. 

  1343.       for try in $tclinc; do
    1344. 

  1344. 	if test -f "$try/tcl.h"; then
    1345. 

  1345. 	  AC_MSG_RESULT($try/tcl.h)
    1346. 

  1346. 	  TCL_INC=$try
    1347. 

  1347. 	  break
    1348. 

  1348. 	fi
    1349. 

  1349.       done
    1350. 

  1350.       if test -z "$TCL_INC"; then
    1351. 

  1351. 	AC_MSG_RESULT(<not found>)
    1352. 

  1352. 	SKIP_TCL=YES
    1353. 

  1353.       fi
    1354. 

  1354.       if test -z "$SKIP_TCL"; then
    1355. 

  1355. 	AC_MSG_CHECKING(for location of tclConfig.sh script)
    1356. 

  1356. 	if test "x$MACOSX" != "xyes"; then
    1357. 

  1357. 	  tclcnf=`echo $tclinc | sed s/include/lib/g`
    1358. 

  1358. 	  tclcnf="$tclcnf `echo $tclinc | sed s/include/lib64/g`"
    1359. 

  1359. 	else
    1360. 

  1360. 	  dnl For Mac OS X 10.3, use the OS-provided framework location
    1361. 

  1361. 	  tclcnf="/System/Library/Frameworks/Tcl.framework"
    1362. 

  1362. 	fi
    1363. 

  1363. 	for try in $tclcnf; do
    1364. 

  1364. 	  if test -f $try/tclConfig.sh; then
    1365. 

  1365. 	    AC_MSG_RESULT($try/tclConfig.sh)
    1366. 

  1366. 	    . $try/tclConfig.sh
    1367. 

  1367. 	    dnl use eval, because tcl 8.2 includes ${TCL_DBGX}
    1368. 

  1368. 	    TCL_LIBS=`eval echo "$TCL_LIB_SPEC $TCL_LIBS"`
    1369. 

  1369. 	    dnl Use $TCL_DEFS for -D_THREAD_SAFE et al.  But only use the
    1370. 

  1370. 	    dnl "-D_ABC" items.  Watch out for -DFOO=long\ long.
    1371. 

  1371. 	    TCL_DEFS=`echo $TCL_DEFS | sed -e 's/\\\\ /\\\\X/g' | tr ' ' '\012' | sed -e '/^[[^-]]/d' -e '/^-[[^D]]/d' -e '/-D[[^_]]/d' -e 's/-D_/ -D_/' | tr '\012' ' ' | sed -e 's/\\\\X/\\\\ /g'`
    1372. 

  1372. 	    break
    1373. 

  1373. 	  fi
    1374. 

  1374. 	done
    1375. 

  1375. 	if test -z "$TCL_LIBS"; then
    1376. 

  1376. 	  AC_MSG_RESULT(<not found>)
    1377. 

  1377. 	  AC_MSG_CHECKING(for Tcl library by myself)
    1378. 

  1378. 	  tcllib=`echo $tclinc | sed s/include/lib/g`
    1379. 

  1379. 	  tclli…
    1380.