4 use File::Basename qw(&basename &dirname);
7 # List explicitly here the variables you want Configure to
8 # generate. Metaconfig only looks for shell variables, so you
9 # have to mention them as if they were shell variables, not
10 # %Config entries. Thus you write
12 # to ensure Configure will look for $Config{startperl}.
15 # This forces PL files to create target in same directory as PL file.
16 # This is so that make depend always knows where to find PL derivatives.
19 $file = basename($0, '.PL');
20 $file .= '.com' if $^O eq 'VMS';
22 open OUT,">$file" or die "Can't create $file: $!";
24 print "Extracting $file (with variable substitutions)\n";
26 # In this section, perl variables will be expanded during extraction.
27 # You can use $Config{...} to use Configure variables.
29 print OUT <<"!GROK!THIS!";
31 eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
32 if \$running_under_some_shell;
35 # In the following, perl variables are not expanded during extraction.
37 print OUT <<'!NO!SUBS!';
42 use File::Basename qw(&basename &dirname);
47 $Getopt::Long::bundling_override = 1;
48 $Getopt::Long::passthrough = 0;
49 $Getopt::Long::ignore_case = 0;
51 my $pathsep = ($Config{'osname'} eq 'MSWin32')? "\\" : "/"; # MAJOR HACK. SHOULD
85 _usage() if (!_checkopts());
86 push(@ARGV, _maketempfile()) if ($options->{'e'});
94 --------------------------------------------------------------------------------
96 --------------------------------------------------------------------------------
106 my ($program_ext, $module_ext) = _getRegexps();
107 my ($obj, $objfile, $so, $type);
110 (($file =~ m"@$program_ext") && ($file !~ m"@$module_ext"))
111 || (defined($options->{'prog'}) || defined($options->{'run'}))
114 $objfile = ($options->{'C'}) ? $options->{'C'} : "$file.c";
117 $obj = ($options->{'o'})? $options->{'o'} :
118 _getExecutable( $file,$program_ext);
123 elsif (($file =~ m"@$module_ext") || ($options->{'mod'}))
125 die "Shared objects are not supported on Win32 yet!!!!\n"
126 if ($Config{'osname'} eq 'MSWin32');
128 $obj = ($options->{'o'})? $options->{'o'} :
129 _getExecutable($file, $module_ext);
130 $so = "$obj.$Config{so}";
133 $objfile = ($options->{'C'}) ? $options->{'C'} : "$file.c";
137 _error("noextension", $file, $program_ext, $module_ext);
141 if ($type eq 'program')
143 _print("Making C($objfile) for $file!\n", 36 );
145 my $errcode = _createCode($objfile, $file);
146 (_print( "ERROR: In generating code for $file!\n", -1), return())
149 _print("Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'});
150 $errcode = _compileCode($file, $objfile, $obj)
151 if (!$options->{'gen'});
155 _print( "ERROR: In compiling code for $objfile !\n", -1);
156 my $ofile = File::Basename::basename($objfile);
157 $ofile =~ s"\.c$"\.o"s;
159 _removeCode("$ofile");
163 _runCode($obj) if ($options->{'run'});
165 _removeCode($objfile) if (!$options->{'sav'} ||
166 ($options->{'e'} && !$options->{'C'}));
168 _removeCode($file) if ($options->{'e'});
170 _removeCode($obj) if (($options->{'e'}
171 && !$options->{'sav'}
173 || ($options->{'run'} && !$options->{'sav'}));
177 _print( "Making C($objfile) for $file!\n", 36 );
178 my $errcode = _createCode($objfile, $file, $obj);
179 (_print( "ERROR: In generating code for $file!\n", -1), return())
182 _print( "Compiling C($so) for $file!\n", 36 ) if (!$options->{'gen'});
185 _compileCode($file, $objfile, $obj, $so ) if (!$options->{'gen'});
187 (_print( "ERROR: In compiling code for $objfile!\n", -1), return())
194 my ($sourceprog, $ext) = @_;
197 if (defined($options->{'regex'}))
199 eval("(\$obj = \$sourceprog) =~ $options->{'regex'}");
200 return(0) if (_error('badeval', $@));
201 return(0) if (_error('equal', $obj, $sourceprog));
203 elsif (defined ($options->{'ext'}))
205 ($obj = $sourceprog) =~ s"@$ext"$options->{ext}"g;
206 return(0) if (_error('equal', $obj, $sourceprog));
208 elsif (defined ($options->{'run'}))
214 ($obj = $sourceprog) =~ s"@$ext""g;
215 return(0) if (_error('equal', $obj, $sourceprog));
222 my ( $generated_cfile, $file, $final_output ) = @_;
227 if (@_ == 2) # compiling a program
229 _print( "$^X -I@INC -MB::Stash -c $file\n", 36);
230 my $stash=`$^X -I@INC -MB::Stash -c $file 2>/dev/null|tail -1`;
233 _print( "$^X -I@INC -MO=CC,$stash,-o$generated_cfile $file\n", 36);
234 $return = _run("$^X -I@INC -MO=CC,$stash,-o$generated_cfile $file", 9);
237 else # compiling a shared object
240 "$^X -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file\n", 36);
242 _run("$^X -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file", 9);
249 my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
252 if (@_ == 3) # just compiling a program
255 _ccharness('static', $sourceprog, "-o", $output_executable,
261 my $object_file = $generated_cfile;
262 $object_file =~ s"\.c$"$Config{_o}";
264 $return[0] = _ccharness('compile', $sourceprog, "-c", $generated_cfile);
265 $return[1] = _ccharness
269 $shared_object, $object_file
271 return(1) if (grep ($_, @return));
278 my ($executable) = @_;
279 _print("$executable $options->{'argv'}\n", 36);
280 _run("$executable $options->{'argv'}", -1 );
286 unlink($file) if (-e $file);
295 my $sourceprog = shift(@args);
296 my ($libdir, $incdir);
298 if (-d "$Config{installarchlib}/CORE")
300 $libdir = "-L$Config{installarchlib}/CORE";
301 $incdir = "-I$Config{installarchlib}/CORE";
305 $libdir = "-L.. -L.";
306 $incdir = "-I.. -I.";
309 $libdir .= " -L$options->{L}" if (defined($options->{L}));
310 $incdir .= " -I$options->{L}" if (defined($options->{L}));
317 if (!grep(/^-[cS]$/, @args))
319 my $lperl = $^O eq 'os2' ? '-llibperl'
320 : $^O eq 'MSWin32' ? "$Config{archlibexp}\\CORE\\perl.lib"
323 $optimize = $Config{'optimize'} =~ /-O\d/ ? '' : $Config{'optimize'};
325 $flags = $type eq 'dynamic' ? $Config{lddlflags} : $Config{ldflags};
326 $linkargs = "$flags $libdir $lperl @Config{libs}";
329 my $libs = _getSharedObjects($sourceprog);
331 my $cccmd = "$Config{cc} $Config{ccflags} $optimize $incdir "
332 ."@args $dynaloader $linkargs @$libs";
334 _print ("$cccmd\n", 36);
338 sub _getSharedObjects
340 my ($sourceprog) = @_;
341 my ($tmpfile, $incfile);
342 my (@sharedobjects, @libraries);
346 ($tmpprog = $sourceprog) =~ s"(.*)[\\/](.*)"$2";
350 if ($Config{'osname'} eq 'MSWin32')
352 $tempdir = $ENV{TEMP};
353 $tempdir =~ s[\\][/]g;
359 $tmpfile = "$tempdir/$tmpprog.tst";
360 $incfile = "$tempdir/$tmpprog.val";
362 my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
364 new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";
368 my \$fh3 = new FileHandle("> $incfile")
369 || die "Couldn't open $incfile\\n";
372 foreach \$key (keys(\%INC)) { print \$fh3 "\$key:\$INC{\$key}\\n"; }
377 print $fd ( <$fd2> );
380 _print("$^X -I@INC $tmpfile\n", 36);
381 _run("$^X -I@INC $tmpfile", 9 );
383 $fd = new FileHandle ("$incfile");
394 foreach $line (@lines)
398 my ($modname, $modpath) = split(':', $line);
399 my ($dir, $file) = ($modpath=~ m"(.*)[\\/]($modname)");
401 if ($autolib = _lookforAuto($dir, $file)) { push(@return, $autolib); }
410 # if ($Config{'osname'} eq 'MSWin32')
411 # { $return = "C:\\TEMP\\comp$$.p"; }
413 # { $return = "/tmp/comp$$.p"; }
415 $return = "comp$$.p";
417 my $fd = new FileHandle( "> $return") || die "Couldn't open $return!\n";
418 print $fd $options->{'e'};
427 my ($dir, $file) = @_;
429 my ($relabs, $relshared);
433 ($prefix = $file) =~ s"(.*)\.pm"$1";
435 my ($tmp, $modname) = ($prefix =~ m"(?:(.*)[\\/]){0,1}(.*)"s);
437 $relshared = "$pathsep$prefix$pathsep$modname.$Config{so}";
438 $relabs = "$pathsep$prefix$pathsep$modname$Config{_a}";
439 # HACK . WHY DOES _a HAVE A '.'
442 my @searchpaths = map("$_${pathsep}auto", @INC);
445 foreach $path (@searchpaths)
447 if (-e ($return = "$path$relshared")) { return($return); }
448 if (-e ($return = "$path$relabs")) { return($return); }
453 sub _getRegexps # make the appropriate regexps for making executables,
456 my ($program_ext, $module_ext) = ([],[]);
459 @$program_ext = ($ENV{PERL_SCRIPT_EXT})? split(':', $ENV{PERL_SCRIPT_EXT}) :
460 ('.p$', '.pl$', '.bat$');
463 @$module_ext = ($ENV{PERL_MODULE_EXT})? split(':', $ENV{PERL_MODULE_EXT}) :
466 _mungeRegexp( $program_ext );
467 _mungeRegexp( $module_ext );
469 return($program_ext, $module_ext);
476 grep(s:(^|[^\\])\.:$1\x00\\.:g, @$regexp);
477 grep(s:(^|[^\x00])\\\.:$1\.:g, @$regexp);
478 grep(s:\x00::g, @$regexp);
483 my ($type, @args) = @_;
485 if ($type eq 'equal')
488 if ($args[0] eq $args[1])
490 _print ("ERROR: The object file '$args[0]' does not generate a legitimate executable file! Skipping!\n", -1);
494 elsif ($type eq 'badeval')
498 _print ("ERROR: $args[0]\n", -1);
502 elsif ($type eq 'noextension')
504 my $progext = join(',', @{$args[1]});
505 my $modext = join(',', @{$args[2]});
516 ERROR: '$args[0]' does not have a proper extension! Proper extensions are:
519 SHARED OBJECT: $modext
521 Use the '-prog' flag to force your files to be interpreted as programs.
522 Use the '-mod' flag to force your files to be interpreted as modules.
536 if ($options->{'log'})
538 $_fh = new FileHandle(">> $options->{'log'}") || push(@errors, "ERROR: Couldn't open $options->{'log'}\n");
541 if (($options->{'c'}) && (@ARGV > 1) && ($options->{'sav'} ))
544 "ERROR: The '-sav' and '-C' options are incompatible when you have more than
545 one input file! ('-C' explicitly names resulting C code, '-sav' saves it,
546 and hence, with more than one file, the c code will be overwritten for
547 each file that you compile)\n");
549 if (($options->{'o'}) && (@ARGV > 1))
552 "ERROR: The '-o' option is incompatible when you have more than one input file!
553 (-o explicitly names the resulting executable, hence, with more than
554 one file the names clash)\n");
557 if ($options->{'e'} && $options->{'sav'} && !$options->{'o'} &&
561 "ERROR: You need to specify where you are going to save the resulting
562 executable or C code, when using '-sav' and '-e'. Use '-o' or '-C'.\n");
565 if (($options->{'regex'} || $options->{'run'} || $options->{'o'})
566 && $options->{'gen'})
569 "ERROR: The options '-regex', '-run', and '-o' are incompatible with '-gen'.
570 '-gen' says to stop at C generation, and the other three modify the
571 compilation and/or running process!\n");
574 if ($options->{'run'} && $options->{'mod'})
577 "ERROR: Can't run modules that you are compiling! '-run' and '-mod' are
581 if ($options->{'e'} && @ARGV)
584 "ERROR: The option '-e' needs to be all by itself without any other
587 if ($options->{'e'} && !($options->{'o'} || $options->{'run'}))
589 $options->{'run'} = 1;
592 if (!defined($options->{'verbose'}))
594 $options->{'verbose'} = ($options->{'log'})? 64 : 7;
599 if ($options->{'verbose'} =~ m"[^tagfcd]" &&
600 !( $options->{'verbose'} eq '0' ||
601 ($options->{'verbose'} < 64 && $options->{'verbose'} > 0)))
605 "ERROR: Illegal verbosity level. Needs to have either the letters
606 't','a','g','f','c', or 'd' in it or be between 0 and 63, inclusive.\n");
609 $options->{'verbose'} = ($options->{'verbose'} =~ m"[tagfcd]")?
610 ($options->{'verbose'} =~ m"d") * 32 +
611 ($options->{'verbose'} =~ m"c") * 16 +
612 ($options->{'verbose'} =~ m"f") * 8 +
613 ($options->{'verbose'} =~ m"t") * 4 +
614 ($options->{'verbose'} =~ m"a") * 2 +
615 ($options->{'verbose'} =~ m"g") * 1
616 : $options->{'verbose'};
618 if (!$verbose_error && ( $options->{'log'} &&
620 ($options->{'verbose'} & 8) ||
621 ($options->{'verbose'} & 16) ||
622 ($options->{'verbose'} & 32 )
628 "ERROR: The verbosity level '$options->{'verbose'}' does not output anything
629 to a logfile, and you specified '-log'!\n");
632 if (!$verbose_error && ( !$options->{'log'} &&
634 ($options->{'verbose'} & 8) ||
635 ($options->{'verbose'} & 16) ||
636 ($options->{'verbose'} & 32) ||
637 ($options->{'verbose'} & 64)
643 "ERROR: The verbosity level '$options->{'verbose'}' requires that you also
644 specify a logfile via '-log'\n");
648 (_print( "\n". join("\n", @errors), -1), return(0)) if (@errors);
654 my ($text, $flag ) = @_;
656 my $logflag = int($flag/8) * 8;
657 my $regflag = $flag % 8;
659 if ($flag == -1 || ($flag & $options->{'verbose'}))
661 my $dolog = ((($logflag & $options->{'verbose'}) || $flag == -1)
662 && $options->{'log'});
664 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
666 if ($doreg) { print( STDERR $text ); }
667 if ($dolog) { print $_fh $text; }
673 my ($command, $flag) = @_;
675 my $logflag = ($flag != -1)? int($flag/8) * 8 : 0;
676 my $regflag = $flag % 8;
678 if ($flag == -1 || ($flag & $options->{'verbose'}))
680 my $dolog = ($logflag & $options->{'verbose'} && $options->{'log'});
681 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
683 if ($doreg && !$dolog)
685 print _interruptrun("$command");
687 elsif ($doreg && $dolog)
689 my $text = _interruptrun($command);
695 my $text = _interruptrun($command);
701 _interruptrun($command);
709 my $pid = open (FD, "$command 2>&1 |");
711 local($SIG{HUP}) = sub {
713 # HACK... 2>&1 doesn't propogate
714 # kill, comment out for quick and dirty
715 # process killing of child.
720 local($SIG{INT}) = sub {
722 # HACK... 2>&1 doesn't propogate
723 # kill, comment out for quick and dirty
724 # process killing of child.
730 ($ENV{'COMPILE_TIMEOUT'} &&
731 $Config{'osname'} ne 'MSWin32' && $command =~ m"^perlc");
736 local($SIG{ALRM}) = sub { die "INFINITE LOOP"; };
737 alarm($ENV{'COMPILE_TIMEOUT'}) if ($needalarm);
738 $text = join('', <FD>);
739 alarm(0) if ($needalarm);
744 eval { kill 'HUP', $pid; };
745 _print("SYSTEM TIMEOUT (infinite loop?)\n", 36);
758 Usage: $0 <file_list>
761 -L < extra library dirs for installation (form of 'dir1:dir2') >
762 -I < extra include dirs for installation (form of 'dir1:dir2') >
763 -C < explicit name of resulting C code >
764 -o < explicit name of resulting executable >
765 -e < to compile 'one liners'. Need executable name (-o) or '-run'>
766 -regex < rename regex, -regex 's/\.p/\.exe/' compiles a.p to a.exe >
767 -verbose < verbose level < 1-63, or following letters 'gatfcd' >
768 -argv < arguments for the executables to be run via '-run' or '-e' >
771 -gen ( to just generate the c code. Implies '-sav' )
772 -sav ( to save intermediate c code, (and executables with '-run'))
773 -run ( to run the compiled program on the fly, as were interpreted.)
774 -prog ( to indicate that the files on command line are programs )
775 -mod ( to indicate that the files on command line are modules )
789 perlcc - frontend for perl compiler
793 %prompt perlcc a.p # compiles into executable 'a'
795 %prompt perlcc A.pm # compile into 'A.so'
797 %prompt perlcc a.p -o execute # compiles 'a.p' into 'execute'.
799 %prompt perlcc a.p -o execute -run # compiles 'a.p' into execute, runs on
802 %prompt perlcc a.p -o execute -run -argv 'arg1 arg2 arg3'
803 # compiles into execute, runs with
804 # arg1 arg2 arg3 as @ARGV
806 %prompt perlcc a.p b.p c.p -regex 's/\.p/\.exe'
807 # compiles into 'a.exe','b.exe','c.exe'.
809 %prompt perlcc a.p -log compilelog # compiles into 'a', saves compilation
810 # info into compilelog, as well
811 # as mirroring to screen
813 %prompt perlcc a.p -log compilelog -verbose cdf
814 # compiles into 'a', saves compilation
815 # info into compilelog, being silent
818 %prompt perlcc a.p -C a.c -gen # generates C code (into a.c) and
819 # stops without compile.
821 %prompt perlcc a.p -L ../lib a.c
822 # Compiles with the perl libraries
823 # inside ../lib included.
827 'perlcc' is the frontend into the perl compiler. Typing 'perlcc a.p'
828 compiles the code inside a.p into a standalone executable, and
829 perlcc A.pm will compile into a shared object, A.so, suitable for inclusion
830 into a perl program via "use A".
832 There are quite a few flags to perlcc which help with such issues as compiling
833 programs in bulk, testing compiled programs for compatibility with the
834 interpreter, and controlling.
840 =item -L < library_directories >
842 Adds directories in B<library_directories> to the compilation command.
844 =item -I < include_directories >
846 Adds directories inside B<include_directories> to the compilation command.
848 =item -C < c_code_name >
850 Explicitly gives the name B<c_code_name> to the generated c code which is to
851 be compiled. Can only be used if compiling one file on the command line.
853 =item -o < executable_name >
855 Explicitly gives the name B<executable_name> to the executable which is to be
856 compiled. Can only be used if compiling one file on the command line.
858 =item -e < perl_line_to_execute>
860 Compiles 'one liners', in the same way that B<perl -e> runs text strings at
861 the command line. Default is to have the 'one liner' be compiled, and run all
862 in one go (see B<-run>); giving the B<-o> flag saves the resultant executable,
863 rather than throwing it away. Use '-argv' to pass arguments to the executable
866 =item -regex <rename_regex>
868 Gives a rule B<rename_regex> - which is a legal perl regular expression - to
869 create executable file names.
871 =item -verbose <verbose_level>
873 Show exactly what steps perlcc is taking to compile your code. You can change
874 the verbosity level B<verbose_level> much in the same way that the '-D' switch
875 changes perl's debugging level, by giving either a number which is the sum of
876 bits you want or a list of letters representing what you wish to see. Here are
877 the verbosity levels so far :
879 Bit 1(g): Code Generation Errors to STDERR
880 Bit 2(a): Compilation Errors to STDERR
881 Bit 4(t): Descriptive text to STDERR
882 Bit 8(f): Code Generation Errors to file (B<-log> flag needed)
883 Bit 16(c): Compilation Errors to file (B<-log> flag needed)
884 Bit 32(d): Descriptive text to file (B<-log> flag needed)
886 If the B<-log> tag is given, the default verbose level is 63 (ie: mirroring
887 all of perlcc's output to both the screen and to a log file). If no B<-log>
888 tag is given, then the default verbose level is 7 (ie: outputting all of
889 perlcc's output to STDERR).
891 NOTE: Because of buffering concerns, you CANNOT shadow the output of '-run' to
892 both a file, and to the screen! Suggestions are welcome on how to overcome this
893 difficulty, but for now it simply does not work properly, and hence will only go
898 Opens, for append, a logfile to save some or all of the text for a given
899 compile command. No rewrite version is available, so this needs to be done
902 =item -argv <arguments>
904 In combination with '-run' or '-e', tells perlcc to run the resulting
905 executable with the string B<arguments> as @ARGV.
909 Tells perl to save the intermediate C code. Usually, this C code is the name
910 of the perl code, plus '.c'; 'perlcode.p' gets generated in 'perlcode.p.c',
911 for example. If used with the '-e' operator, you need to tell perlcc where to
912 save resulting executables.
916 Tells perlcc to only create the intermediate C code, and not compile the
917 results. Does an implicit B<-sav>, saving the C code rather than deleting it.
921 Immediately run the perl code that has been generated. NOTE: IF YOU GIVE THE
922 B<-run> FLAG TO B<perlcc>, THEN THE REST OF @ARGV WILL BE INTERPRETED AS
923 ARGUMENTS TO THE PROGRAM THAT YOU ARE COMPILING.
927 Indicate that the programs at the command line are programs, and should be
928 compiled as such. B<perlcc> will automatically determine files to be
929 programs if they have B<.p>, B<.pl>, B<.bat> extensions.
933 Indicate that the programs at the command line are modules, and should be
934 compiled as such. B<perlcc> will automatically determine files to be
935 modules if they have the extension B<.pm>.
941 Most of the work of B<perlcc> is done at the command line. However, you can
942 change the heuristic which determines what is a module and what is a program.
943 As indicated above, B<perlcc> assumes that the extensions:
947 indicate a perl program, and:
951 indicate a library, for the purposes of creating executables. And furthermore,
952 by default, these extensions will be replaced (and dropped) in the process of
953 creating an executable.
955 To change the extensions which are programs, and which are modules, set the
956 environmental variables:
961 These two environmental variables take colon-separated, legal perl regular
962 expressions, and are used by perlcc to decide which objects are which.
965 setenv PERL_SCRIPT_EXT '.prl$:.perl$'
966 prompt% perlcc sample.perl
968 will compile the script 'sample.perl' into the executable 'sample', and
970 setenv PERL_MODULE_EXT '.perlmod$:.perlmodule$'
972 prompt% perlcc sample.perlmod
974 will compile the module 'sample.perlmod' into the shared object
977 NOTE: the '.' in the regular expressions for PERL_SCRIPT_EXT and PERL_MODULE_EXT
978 is a literal '.', and not a wild-card. To get a true wild-card, you need to
979 backslash the '.'; as in:
981 setenv PERL_SCRIPT_EXT '\.\.\.\.\.'
983 which would have the effect of compiling ANYTHING (except what is in
984 PERL_MODULE_EXT) into an executable with 5 less characters in its name.
988 'perlcc' uses a temporary file when you use the B<-e> option to evaluate
989 text and compile it. This temporary file is 'perlc$$.p'. The temporary C code is
990 perlc$$.p.c, and the temporary executable is perlc$$.
992 When you use '-run' and don't save your executable, the temporary executable is
997 perlcc currently cannot compile shared objects on Win32. This should be fixed
1004 close OUT or die "Can't close $file: $!";
1005 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
1006 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';