Configure.pl

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