bootstrap 47.8 KB
Newer Older
1
#!/bin/sh
2
3
# Distributed under the OSI-approved BSD 3-Clause License.  See accompanying
# file Copyright.txt or https://cmake.org/licensing for details.
4

5
6
7
8
die() {
  echo "$@" 1>&2 ; exit 1
}

9
10
11
# Compile flag extraction function.
cmake_extract_standard_flags()
{
12
  sed -n "s/ *set *( *CMAKE_${2}${3}_EXTENSION_COMPILE_OPTION *\"\{0,1\}\([^\")]*\).*/\1/p" \
13
    "${cmake_source_dir}/Modules/Compiler/"${1:-*}-${2}.cmake 2>/dev/null | tr ';' ' '
14
15
}

16
17
18
# Version number extraction function.
cmake_version_component()
{
19
  sed -n "
20
/^set(CMake_VERSION_${1}/ {s/set(CMake_VERSION_${1} *\([0-9]*\))/\1/;p;}
21
" "${cmake_source_dir}/Source/CMakeVersion.cmake"
22
23
}

24
25
26
# Install destination extraction function.
cmake_install_dest_default()
{
27
  sed -n '
28
/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT.*) # '"${2}"'$/ {
29
30
31
32
33
34
35
  s/^ *set(CMAKE_'"${1}"'_DIR_DEFAULT *"\([^"]*\)").*$/\1/
  s/${CMake_VERSION_MAJOR}/'"${cmake_version_major}"'/
  s/${CMake_VERSION_MINOR}/'"${cmake_version_minor}"'/
  s/${CMake_VERSION_PATCH}/'"${cmake_version_patch}"'/
  p
  q
}
36
' "${cmake_source_dir}/Source/CMakeInstallDestinations.cmake"
37
38
}

39
40
cmake_toupper()
{
41
    echo "$1" | tr '[:lower:]' '[:upper:]'
42
43
}

44
45
# Detect system and directory information.
cmake_system=`uname`
46
cmake_source_dir=`cd "\`dirname \"$0\"\`";pwd`
47
cmake_binary_dir=`pwd`
48
49

# Load version information.
50
51
cmake_version_major="`cmake_version_component MAJOR`"
cmake_version_minor="`cmake_version_component MINOR`"
52
53
cmake_version_patch="`cmake_version_component PATCH`"
cmake_version="${cmake_version_major}.${cmake_version_minor}.${cmake_version_patch}"
54
55
56
57
cmake_version_rc="`cmake_version_component RC`"
if [ "$cmake_version_rc" != "" ]; then
  cmake_version="${cmake_version}-rc${cmake_version_rc}"
fi
58

59
60
cmake_copyright="`grep '^Copyright .* Kitware' "${cmake_source_dir}/Copyright.txt"`"

61
cmake_bin_dir_keyword="OTHER"
62
63
64
cmake_data_dir_keyword="OTHER"
cmake_doc_dir_keyword="OTHER"
cmake_man_dir_keyword="OTHER"
65
cmake_xdgdata_dir_keyword="OTHER"
66
cmake_bin_dir=""
67
68
69
cmake_data_dir=""
cmake_doc_dir=""
cmake_man_dir=""
70
cmake_xdgdata_dir=""
71
cmake_init_file=""
72
cmake_bootstrap_system_libs=""
73
74
cmake_bootstrap_qt_gui=""
cmake_bootstrap_qt_qmake=""
75
76
cmake_sphinx_man=""
cmake_sphinx_html=""
77
cmake_sphinx_qthelp=""
78
cmake_sphinx_build=""
79
cmake_sphinx_flags=""
80

81
# Determine whether this is a Cygwin environment.
82
if echo "${cmake_system}" | grep CYGWIN >/dev/null 2>&1; then
83
  cmake_system_cygwin=true
84
85
  cmake_doc_dir_keyword="CYGWIN"
  cmake_man_dir_keyword="CYGWIN"
86
87
88
89
else
  cmake_system_cygwin=false
fi

90
# Determine whether this is a MinGW environment.
91
if echo "${cmake_system}" | grep 'MINGW\|MSYS' >/dev/null 2>&1; then
92
93
94
95
96
  cmake_system_mingw=true
else
  cmake_system_mingw=false
fi

97
# Determine whether this is OS X
98
if echo "${cmake_system}" | grep Darwin >/dev/null 2>&1; then
99
100
101
102
103
  cmake_system_darwin=true
else
  cmake_system_darwin=false
fi

104
# Determine whether this is BeOS
105
if echo "${cmake_system}" | grep BeOS >/dev/null 2>&1; then
106
  cmake_system_beos=true
107
108
  cmake_doc_dir_keyword="HAIKU"
  cmake_man_dir_keyword="HAIKU"
109
110
111
112
else
  cmake_system_beos=false
fi

113
# Determine whether this is Haiku
114
if echo "${cmake_system}" | grep Haiku >/dev/null 2>&1; then
115
  cmake_system_haiku=true
116
117
  cmake_doc_dir_keyword="HAIKU"
  cmake_man_dir_keyword="HAIKU"
118
119
120
121
else
  cmake_system_haiku=false
fi

122
# Determine whether this is OpenVMS
123
if echo "${cmake_system}" | grep OpenVMS >/dev/null 2>&1; then
124
125
126
127
128
  cmake_system_openvms=true
else
  cmake_system_openvms=false
fi

129
# Determine whether this is HP-UX
130
if echo "${cmake_system}" | grep HP-UX >/dev/null 2>&1; then
131
132
133
134
135
  die 'CMake no longer compiles on HP-UX.  See

  https://gitlab.kitware.com/cmake/cmake/issues/17137

