Configure.pl

   1 #! perl
   2
   3 # Copyright (C) 2001-2009, Parrot Foundation.
   4 # $Id$
   5
   6 use 5.008;
   7 use strict;
   8 use warnings;
   9 use lib 'lib';
  10
  11 use Parrot::Configure;
  12 use Parrot::Configure::Options qw( process_options );
  13 use Parrot::Configure::Options::Test;
  14 use Parrot::Configure::Options::Test::Prepare qw(
  15     get_preconfiguration_tests
  16     get_postconfiguration_tests
  17 );
  18 use Parrot::Configure::Messages qw(
  19     print_introduction
  20     print_conclusion
  21 );
  22 use Parrot::Revision;
  23
  24 $| = 1;    # $OUTPUT_AUTOFLUSH = 1;
  25
  26 # Install Option text was taken from:
  27 #
  28 # autoconf (GNU Autoconf) 2.59
  29 # Written by David J. MacKenzie and Akim Demaille.
  30 #
  31 # Copyright (C) 2003 Free Software Foundation, Inc.
  32 # This is free software; see the source for copying conditions.  There is NO
  33 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  34
  35 # from Parrot::Configure::Options
  36 my ($args, $steps_list_ref) = process_options(
  37     {
  38         mode => (defined $ARGV[0]  and $ARGV[0] =~ /^--file=/)
  39                     ? 'file'
  40                     : 'configure',
  41         argv => [@ARGV],
  42     }
  43 );
  44 exit(1) unless defined $args;
  45
  46 my $opttest = Parrot::Configure::Options::Test->new($args);
  47
  48 # configuration tests will only be run if you requested them
  49 # as command-line option
  50 $opttest->run_configure_tests( get_preconfiguration_tests() );
  51
  52 my $parrot_version = $Parrot::Configure::Options::Conf::parrot_version;
  53
  54 # from Parrot::Configure::Messages
  55 print_introduction($parrot_version);
  56
  57 # Update revision number if needed
  58 Parrot::Revision::update();
  59
  60 my $conf = Parrot::Configure->new();
  61
  62 $conf->add_steps( @{ $steps_list_ref } );
  63
  64 # from Parrot::Configure::Data
  65 $conf->options->set( %{$args} );
  66 # save the command-line for make reconfig
  67 $conf->data->set(configure_args => @ARGV ? '"'.join("\" \"", map {qq($_)} @ARGV).'"'
  68                                          : '');
  69
  70 # Log files created by Configure.pl in MANIFEST.configure.generated
  71 $conf->{active_configuration} = 1;
  72 unlink 'MANIFEST.configure.generated';
  73
  74 # Run the actual steps from Parrot::Configure
  75 $conf->runsteps or exit(1);
  76
  77 # build tests will only be run if you requested them
  78 # as command-line option
  79 $opttest->run_build_tests( get_postconfiguration_tests() );
  80
  81 my $make = $conf->data->get('make');
  82 # from Parrot::Configure::Messages
  83 ( print_conclusion( $conf, $make ) ) ? exit 0 : exit 1;
  84
  85 ################### DOCUMENTATION ###################
  86
  87 =head1 NAME
  88
  89 Configure.pl - Parrot's configuration script
  90
  91 =head1 SYNOPSIS
  92
  93     % perl Configure.pl [options]
  94
  95 or:
  96
  97     % perl Configure.pl --file=/path/to/configuration/directives
  98
  99 =head1 DESCRIPTION
 100
 101 This is Parrot's configuration program. It should be run to create
 102 the necessary system-specific files before building Parrot.
 103
 104 We now offer two interfaces to configuration:
 105
 106 =over 4
 107
 108 =item * Command-Line Interface
 109
 110 All configuration options are placed on the command-line.  You may request
 111 interactive configuration with the C<--ask> option.  You may not use the
 112 C<--file> option, as that is reserved for the Configuration-File interface.
 113
 114 =item * Configuration-File Interface
 115
 116 All configuration options are placed in a special configuration file whose
 117 full path is invoked on the command-line as
 118 C<--file=/path/to/configuration/directives> as the sole command-line option.
 119 You may not request interactive configuration.  For specific instructions, see
 120 L</"CONFIGURATION-FILE INTERFACE"> below.
 121
 122 =back
 123
 124 =head2 General Options
 125
 126 =over 4
 127
 128 =item C<--help>
 129
 130 Prints out a description of the options and exits.
 131
 132 =item C<--version>
 133
 134 Prints out the version number of Configure.pl and exits.
 135
 136 =item C<--verbose>
 137
 138 Tells Configure.pl to output extra information about the configuration data it
 139 is setting.
 140
 141 =item C<--verbose=2>
 142
 143 Tells Configure.pl to output information about i<every> setting added or
 144 changed.
 145
 146 =item C<--verbose-step={N|regex}>
 147
 148 Run C<--verbose=2> for step number C<N> or matching description.
 149
 150 =item C<--fatal>
 151
 152 Tells Configure.pl to halt completely if any configuration step fails.
 153
 154 =item C<--fatal-step={init::alpha,inter::beta,auto::gamma}>
 155
 156 Tells Configure.pl to halt completely if any configuration step in
 157 comma-delimited string individually fails.
 158
 159 =item C<--nomanicheck>
 160
 161 Tells Configure.pl not to run the MANIFEST check.
 162
 163 =item C<--prefix>
 164
 165 Sets the location where parrot will be installed.
 166
 167 =item C<--ask>
 168
 169 This turns on the user prompts during configuration.  Available only in
 170 Command-Line interface.  Not available in Configuration-File interface.
 171
 172 =item C<--test>
 173
 174 Run certain tests along with F<Configure.pl>:
 175
 176 =over 4
 177
 178 =item C<--test=configure>
 179
 180 Run tests found in F<t/configure/> I<before> beginning configuration.  These
 181 tests demonstrate that Parrot's configuration tools will work properly once
 182 configuration has begun.
 183
 184 =item C<--test=build>
 185
 186 Run tests found in F<t/postconfigure/>, F<t/tools/pmc2cutils/>,
 187 F<t/tools/ops2cutils/> and F<t/tools/ops2pm/> I<after> configuration has
 188 completed.  These tests demonstrate (a) that certain of Parrot's configuration
 189 tools are working properly post-configuration; and (b) that certain of
 190 Parrot's build tools will work properly once you call F<make>.
 191
 192 =item C<--test>
 193
 194 Run the tests described in C<--test=configure>, conduct configuration, then
 195 run the tests described in C<--test=build>.
 196
 197 =back
 198
 199 =item C<--configure_trace>
 200
 201 Store the results of each configuration step in a Storable F<.sto> file on
 202 disk, for later analysis by F<Parrot::Configure::Trace> methods.
 203
 204 =item Operating system-specific configuration options
 205
 206 =over 4
 207
 208 =item C<--darwin_no_fink>
 209
 210 On Darwin, do not probe for Fink libraries.
 211
 212 =item C<--darwin_no_macports>
 213
 214 On Darwin, do not probe for Macports libraries.
 215
 216 =back
 217
 218 =back
 219
 220 =head2 Compile Options
 221
 222 =over 4
 223
 224 =item C<--debugging=0>
 225
 226 Debugging is turned on by default. Use this to disable it.
 227
 228 =item C<--parrot_is_shared>
 229
 230 Link parrot dynamically.
 231
 232 =item C<--m=32>
 233
 234 Create a 32-bit executable on 64-architectures like x86_64. This
 235 option appends -m32 to compiler and linker programs and does
 236 s/lib64/lib/g on link flags.
 237
 238 This option is experimental. See F<config/init/defaults.pm> for more.
 239
 240 =item C<--profile>
 241
 242 Turn on profiled compile (gcc only for now)
 243
 244 =item C<--cage>
 245
 246 [CAGE] compile includes many additional warnings
 247
 248 =item C<--optimize>
 249
 250 Add perl5's $Config{optimize} to the compiler flags.
 251
 252 =item C<--optimize=flags>
 253
 254 Add C<flags> to the compiler flags.
 255
 256 =item C<--inline>
 257
 258 Tell Configure that the compiler supports C<inline>.
 259
 260 =item C<--cc=(compiler)>
 261
 262 Specify which compiler to use.
 263
 264 =item C<--ccflags=(flags)>
 265
 266 Use the given compiler flags.
 267
 268 =item C<--ccwarn=(flags)>
 269
 270 Use the given compiler warning flags.
 271
 272 =item C<--cxx=(compiler)>
 273
 274 Specify which C++ compiler to use (for ICU).
 275
 276 =item C<--libs=(libs)>
 277
 278 Use the given libraries.
 279
 280 =item C<--link=(linker)>
 281
 282 Specify which linker to use.
 283
 284 =item C<--linkflags=(flags)>
 285
 286 Use the given linker flags
 287
 288 =item C<--ld=(linker)>
 289
 290 Specify which loader to use for shared libraries.
 291
 292 =item C<--ldflags=(flags)>
 293
 294 Use the given loader flags for shared libraries
 295
 296 =item C<--disable-rpath>
 297
 298 Specify that rpath should not be included in linking flags. With this
 299 configuration option, you must append the library build directory
 300 (usually blib/lib) to the LD_LIBRARY_PATH environment variable (or your
 301 platform equivalent). This option is primarily used for building Linux
 302 packages.
 303
 304 =item C<--lex=(lexer)>
 305
 306 Specify which lexer to use.
 307
 308 =item C<--yacc=(parser)>
 309
 310 Specify which parser to use.
 311
 312 =item C<--define=val1[,val2]>
 313
 314 Generate "#define PARROT_DEF_VAL1 1" ... entries in has_header.h. Currently
 315 needed to use inet_aton for systems that lack inet_pton:
 316
 317   --define=inet_aton
 318
 319 =item C<--no-line-directives>
 320
 321 Disables the creation of C #line directives when generating C from PMCs and
 322 ops. Useful when debugging internals.
 323
 324 =back
 325
 326 =head2 Parrot Options
 327
 328 =over 4
 329
 330 =item C<--intval=(type)>
 331
 332 Use the given type for C<INTVAL>.
 333
 334 =item C<--floatval=(type)>
 335
 336 Use the given type for C<FLOATVAL>.
 337
 338 =item C<--opcode=(type)>
 339
 340 Use the given type for opcodes.
 341
 342 =item C<--ops=(files)>
 343
 344 Use the given ops files.
 345
 346 =item C<--cgoto=0>
 347
 348 Don't build cgoto core. This is recommended when you are short of memory.
 349
 350 =item C<--jitcapable>
 351
 352 Use JIT system.
 353
 354 =item C<--buildframes>
 355
 356 Dynamically build NCI call frames.
 357
 358 =item C<--execcapable>
 359
 360 Use JIT to emit a native executable.
 361
 362 =back
 363
 364 =head2 International Components For Unicode (ICU) Options
 365
 366 =over 4
 367
 368 =item C<--icu-config=/path/to/icu-config>
 369
 370 Use the specified icu-config script to determine the necessary ICU options.
 371
 372 Use --icu-config=none to disable the autodetect feature. Parrot will then be
 373 build without ICU.
 374
 375 B<Note:> If you specify another ICU option than --icu-config, the autodetection
 376 functionality will be disabled.
 377
 378 =item C<--icushared=(linkeroption)>
 379
 380 Linker command to link against ICU library.
 381
 382 E.g.
 383
 384    --icushared='-L /opt/openoffice/program -licudata -licuuc'
 385
 386 (The libs in openoffice are actually version 2.2 and do not work)
 387
 388 =item C<--icuheaders=(header_dir)>
 389
 390 Location of ICU header files without the /unicode suffix.
 391
 392 E.g.
 393
 394 --icuheaders='/home/lt/icu/'
 395
 396 =back
 397
 398 =head2 Other Options
 399
 400 =over 4
 401
 402 =item C<--maintainer>
 403
 404 Use this option if you want imcc's parser and lexer files to be generated.
 405 Needs a working parser and lexer.
 406
 407 =back
 408
 409 =head1 CONFIGURATION-FILE INTERFACE
 410
 411 In the Configuration-File interface, unlike the Command-Line interface, you
 412 may delete configuration steps or run them in an order different from that
 413 listed in Parrot::Configure::Step::List.
 414
 415 A configuration file is a plain-text file located somewhere in or under your
 416 top-level Parrot directory.  Unless indicated otherwise, all lines in this
 417 file must have no leading whitespace.  As in Perl 5, lines beginning with C<#>
 418 marks are comments and are ignored during parsing of the file.  Unlike Perl 5,
 419 you may not begin comments in the middle of a line.
 420
 421 The configuration file must contain these three sections:
 422
 423 =over 4
 424
 425 =item * variables
 426
 427 =over 4
 428
 429 =item *
 430
 431 Section begins with line C<=variables> and must be followed by at least one
 432 blank line.  All other content in this section is optional.
 433
 434 =item *
 435
 436 Section may contain one or more I<key=value> pairs which assign strings to
 437 variables much in the way that you would do in a shell script wrapping around
 438 F<Configure.pl>.
 439
 440     =variables
 441
 442     CC=/usr/bin/gcc
 443     CX=/usr/bin/g++
 444
 445 So if you typically invoked F<Configure.pl> by wrapping it in a shell script
 446 for the purpose of setting environmental variables used in options, like this:
 447
 448     CC="/usr/bin/gcc"
 449     CX="/usr/bin/g++"
 450     /usr/local/bin/perl Configure.pl \
 451         --cc="$CC" \
 452         --cxx="$CX" \
 453         --link="$CX" \
 454         --ld="$CX"
 455
 456 ... you would now place the assignments to C<CC> and C<CX> in the
 457 I<=variables> section of the configuration file (as above).
 458
 459 =back
 460
 461 =item * general
 462
 463 =over 4
 464
 465 =item *
 466
 467 Section begins with line C<=general> and must be followed by at least one
 468 blank line.  All other content in this section is optional.
 469
 470 =item *
 471
 472 This section is the location recommended for listing options whose impact is
 473 not conceptually limited to a single step.  It is also the location where the
 474 variables defined in the I<=variables> section are assigned to particular
 475 Parrot configuration options.  Entries in this section must be either
 476 I<option=value> pairs or be options which will be assigned a true value.
 477
 478     cc=$CC
 479     cxx=$CX
 480     link=$CX
 481     ld=/usr/bin/g++
 482     verbose
 483
 484 Note that when the value is a variable defined in the I<=variables> section,
 485 it must be preceded by a C<$> sign.
 486
 487 =item *
 488
 489 You I<may> list options here which are I<conceptually> limited to a single
 490 configuration step.  For example, if you wished to skip validation of the
 491 F<MANIFEST> during configuration and to configure without ICU, you I<could>,
 492 in this section, say:
 493
 494     nomanicheck
 495     without-icu
 496
 497 However, as we shall quickly see, it's conceptually clearer to place these
 498 values next to those configuration steps that actually use them.
 499
 500 =back
 501
 502 =item * steps
 503
 504 =over 4
 505
 506 =item *
 507
 508 Section begins with line C<=steps> and must be followed by at least one
 509 blank line, in turn followed by the list of configuration steps, followed by
 510 another blank line followed by a line C<=cut> (just like POD).
 511
 512 =item *
 513
 514 The order in which you list the steps is the order in which they will be
 515 executed.  If you delete a step from the canonical list or comment a step out,
 516 it will not be executed.
 517
 518     ...
 519     auto::snprintf
 520     # auto::perldoc
 521     auto::ctags
 522     ...
 523
 524 In the above example, step C<auto::perldoc> will be completely skipped.  You
 525 will not see it listed as C<....skipped> in F<Configure.pl>'s output; it will
 526 simply not be there at all.
 527
 528 =item *
 529
 530 This is the recommended location to call options whose impact is
 531 I<conceptually> limited to a single configuration step.  Type the
 532 configuration step's name, type a whitespace, type the option (with no leading
 533 C<-->) and repeat as needed for additional step-specific options.
 534
 535     init::manifest nomanicheck
 536     ...
 537
 538 =item *
 539
 540 This is also the location to call options whose impact is limited to one step
 541 at a time but which may be applied to more than one configuration step.  The
 542 C<fatal-step> and C<verbose-step> options are the best examples of this case.
 543 Rather than requesting verbose output from all configuration steps, you may,
 544 for example, wish to designate only a few steps for verbose output:
 545
 546     ...
 547     init::hints verbose-step
 548     init::headers
 549     inter::progs fatal-step
 550     ...
 551     auto::gcc verbose-step
 552     ...
 553
 554 In the above example, F<Configure.pl> will grind to a halt if C<inter::progs>
 555 does not complete successfully.  You will get verbose output only from
 556 C<init::hints> and C<auto::gcc>; the other 60+ steps will be terse.
 557
 558 =item *
 559
 560 Nothing prevents you from listing general options anywhere in this section.
 561
 562     init::manifest nomanicheck cc=$CC ld=/usr/bin/g++ verbose
 563     init::defaults
 564     ...
 565
 566 That will work -- but why would you want to do something that messy?
 567
 568 =back
 569
 570 =back
 571
 572 =head2 Example
 573
 574 Ignoring leading whitespace, this is an example of a correctly formed
 575 configuration file.
 576
 577     =variables
 578
 579     CC=/usr/bin/gcc
 580     CX=/usr/bin/g++
 581
 582     =general
 583
 584     cc=$CC
 585     cxx=$CX
 586     link=$CX
 587     ld=/usr/bin/g++
 588
 589     =steps
 590
 591     init::manifest nomanicheck
 592     init::defaults
 593     init::install
 594     init::hints verbose-step
 595     init::headers
 596     inter::progs
 597     inter::make
 598     inter::lex
 599     inter::yacc
 600     auto::gcc
 601     auto::glibc
 602     auto::backtrace
 603     auto::fink
 604     auto::macports
 605     auto::msvc
 606     auto::attributes
 607     auto::warnings
 608     init::optimize
 609     inter::shlibs
 610     inter::libparrot
 611     inter::charset
 612     inter::encoding
 613     inter::types
 614     auto::ops
 615     auto::alignptrs
 616     auto::headers
 617     auto::sizes
 618     auto::byteorder
 619     auto::va_ptr
 620     auto::format
 621     auto::isreg
 622     auto::arch
 623     auto::jit
 624     auto::frames
 625     auto::cpu
 626     auto::funcptr
 627     auto::cgoto
 628     auto::inline
 629     auto::gc
 630     auto::memalign
 631     auto::signal
 632     auto::socklen_t
 633     auto::env
 634     auto::gmp
 635     auto::readline
 636     auto::gdbm
 637     auto::pcre
 638     auto::opengl
 639     auto::crypto
 640     auto::gettext
 641     auto::snprintf
 642     # auto::perldoc
 643     auto::ctags
 644     auto::revision
 645     auto::icu
 646     gen::config_h
 647     gen::core_pmcs
 648     gen::crypto
 649     gen::parrot_include
 650     gen::opengl
 651     gen::call_list
 652     gen::makefiles
 653     gen::platform
 654     gen::config_pm
 655
 656     =cut
 657
 658 You may see how this works in practice by calling:
 659
 660     perl Configure.pl --file=examples/config/file/configcompiler
 661
 662 or
 663
 664     perl Configure.pl --file=examples/config/file/configwithfatalstep
 665
 666 =head1 SEE ALSO
 667
 668 F<lib/Parrot/Configure.pm>,
 669 F<lib/Parrot/Configure/Step.pm>, F<docs/configuration.pod>
 670
 671 =cut
 672
 673 # Local Variables:
 674 #   mode: cperl
 675 #   cperl-indent-level: 4
 676 #   fill-column: 100
 677 # End:
 678 # vim: expandtab shiftwidth=4:
 679