Use CMake 3.9 or lower instead.'
136
137
138
139
140
  cmake_system_hpux=true
else
  cmake_system_hpux=false
fi

141
# Determine whether this is Linux
142
if echo "${cmake_system}" | grep Linux >/dev/null 2>&1; then
143
  cmake_system_linux=true
144
145
146
147
148
149
150
151
152
else
  cmake_system_linux=false
 fi

# Determine whether this is a PA-RISC machine
# This only works for Linux or HP-UX, not other PA-RISC OSs (BSD maybe?). Also
# may falsely detect parisc on HP-UX m68k
cmake_machine_parisc=false
if ${cmake_system_linux}; then
153
  if uname -m | grep parisc >/dev/null 2>&1; then
154
155
    cmake_machine_parisc=true
  fi
156
elif ${cmake_system_hpux}; then
157
  if uname -m | grep ia64 >/dev/null 2>&1; then : ; else
158
159
    cmake_machine_parisc=true
  fi
160
161
fi

162
163
164
165
166
167
168
169
170
# Choose the generator to use for bootstrapping.
if ${cmake_system_mingw}; then
  # Bootstrapping from an MSYS prompt.
  cmake_bootstrap_generator="MSYS Makefiles"
else
  # Bootstrapping from a standard UNIX prompt.
  cmake_bootstrap_generator="Unix Makefiles"
fi

171
172
173
174
175
176
177
178
179
180
181
182
183
184
# Choose tools and extensions for this platform.
if ${cmake_system_openvms}; then
  _tmp="_tmp"
  _cmk="_cmk"
  _diff=`which diff`
else
  _tmp=".tmp"
  _cmk=".cmk"
  _diff="diff"
fi

# Construct bootstrap directory name.
cmake_bootstrap_dir="${cmake_binary_dir}/Bootstrap${_cmk}"

185
# Helper function to fix windows paths.
186
187
188
189
190
191
192
193
194
195
196
197
198
199
case "${cmake_system}" in
*MINGW*)
  cmake_fix_slashes()
  {
    cmd //c echo "$(echo "$1" | sed 's/\\/\//g')" | sed 's/^"//;s/" *$//'
  }
  ;;
*)
  cmake_fix_slashes()
  {
    echo "$1" | sed 's/\\/\//g'
  }
  ;;
esac
200
201
202
203
204
205
206
207
208
209
210
211
212
213

# Choose the default install prefix.
if ${cmake_system_mingw}; then
  if [ "x${PROGRAMFILES}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${PROGRAMFILES}/CMake"`
  elif [ "x${ProgramFiles}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${ProgramFiles}/CMake"`
  elif [ "x${SYSTEMDRIVE}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${SYSTEMDRIVE}/Program Files/CMake"`
  elif [ "x${SystemDrive}" != "x" ]; then
    cmake_default_prefix=`cmake_fix_slashes "${SystemDrive}/Program Files/CMake"`
  else
    cmake_default_prefix="c:/Program Files/CMake"
  fi
214
elif ${cmake_system_haiku}; then
215
  cmake_default_prefix=`finddir B_COMMON_DIRECTORY`
216
217
218
219
else
  cmake_default_prefix="/usr/local"
fi

220
# Lookup default install destinations.
221
cmake_bin_dir_default="`cmake_install_dest_default BIN ${cmake_bin_dir_keyword}`"
222
223
224
cmake_data_dir_default="`cmake_install_dest_default DATA ${cmake_data_dir_keyword}`"
cmake_doc_dir_default="`cmake_install_dest_default DOC ${cmake_doc_dir_keyword}`"
cmake_man_dir_default="`cmake_install_dest_default MAN ${cmake_man_dir_keyword}`"
225
cmake_xdgdata_dir_default="`cmake_install_dest_default XDGDATA ${cmake_xdgdata_dir_keyword}`"
226

227
228
CMAKE_KNOWN_C_COMPILERS="cc gcc clang xlc icc tcc"
CMAKE_KNOWN_CXX_COMPILERS="aCC xlC CC g++ clang++ c++ icc como "
Bill Hoffman's avatar
Bill Hoffman committed
229
CMAKE_KNOWN_MAKE_PROCESSORS="gmake make"
230

231
232
233
234
235
CMAKE_PROBLEMATIC_FILES="\
  CMakeCache.txt \
  CMakeSystem.cmake \
  CMakeCCompiler.cmake \
  CMakeCXXCompiler.cmake \
236
237
238
  */CMakeSystem.cmake \
  */CMakeCCompiler.cmake \
  */CMakeCXXCompiler.cmake \
239
240
241
242
243
244
  Source/cmConfigure.h \
  Source/CTest/Curl/config.h \
  Utilities/cmexpat/expatConfig.h \
  Utilities/cmexpat/expatDllConfig.h \
  "

245
246
247
248
249
250
251
252
CMAKE_UNUSED_SOURCES="\
  cmGlobalXCodeGenerator \
  cmLocalXCodeGenerator \
  cmXCodeObject \
  cmXCode21Object \
  cmSourceGroup \
"

253
CMAKE_CXX_SOURCES="\
254
255
256
257
258
259
260
261
262
263
264
265
  cmAddCustomCommandCommand \
  cmAddCustomTargetCommand \
  cmAddDefinitionsCommand \
  cmAddDependenciesCommand \
  cmAddExecutableCommand \
  cmAddLibraryCommand \
  cmAddSubDirectoryCommand \
  cmAddTestCommand \
  cmBreakCommand \
  cmBuildCommand \
  cmCMakeMinimumRequired \
  cmCMakePolicyCommand \
266
267
  cmCPackPropertiesGenerator \
  cmCacheManager \
268
  cmCommand \
269
  cmCommandArgumentParserHelper \
270
  cmCommandArgumentsHelper \
271
272
273
274
275
276
277
  cmCommands \
  cmCommonTargetGenerator \
  cmComputeComponentGraph \
  cmComputeLinkDepends \
  cmComputeLinkInformation \
  cmComputeTargetDepends \
  cmConditionEvaluator \
278
279
280
281
  cmConfigureFileCommand \
  cmContinueCommand \
  cmCoreTryCompile \
  cmCreateTestSourceList \
282
283
  cmCustomCommand \
  cmCustomCommandGenerator \
284
  cmDefinePropertyCommand \
285
286
287
  cmDefinitions \
  cmDepends \
  cmDependsC \
288
  cmDisallowedCommand \
289
  cmDocumentationFormatter \
290
291
292
293
  cmEnableLanguageCommand \
  cmEnableTestingCommand \
  cmExecProgramCommand \
  cmExecuteProcessCommand \
294
295
296
297
298
299
300
301
302
  cmExpandedCommandArgument \
  cmExportBuildFileGenerator \
  cmExportFileGenerator \
  cmExportInstallFileGenerator \
  cmExportSet \
  cmExportSetMap \
  cmExportTryCompileFileGenerator \
  cmExprParserHelper \
  cmExternalMakefileProjectGenerator \
303
  cmFileCommand \
304
  cmFileTimeComparison \
305
306
307
308
309
310
311
312
313
  cmFindBase \
  cmFindCommon \
  cmFindFileCommand \
  cmFindLibraryCommand \
  cmFindPackageCommand \
  cmFindPathCommand \
  cmFindProgramCommand \
  cmForEachCommand \
  cmFunctionCommand \
314
  cmFSPermissions \
315
316
317
318
319
320
321
322
323
324
  cmGeneratedFileStream \
  cmGeneratorExpression \
  cmGeneratorExpressionContext \
  cmGeneratorExpressionDAGChecker \
  cmGeneratorExpressionEvaluationFile \
  cmGeneratorExpressionEvaluator \
  cmGeneratorExpressionLexer \
  cmGeneratorExpressionNode \
  cmGeneratorExpressionParser \
  cmGeneratorTarget \
325
326
327
328
329
330
331
  cmGetCMakePropertyCommand \
  cmGetDirectoryPropertyCommand \
  cmGetFilenameComponentCommand \
  cmGetPropertyCommand \
  cmGetSourceFilePropertyCommand \
  cmGetTargetPropertyCommand \
  cmGetTestPropertyCommand \
332
333
334
  cmGlobalCommonGenerator \
  cmGlobalGenerator \
  cmGlobalUnixMakefileGenerator3 \
335
336
337
  cmHexFileConverter \
  cmIfCommand \
  cmIncludeCommand \
338
  cmIncludeGuardCommand \
339
340
341
342
  cmIncludeDirectoryCommand \
  cmIncludeRegularExpressionCommand \
  cmInstallCommand \
  cmInstallCommandArguments \
343
344
  cmInstallDirectoryGenerator \
  cmInstallExportGenerator \
345
  cmInstallFilesCommand \
346
347
348
349
  cmInstallFilesGenerator \
  cmInstallGenerator \
  cmInstallScriptGenerator \
  cmInstallTargetGenerator \
350
  cmInstallTargetsCommand \
351
  cmInstalledFile \
352
  cmLinkDirectoriesCommand \
353
  cmLinkLineComputer \
354
  cmListCommand \
355
356
357
358
359
  cmListFileCache \
  cmLocalCommonGenerator \
  cmLocalGenerator \
  cmLocalUnixMakefileGenerator3 \
  cmMSVC60LinkLineComputer \
360
361
  cmMacroCommand \
  cmMakeDirectoryCommand \
362
363
364
365
366
  cmMakefile \
  cmMakefileExecutableTargetGenerator \
  cmMakefileLibraryTargetGenerator \
  cmMakefileTargetGenerator \
  cmMakefileUtilityTargetGenerator \
367
368
369
  cmMarkAsAdvancedCommand \
  cmMathCommand \
  cmMessageCommand \
370
371
372
  cmMessenger \
  cmNewLineStyle \
  cmOSXBundleGenerator \
373
  cmOptionCommand \
374
375
376
377
378
  cmOrderDirectories \
  cmOutputConverter \
  cmParseArgumentsCommand \
  cmPathLabel \
  cmPolicies \
379
  cmProcessOutput \
380
  cmProjectCommand \
381
382
383
384
  cmProperty \
  cmPropertyDefinition \
  cmPropertyDefinitionMap \
  cmPropertyMap \
385
  cmReturnCommand \
386
387
388
  cmRulePlaceholderExpander \
  cmScriptGenerator \
  cmSearchPath \
389
390
391
392
393
394
395
396
  cmSeparateArgumentsCommand \
  cmSetCommand \
  cmSetDirectoryPropertiesCommand \
  cmSetPropertyCommand \
  cmSetSourceFilesPropertiesCommand \
  cmSetTargetPropertiesCommand \
  cmSetTestsPropertiesCommand \
  cmSiteNameCommand \
397
398
399
400
401
  cmSourceFile \
  cmSourceFileLocation \
  cmState \
  cmStateDirectory \
  cmStateSnapshot \
402
403
  cmStringCommand \
  cmSubdirCommand \
404
405
  cmSystemTools \
  cmTarget \
406
407
408
409
  cmTargetCompileDefinitionsCommand \
  cmTargetCompileFeaturesCommand \
  cmTargetCompileOptionsCommand \
  cmTargetIncludeDirectoriesCommand \
410
  cmTargetLinkLibrariesCommand \
411
  cmTargetPropCommandBase \
412
  cmTargetPropertyComputer \
413
  cmTargetSourcesCommand \
414
415
  cmTest \
  cmTestGenerator \
416
417
418
  cmTimestamp \
  cmTryCompileCommand \
  cmTryRunCommand \
419
  cmUnexpectedCommand \
420
  cmUnsetCommand \
421
  cmUVHandlePtr \
422
  cmVersion \
423
  cmWhileCommand \
424
  cmWorkingDirectory \
425
426
427
  cmake  \
  cmakemain \
  cmcmd  \
428
"
429

430
431
432
if ${cmake_system_mingw}; then
  CMAKE_CXX_SOURCES="${CMAKE_CXX_SOURCES}\
    cmGlobalMSYSMakefileGenerator \
433
    cmGlobalMinGWMakefileGenerator"
434
435
fi

436
437
438
439
440
441
442
443
444
445
LexerParser_CXX_SOURCES="\
  cmCommandArgumentLexer \
  cmCommandArgumentParser \
  cmExprLexer \
  cmExprParser \
"

LexerParser_C_SOURCES="\
  cmListFileLexer \
"
446

447
448
if ${cmake_system_mingw}; then
  KWSYS_C_SOURCES="\
449
    EncodingC \
450
    ProcessWin32 \
451
    String \
452
453
    System \
    Terminal"
454
455
else
  KWSYS_C_SOURCES="\
456
    EncodingC \
457
    ProcessUNIX \
458
    String \
459
460
    System \
    Terminal"
461
fi
462
463

KWSYS_CXX_SOURCES="\
Brad King's avatar
Brad King committed
464
  Directory \
465
  EncodingCXX \
466
  FStream \
Andy Cedilnik's avatar
Andy Cedilnik committed
467
  Glob \
Brad King's avatar
Brad King committed
468
469
470
471
472
  RegularExpression \
  SystemTools"

KWSYS_FILES="\
  Directory.hxx \
473
474
475
  Encoding.h \
  Encoding.hxx \
  FStream.hxx \
Andy Cedilnik's avatar
Andy Cedilnik committed
476
  Glob.hxx \
Brad King's avatar
Brad King committed
477
478
  Process.h \
  RegularExpression.hxx \
479
  String.h \
480
  String.hxx \
481
  System.h \
482
483
  SystemTools.hxx \
  Terminal.h"
Brad King's avatar
Brad King committed
484

485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
if ${cmake_system_mingw}; then
  LIBUV_C_SOURCES="\
    src/fs-poll.c \
    src/inet.c \
    src/threadpool.c \
    src/uv-common.c \
    src/win/async.c \
    src/win/core.c \
    src/win/detect-wakeup.c \
    src/win/dl.c \
    src/win/error.c \
    src/win/fs-event.c \
    src/win/fs.c \
    src/win/getaddrinfo.c \
    src/win/getnameinfo.c \
    src/win/handle.c \
    src/win/loop-watcher.c \
    src/win/pipe.c \
    src/win/poll.c \
    src/win/process-stdio.c \
    src/win/process.c \
    src/win/req.c \
    src/win/signal.c \
    src/win/stream.c \
    src/win/tcp.c \
    src/win/thread.c \
    src/win/timer.c \
    src/win/tty.c \
    src/win/udp.c \
    src/win/util.c \
    src/win/winapi.c \
    src/win/winsock.c \
    "
else
  LIBUV_C_SOURCES="\
    src/uv-common.c \
    src/unix/cmake-bootstrap.c \
    src/unix/core.c \
    src/unix/fs.c \
    src/unix/loop.c \
    src/unix/loop-watcher.c \
    src/unix/no-fsevents.c \
    src/unix/pipe.c \
    src/unix/poll.c \
    src/unix/posix-hrtime.c \
    src/unix/posix-poll.c \
    src/unix/process.c \
    src/unix/signal.c \
    src/unix/stream.c \
    src/unix/timer.c \
    "
fi

538
# Display CMake bootstrap usage
539
540
cmake_usage()
{
541
echo '
542
Usage: '"$0"' [<options>...] [-- <cmake-options>...]
543
544
545
Options: [defaults in brackets after descriptions]
Configuration:
  --help                  print this message
546
  --version               only print version information
547
  --verbose               display more information
548
549
  --parallel=n            bootstrap cmake in parallel, where n is
                          number of nodes [1]
550
  --enable-ccache         Enable ccache when building cmake
551
  --init=FILE             load FILE as script to populate cache
552
  --system-libs           use all system-installed third-party libraries
553
                          (for use only by package maintainers)
554
  --no-system-libs        use all cmake-provided third-party libraries
555
                          (default)
556
557
558
559
  --system-curl           use system-installed curl library
  --no-system-curl        use cmake-provided curl library (default)
  --system-expat          use system-installed expat library
  --no-system-expat       use cmake-provided expat library (default)
560
561
  --system-jsoncpp        use system-installed jsoncpp library
  --no-system-jsoncpp     use cmake-provided jsoncpp library (default)
562
563
564
565
  --system-zlib           use system-installed zlib library
  --no-system-zlib        use cmake-provided zlib library (default)
  --system-bzip2          use system-installed bzip2 library
  --no-system-bzip2       use cmake-provided bzip2 library (default)
566
567
  --system-liblzma        use system-installed liblzma library
  --no-system-liblzma     use cmake-provided liblzma library (default)
568
569
  --system-libarchive     use system-installed libarchive library
  --no-system-libarchive  use cmake-provided libarchive library (default)
570
571
  --system-librhash       use system-installed librhash library
  --no-system-librhash    use cmake-provided librhash library (default)
572

573
574
575
  --qt-gui                build the Qt-based GUI (requires Qt >= 4.2)
  --no-qt-gui             do not build the Qt-based GUI (default)
  --qt-qmake=<qmake>      use <qmake> as the qmake executable to find Qt
576

577
578
  --sphinx-man            build man pages with Sphinx
  --sphinx-html           build html help with Sphinx
579
  --sphinx-qthelp         build qch help with Sphinx
580
  --sphinx-build=<sb>     use <sb> as the sphinx-build executable
581
  --sphinx-flags=<flags>  pass <flags> to sphinx-build executable
582

583
Directory and file names:
584
  --prefix=PREFIX         install files in tree rooted at PREFIX
585
                          ['"${cmake_default_prefix}"']
586
587
  --bindir=DIR            install binaries in PREFIX/DIR
                          ['"${cmake_bin_dir_default}"']
588
  --datadir=DIR           install data files in PREFIX/DIR
589
                          ['"${cmake_data_dir_default}"']
590
  --docdir=DIR            install documentation files in PREFIX/DIR
591
                          ['"${cmake_doc_dir_default}"']
592
  --mandir=DIR            install man pages files in PREFIX/DIR/manN
593
                          ['"${cmake_man_dir_default}"']
594
595
  --xdgdatadir=DIR        install XDG specific files in PREFIX/DIR
                          ['"${cmake_xdgdata_dir_default}"']
596
'
597
598
599
  exit 10
}

600
# Display CMake bootstrap usage
601
cmake_version_display()
602
{
603
  echo "CMake ${cmake_version}, ${cmake_copyright}"
604
605
606
}

# Display CMake bootstrap error, display the log file and exit
607
608
cmake_error()
{
609
610
  res=$1
  shift 1
611
  echo "---------------------------------------------"
612
  echo "Error when bootstrapping CMake:"
613
614
615
  echo "$*"
  echo "---------------------------------------------"
  if [ -f cmake_bootstrap.log ]; then
616
617
    echo "Log of errors: `pwd`/cmake_bootstrap.log"
    #cat cmake_bootstrap.log
618
619
    echo "---------------------------------------------"
  fi
620
  exit ${res}
621
}
622

623
624
625
626
627
628
629
630
631
632
633
634
cmake_generate_file ()
{
  OUTFILE="$1"
  CONTENT="$2"
  echo "$CONTENT" > "$OUTFILE.tmp"
  if "${_diff}" "$OUTFILE.tmp" "$OUTFILE" > /dev/null 2> /dev/null ; then
    rm -f "$OUTFILE.tmp"
  else
    mv -f "$OUTFILE.tmp" "$OUTFILE"
  fi
}

635
636
637
638
639
640
641
# Replace KWSYS_NAMESPACE with cmsys
cmake_replace_string ()
{
  INFILE="$1"
  OUTFILE="$2"
  SEARCHFOR="$3"
  REPLACEWITH="$4"
642
  if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then
643
    sed "s/\@${SEARCHFOR}\@/${REPLACEWITH}/g" "${INFILE}" > "${OUTFILE}${_tmp}"
644
645
    if [ -f "${OUTFILE}${_tmp}" ]; then
      if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
646
        #echo "Files are the same"
647
        rm -f "${OUTFILE}${_tmp}"
648
      else
649
        mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
650
651
      fi
    fi
Brad King's avatar
Brad King committed
652
  else
653
    cmake_error 1 "Cannot find file ${INFILE}"
654
655
656
  fi
}

657
658
659
660
661
662
cmake_kwsys_config_replace_string ()
{
  INFILE="$1"
  OUTFILE="$2"
  shift 2
  APPEND="$*"
663
664
  if [ -f "${INFILE}" ] || ${cmake_system_openvms}; then
    echo "${APPEND}" > "${OUTFILE}${_tmp}"
665
666
667
668
669
670
671
672
    sed "/./ {s/\@KWSYS_NAMESPACE\@/cmsys/g;
              s/@KWSYS_BUILD_SHARED@/${KWSYS_BUILD_SHARED}/g;
              s/@KWSYS_LFS_AVAILABLE@/${KWSYS_LFS_AVAILABLE}/g;
              s/@KWSYS_LFS_REQUESTED@/${KWSYS_LFS_REQUESTED}/g;
              s/@KWSYS_NAME_IS_KWSYS@/${KWSYS_NAME_IS_KWSYS}/g;
              s/@KWSYS_STL_HAS_WSTRING@/${KWSYS_STL_HAS_WSTRING}/g;
              s/@KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H@/${KWSYS_CXX_HAS_EXT_STDIO_FILEBUF_H}/g;
             }" "${INFILE}" >> "${OUTFILE}${_tmp}"
673
674
    if [ -f "${OUTFILE}${_tmp}" ]; then
      if "${_diff}" "${OUTFILE}" "${OUTFILE}${_tmp}" > /dev/null 2> /dev/null ; then
675
        #echo "Files are the same"
676
        rm -f "${OUTFILE}${_tmp}"
677
      else
678
        mv -f "${OUTFILE}${_tmp}" "${OUTFILE}"
679
680
681
682
683
684
      fi
    fi
  else
    cmake_error 2 "Cannot find file ${INFILE}"
  fi
}
685
# Write string into a file
686
687
688
689
690
691
692
cmake_report ()
{
  FILE=$1
  shift
  echo "$*" >> ${FILE}
}

693
# Escape spaces in strings
694
695
696
697
698
cmake_escape ()
{
  echo $1 | sed "s/ /\\\\ /g"
}

699
700
701
702
703
704
# Encode object file names.
cmake_obj ()
{
  echo $1 | sed 's/\//-/g' | sed 's/$/\.o/'
}

705
706
707
708
709
710
# Strip prefix from argument
cmake_arg ()
{
  echo "$1" | sed "s/^${2-[^=]*=}//"
}

711
# Write message to the log
712
713
714
715
716
cmake_log ()
{
  echo "$*" >> cmake_bootstrap.log
}

717
# Return temp file
718
719
cmake_tmp_file ()
{
720
  echo "cmake_bootstrap_$$_test"
721
722
}

723
724
# Run a compiler test. First argument is compiler, second one are compiler
# flags, third one is test source file to be compiled
725
726
727
728
729
730
731
732
733
734
735
cmake_try_run ()
{
  COMPILER=$1
  FLAGS=$2
  TESTFILE=$3
  if [ ! -f "${TESTFILE}" ]; then
    echo "Test file ${TESTFILE} missing. Please verify your CMake source tree."
    exit 4
  fi
  TMPFILE=`cmake_tmp_file`
  echo "Try: ${COMPILER}"
736
737
  echo "Line: ${COMPILER} ${FLAGS} ${TESTFILE} -o ${TMPFILE}"
  echo "----------  file   -----------------------"
738
  cat "${TESTFILE}"
739
  echo "------------------------------------------"
740
741
742
  "${COMPILER}" ${FLAGS} "${TESTFILE}" -o "${TMPFILE}"
  RES=$?
  if [ "${RES}" -ne "0" ]; then
743
744
    echo "Test failed to compile"
    return 1
745
746
  fi
  if [ ! -f "${TMPFILE}" ] && [ ! -f "${TMPFILE}.exe" ]; then
747
    echo "Test failed to produce executable"
748
749
750
751
752
753
    return 2
  fi
  ./${TMPFILE}
  RES=$?
  rm -f "${TMPFILE}"
  if [ "${RES}" -ne "0" ]; then
754
    echo "Test produced non-zero return code"
755
756
    return 3
  fi
757
  echo "Test succeeded"
758
759
760
  return 0
}

761
# Run a make test. First argument is the make interpreter.
762
763
cmake_try_make ()
{
764
765
  MAKE_PROC="$1"
  MAKE_FLAGS="$2"
766
  echo "Try: ${MAKE_PROC}"
767
  "${MAKE_PROC}" ${MAKE_FLAGS}
768
769
  RES=$?
  if [ "${RES}" -ne "0" ]; then
770
771
    echo "${MAKE_PROC} does not work"
    return 1
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
  fi
  if [ ! -f "test" ] && [ ! -f "test.exe" ]; then
    echo "${COMPILER} does not produce output"
    return 2
  fi
  ./test
  RES=$?
  rm -f "test"
  if [ "${RES}" -ne "0" ]; then
    echo "${MAKE_PROC} produces strange executable"
    return 3
  fi
  echo "${MAKE_PROC} works"
  return 0
}

788
# Parse arguments
789
cmake_verbose=
790
cmake_parallel_make=
791
cmake_ccache_enabled=
792
cmake_prefix_dir="${cmake_default_prefix}"
793
794
while test $# != 0; do
  case "$1" in
795
796
797
  --prefix=*) dir=`cmake_arg "$1"`
              cmake_prefix_dir=`cmake_fix_slashes "$dir"` ;;
  --parallel=*) cmake_parallel_make=`cmake_arg "$1"` ;;
798
  --bindir=*) cmake_bin_dir=`cmake_arg "$1"` ;;
799
800
801
  --datadir=*) cmake_data_dir=`cmake_arg "$1"` ;;
  --docdir=*) cmake_doc_dir=`cmake_arg "$1"` ;;
  --mandir=*) cmake_man_dir=`cmake_arg "$1"` ;;
802
  --xdgdatadir=*) cmake_xdgdata_dir=`cmake_arg "$1"` ;;
803
  --init=*) cmake_init_file=`cmake_arg "$1"` ;;
804
805
  --system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=1" ;;
  --no-system-libs) cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARIES=0" ;;
806
  --system-bzip2|--system-curl|--system-expat|--system-jsoncpp|--system-libarchive|--system-librhash|--system-zlib|--system-liblzma)
807
808
    lib=`cmake_arg "$1" "--system-"`
    cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=1" ;;
809
  --no-system-bzip2|--no-system-curl|--no-system-expat|--no-system-jsoncpp|--no-system-libarchive|--no-system-librhash|--no-system-zlib|--no-system-liblzma)
810
811
    lib=`cmake_arg "$1" "--no-system-"`
    cmake_bootstrap_system_libs="${cmake_bootstrap_system_libs} -DCMAKE_USE_SYSTEM_LIBRARY_`cmake_toupper $lib`=0" ;;
812
813
  --qt-gui) cmake_bootstrap_qt_gui="1" ;;
  --no-qt-gui) cmake_bootstrap_qt_gui="0" ;;
814
  --qt-qmake=*) cmake_bootstrap_qt_qmake=`cmake_arg "$1"` ;;
815
816
  --sphinx-man) cmake_sphinx_man="1" ;;
  --sphinx-html) cmake_sphinx_html="1" ;;
817
  --sphinx-qthelp) cmake_sphinx_qthelp="1" ;;
818
  --sphinx-build=*) cmake_sphinx_build=`cmake_arg "$1"` ;;
819
  --sphinx-flags=*) cmake_sphinx_flags=`cmake_arg "$1"` ;;
820
821
822
823
  --help) cmake_usage ;;
  --version) cmake_version_display ; exit 2 ;;
  --verbose) cmake_verbose=TRUE ;;
  --enable-ccache) cmake_ccache_enabled=TRUE ;;
824
  --) shift; break ;;
825
826
827
  *) die "Unknown option: $1" ;;
  esac
  shift
828
829
done

830
# If verbose, display some information about bootstrap
831
832
833
834
835
836
if [ -n "${cmake_verbose}" ]; then
  echo "---------------------------------------------"
  echo "Source directory: ${cmake_source_dir}"
  echo "Binary directory: ${cmake_binary_dir}"
  echo "Prefix directory: ${cmake_prefix_dir}"
  echo "System:           ${cmake_system}"
837
838
839
840
  if [ "x${cmake_parallel_make}" != "x" ]; then
    echo "Doing parallel make: ${cmake_parallel_make}"
  fi
  echo ""
841
842
843
fi

echo "---------------------------------------------"
844
# Get CMake version
845
echo "`cmake_version_display`"
846

847
848
849
850
851
852
853
854
855
856
857
858
859
# Check for in-source build
cmake_in_source_build=
if [ -f "${cmake_binary_dir}/Source/cmake.cxx" -a \
     -f "${cmake_binary_dir}/Source/cmake.h" ]; then
  if [ -n "${cmake_verbose}" ]; then
    echo "Warning: This is an in-source build"
  fi
  cmake_in_source_build=TRUE
fi

# If this is not an in-source build, then Bootstrap stuff should not exist.
if [ -z "${cmake_in_source_build}" ]; then
  # Did somebody bootstrap in the source tree?
860
861
  if [ -d "${cmake_source_dir}/Bootstrap${_cmk}" ]; then
    cmake_error 10 "Found directory \"${cmake_source_dir}/Bootstrap${_cmk}\".
862
Looks like somebody did bootstrap CMake in the source tree, but now you are
863
trying to do bootstrap in the binary tree. Please remove Bootstrap${_cmk}
864
865
866
867
directory from the source tree."
  fi
  # Is there a cache in the source tree?
  for cmake_problematic_file in ${CMAKE_PROBLEMATIC_FILES}; do
Will Schroeder's avatar
Will Schroeder committed
868
    if [ -f "${cmake_source_dir}/${cmake_problematic_file}" ]; then
869
870
871
872
873
874
875
876
      cmake_error 10 "Found \"${cmake_source_dir}/${cmake_problematic_file}\".
Looks like somebody tried to build CMake in the source tree, but now you are
trying to do bootstrap in the binary tree. Please remove \"${cmake_problematic_file}\"
from the source tree."
    fi
  done
fi

877
# Make bootstrap directory
878
879
[ -d "${cmake_bootstrap_dir}" ] || mkdir "${cmake_bootstrap_dir}"
if [ ! -d "${cmake_bootstrap_dir}" ]; then
880
  cmake_error 3 "Cannot create directory ${cmake_bootstrap_dir} to bootstrap CMake."
881
882
883
fi
cd "${cmake_bootstrap_dir}"

Brad King's avatar
Brad King committed
884
885
[ -d "cmsys" ] || mkdir "cmsys"
if [ ! -d "cmsys" ]; then
886
  cmake_error 4 "Cannot create directory ${cmake_bootstrap_dir}/cmsys"
Brad King's avatar
Brad King committed
887
888
fi

889
# Delete all the bootstrap files
890
rm -f "${cmake_bootstrap_dir}/cmake_bootstrap.log"
891
892
rm -f "${cmake_bootstrap_dir}/cmConfigure.h${_tmp}"
rm -f "${cmake_bootstrap_dir}/cmVersionConfig.h${_tmp}"
893

894
895
896
897
898
899
# If building in-source, remove any cmConfigure.h that may
# have been created by a previous run of the bootstrap cmake.
if [ -n "${cmake_in_source_build}" ]; then
  rm -f "${cmake_source_dir}/Source/cmConfigure.h"
fi

900
# If exist compiler flags, set them
901
902
cmake_c_flags=${CFLAGS}
cmake_cxx_flags=${CXXFLAGS}
Bill Hoffman's avatar
Bill Hoffman committed
903
cmake_ld_flags=${LDFLAGS}
904

905
906
907
908
909
# Add Cygwin-specific flags
if ${cmake_system_cygwin}; then
  cmake_ld_flags="${LDFLAGS} -Wl,--enable-auto-import"
fi

910
# Add CoreFoundation framework on Darwin
911
if ${cmake_system_darwin}; then
912
  cmake_ld_flags="${LDFLAGS} -framework CoreFoundation"
913
914
fi

915
916
917
918
919
# Add BeOS toolkits...
if ${cmake_system_beos}; then
  cmake_ld_flags="${LDFLAGS} -lroot -lbe"
fi

920
921
922
923
924
# Add Haiku toolkits...
if ${cmake_system_haiku}; then
  cmake_ld_flags="${LDFLAGS} -lroot -lbe"
fi

925
926
927
928
929
930
#-----------------------------------------------------------------------------
# Detect known toolchains on some platforms.
cmake_toolchains=''
case "${cmake_system}" in
  *AIX*)   cmake_toolchains='XL GNU' ;;
  *CYGWIN*) cmake_toolchains='GNU' ;;
931
  *Darwin*) cmake_toolchains='Clang GNU' ;;
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
  *Linux*) cmake_toolchains='GNU Clang XL PGI PathScale' ;;
  *MINGW*) cmake_toolchains='GNU' ;;
esac

# Toolchain compiler name table.
cmake_toolchain_Clang_CC='clang'
cmake_toolchain_Clang_CXX='clang++'
cmake_toolchain_GNU_CC='gcc'
cmake_toolchain_GNU_CXX='g++'
cmake_toolchain_PGI_CC='pgcc'
cmake_toolchain_PGI_CXX='pgCC'
cmake_toolchain_PathScale_CC='pathcc'
cmake_toolchain_PathScale_CXX='pathCC'
cmake_toolchain_XL_CC='xlc'
cmake_toolchain_XL_CXX='xlC'

cmake_toolchain_try()
{
  tc="$1"
  TMPFILE=`cmake_tmp_file`

  eval "tc_CC=\${cmake_toolchain_${tc}_CC}"
  echo 'int main() { return 0; }' > "${TMPFILE}.c"
  cmake_try_run "$tc_CC" "" "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1
  tc_result_CC="$?"
  rm -f "${TMPFILE}.c"
  test "${tc_result_CC}" = "0" || return 1

  eval "tc_CXX=\${cmake_toolchain_${tc}_CXX}"
  echo 'int main() { return 0; }' > "${TMPFILE}.cpp"
  cmake_try_run "$tc_CXX" "" "${TMPFILE}.cpp" >> cmake_bootstrap.log 2>&1
  tc_result_CXX="$?"
  rm -f "${TMPFILE}.cpp"
  test "${tc_result_CXX}" = "0" || return 1

  cmake_toolchain="$tc"
}

cmake_toolchain_detect()
{
  cmake_toolchain=
  for tc in ${cmake_toolchains}; do
    echo "Checking for $tc toolchain" >> cmake_bootstrap.log 2>&1
    cmake_toolchain_try "$tc" &&
    echo "Found $tc toolchain" &&
    break
  done
}

if [ -z "${CC}" -a -z "${CXX}" ]; then
  cmake_toolchain_detect
fi

985
thread_flags=''
986
987
988
case "${cmake_system}" in
  *AIX*)   thread_flags='-pthread' ;;
esac
989

990
#-----------------------------------------------------------------------------
991
992
993
# Test C compiler
cmake_c_compiler=

994
# If CC is set, use that for compiler, otherwise use list of known compilers
995
996
997
if [ -n "${cmake_toolchain}" ]; then
  eval cmake_c_compilers="\${cmake_toolchain_${cmake_toolchain}_CC}"
elif [ -n "${CC}" ]; then
998
999
1000
1001
1002
  cmake_c_compilers="${CC}"
else
  cmake_c_compilers="${CMAKE_KNOWN_C_COMPILERS}"
fi

1003
# Check if C compiler works
1004
TMPFILE=`cmake_tmp_file`
1005
echo '
1006
1007
#ifdef __cplusplus
# error "The CMAKE_C_COMPILER is set to a C++ compiler"
1008
1009
#endif

1010
1011
1012
1013
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
#error "On AIX with GNU we need the -pthread flag."
#endif

1014
1015
1016
1017
#if defined(__sun) && __STDC_VERSION__ < 199901L
#error "On Solaris we need C99."
#endif

1018
#include <stdio.h>
1019

Andy Cedilnik's avatar
Andy Cedilnik committed
1020
int main(int argc, char* argv[])
1021
{
1022
  printf("%d%c", (argv != 0), (char)0x0a);
1023
  return argc - 1;
1024
}
1025
' > "${TMPFILE}.c"
1026
for std in 11 99 90; do
1027
  std_flags="`cmake_extract_standard_flags \"${cmake_toolchain}\" C \"${std}\"`"
1028
  for compiler in ${cmake_c_compilers}; do
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
    for std_flag in '' $std_flags; do
      for thread_flag in '' $thread_flags; do
        echo "Checking whether '${compiler} ${cmake_c_flags} ${std_flag} ${thread_flag}' works." >> cmake_bootstrap.log 2>&1
        if cmake_try_run "${compiler}" "${cmake_c_flags} ${std_flag} ${thread_flag}" \
          "${TMPFILE}.c" >> cmake_bootstrap.log 2>&1; then
          cmake_c_compiler="${compiler}"
          cmake_c_flags="${cmake_c_flags} ${std_flag} ${thread_flag}"
          break 3
        fi
      done
1039
    done
1040
1041
  done
done
1042
1043
1044
rm -f "${TMPFILE}.c"

if [ -z "${cmake_c_compiler}" ]; then
1045
  cmake_error 6 "Cannot find appropriate C compiler on this system.
Bill Hoffman's avatar
Bill Hoffman committed
1046
1047
1048
Please specify one using environment variable CC.
See cmake_bootstrap.log for compilers attempted.
"
1049
1050
1051
fi
echo "C compiler on this system is: ${cmake_c_compiler} ${cmake_c_flags}"

1052
#-----------------------------------------------------------------------------
1053
1054
# Test CXX compiler
cmake_cxx_compiler=
1055

1056
1057
# On Mac OSX, CC is the same as cc, so make sure not to try CC as c++ compiler.

1058
# If CC is set, use that for compiler, otherwise use list of known compilers
1059
1060
1061
if [ -n "${cmake_toolchain}" ]; then
  eval cmake_cxx_compilers="\${cmake_toolchain_${cmake_toolchain}_CXX}"
elif [ -n "${CXX}" ]; then
1062
1063
1064
1065
1066
  cmake_cxx_compilers="${CXX}"
else
  cmake_cxx_compilers="${CMAKE_KNOWN_CXX_COMPILERS}"
fi

1067
# Check if C++ compiler works
1068
TMPFILE=`cmake_tmp_file`
1069
echo '
1070
1071
#include <iostream>
#include <memory>
1072
#include <unordered_map>
1073

1074
1075
1076
1077
#if __cplusplus < 201103L
#error "Compiler is not in a mode aware of C++11."
#endif

1078
1079
1080
1081
#if defined(_AIX) && defined(__GNUC__) && !defined(_THREAD_SAFE)
#error "On AIX with GNU we need the -pthread flag."
#endif