4 use File::Basename qw(&basename &dirname);
8 # List explicitly here the variables you want Configure to
9 # generate. Metaconfig only looks for shell variables, so you
10 # have to mention them as if they were shell variables, not
11 # %Config entries. Thus you write
13 # to ensure Configure will look for $Config{startperl}.
16 # This forces PL files to create target in same directory as PL file.
17 # This is so that make depend always knows where to find PL derivatives.
20 $file = basename($0, '.PL');
21 $file .= '.com' if $^O eq 'VMS';
23 open OUT,">$file" or die "Can't create $file: $!";
25 print "Extracting $file (with variable substitutions)\n";
27 # In this section, perl variables will be expanded during extraction.
28 # You can use $Config{...} to use Configure variables.
30 print OUT <<"!GROK!THIS!";
32 eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
33 if \$running_under_some_shell;
36 # In the following, perl variables are not expanded during extraction.
38 print OUT <<'!NO!SUBS!';
43 use File::Basename qw(&basename &dirname);
48 $Getopt::Long::bundling_override = 1;
49 $Getopt::Long::passthrough = 0;
50 $Getopt::Long::ignore_case = 0;
52 my $pathsep = ($Config{'osname'} eq 'MSWin32')? "\\" : "/"; # MAJOR HACK. SHOULD
57 unshift @ARGV, split ' ', $ENV{PERLCC_OPTS} if $ENV{PERLCC_OPTS};
89 _usage() if (!_checkopts());
90 push(@ARGV, _maketempfile()) if ($options->{'e'});
98 --------------------------------------------------------------------------------
100 --------------------------------------------------------------------------------
110 my ($program_ext, $module_ext) = _getRegexps();
111 my ($obj, $objfile, $so, $type, $backend, $gentype);
113 $backend = $options->{'b'} ? 'Bytecode' : $options->{'opt'} ? 'CC' : 'C';
115 $gentype = $options->{'b'} ? 'Bytecode' : 'C';
118 (($file =~ m"@$program_ext") && ($file !~ m"@$module_ext"))
119 || (defined($options->{'prog'}) || defined($options->{'run'}))
126 $obj = $objfile = $options->{'o'} ? $options->{'o'} : "${file}c";
130 $objfile = $options->{'C'} ? $options->{'C'} : "$file.c";
131 $obj = $options->{'o'} ? $options->{'o'}
132 : _getExecutable( $file,$program_ext);
138 elsif (($file =~ m"@$module_ext") || ($options->{'mod'}))
144 $obj = $objfile = $options->{'o'} ? $options->{'o'} : "${file}c";
148 die "Shared objects are not supported on Win32 yet!!!!\n"
149 if ($Config{'osname'} eq 'MSWin32');
151 $objfile = $options->{'C'} ? $options->{'C'} : "$file.c";
152 $obj = $options->{'o'} ? $options->{'o'}
153 : _getExecutable($file, $module_ext);
154 $so = "$obj.$Config{so}";
161 _error("noextension", $file, $program_ext, $module_ext);
165 if ($type eq 'program')
167 _print("Making $gentype($objfile) for $file!\n", 36 );
169 my $errcode = _createCode($backend, $objfile, $file);
170 (_print( "ERROR: In generating code for $file!\n", -1), return())
173 _print("Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'} &&
175 $errcode = _compileCode($file, $objfile, $obj)
176 if (!$options->{'gen'} &&
181 _print( "ERROR: In compiling code for $objfile !\n", -1);
182 my $ofile = File::Basename::basename($objfile);
183 $ofile =~ s"\.c$"\.o"s;
185 _removeCode("$ofile");
189 _runCode($objfile) if ($options->{'run'} && $options->{'b'});
190 _runCode($obj) if ($options->{'run'} && !$options->{'b'});
192 _removeCode($objfile) if (($options->{'b'} &&
193 ($options->{'e'} && !$options->{'o'})) ||
195 (!$options->{'sav'} ||
196 ($options->{'e'} && !$options->{'C'}))));
198 _removeCode($file) if ($options->{'e'});
200 _removeCode($obj) if (!$options->{'b'} &&
202 !$options->{'sav'} && !$options->{'o'}) ||
203 ($options->{'run'} && !$options->{'sav'})));
207 _print( "Making $gentype($objfile) for $file!\n", 36 );
208 my $errcode = _createCode($backend, $objfile, $file, $obj);
209 (_print( "ERROR: In generating code for $file!\n", -1), return())
212 _print( "Compiling C($so) for $file!\n", 36 ) if (!$options->{'gen'} &&
216 _compileCode($file, $objfile, $obj, $so ) if (!$options->{'gen'} &&
219 (_print( "ERROR: In compiling code for $objfile!\n", -1), return())
226 my ($sourceprog, $ext) = @_;
229 if (defined($options->{'regex'}))
231 eval("(\$obj = \$sourceprog) =~ $options->{'regex'}");
232 return(0) if (_error('badeval', $@));
233 return(0) if (_error('equal', $obj, $sourceprog));
235 elsif (defined ($options->{'ext'}))
237 ($obj = $sourceprog) =~ s"@$ext"$options->{ext}"g;
238 return(0) if (_error('equal', $obj, $sourceprog));
240 elsif (defined ($options->{'run'}))
246 ($obj = $sourceprog) =~ s"@$ext""g;
247 return(0) if (_error('equal', $obj, $sourceprog));
254 my ( $backend, $generated_file, $file, $final_output ) = @_;
256 my $output_switch = "o";
260 if ($backend eq "Bytecode")
264 open(GENFILE, "> $generated_file") || die "Can't open $generated_file: $!";
266 print GENFILE "#!$^X\n" if @_ == 3;
267 print GENFILE "use ByteLoader $ByteLoader::VERSION;\n";
273 if (@_ == 3) # compiling a program
275 chmod $generated_file, 0777 & ~umask if $backend eq "Bytecode";
276 my $null=File::Spec->devnull;
277 _print( "$^X -I@INC -MB::Stash -c $file\n", 36);
278 my @stash=`$^X -I@INC -MB::Stash -c $file 2>$null`;
279 my $stash=$stash[-1];
282 _print( "$^X -I@INC -MO=$backend,$stash $file\n", 36);
283 $return = _run("$^X -I@INC -MO=$backend,$stash,-$output_switch$generated_file $file", 9);
286 else # compiling a shared object
289 "$^X -I@INC -MO=$backend,-m$final_output $file\n", 36);
291 _run("$^X -I@INC -MO=$backend,-m$final_output,-$output_switch$generated_file $file ", 9);
298 my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
301 if (@_ == 3) # just compiling a program
304 _ccharness('static', $sourceprog, "-o", $output_executable,
310 my $object_file = $generated_cfile;
311 $object_file =~ s"\.c$"$Config{_o}";
313 $return[0] = _ccharness('compile', $sourceprog, "-c", $generated_cfile);
314 $return[1] = _ccharness
318 $shared_object, $object_file
320 return(1) if (grep ($_, @return));
327 my ($executable) = @_;
328 _print("$executable $options->{'argv'}\n", 36);
329 _run("$executable $options->{'argv'}", -1 );
335 unlink($file) if (-e $file);
344 my $sourceprog = shift(@args);
345 my ($libdir, $incdir);
347 if (-d "$Config{installarchlib}/CORE")
349 $libdir = "-L$Config{installarchlib}/CORE";
350 $incdir = "-I$Config{installarchlib}/CORE";
354 $libdir = "-L.. -L.";
355 $incdir = "-I.. -I.";
358 $libdir .= " -L$options->{L}" if (defined($options->{L}));
359 $incdir .= " -I$options->{L}" if (defined($options->{L}));
366 if (!grep(/^-[cS]$/, @args))
368 my $lperl = $^O eq 'os2' ? '-llibperl'
369 : $^O eq 'MSWin32' ? "$Config{archlibexp}\\CORE\\perl.lib"
371 ($lperl = $Config{libperl}) =~ s/lib(.*)\Q$Config{_a}\E/-l$1/
374 $optimize = $Config{'optimize'} =~ /-O\d/ ? '' : $Config{'optimize'};
376 $flags = $type eq 'dynamic' ? $Config{lddlflags} : $Config{ldflags};
377 $linkargs = "$flags $libdir $lperl @Config{libs}";
380 my $libs = _getSharedObjects($sourceprog);
381 @$libs = grep { !(/DynaLoader\.a$/ && ($dynaloader = $_)) } @$libs
384 my $ccflags = $Config{ccflags};
385 $ccflags .= ' -DUSEIMPORTLIB' if $^O eq 'cygwin';
386 my $cccmd = "$Config{cc} $ccflags $optimize $incdir "
387 ."@args $dynaloader $linkargs @$libs";
389 _print ("$cccmd\n", 36);
393 sub _getSharedObjects
395 my ($sourceprog) = @_;
396 my ($tmpfile, $incfile);
397 my (@sharedobjects, @libraries);
401 ($tmpprog = $sourceprog) =~ s"(.*)[\\/](.*)"$2";
403 my $tempdir= File::Spec->tmpdir;
405 $tmpfile = "$tempdir/$tmpprog.tst";
406 $incfile = "$tempdir/$tmpprog.val";
408 my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
410 new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";
414 my \$fh3 = new FileHandle("> $incfile")
415 || die "Couldn't open $incfile\\n";
418 foreach \$key (keys(\%INC)) { print \$fh3 "\$key:\$INC{\$key}\\n"; }
423 print $fd ( <$fd2> );
426 _print("$^X -I@INC $tmpfile\n", 36);
427 _run("$^X -I@INC $tmpfile", 9 );
429 $fd = new FileHandle ("$incfile");
440 foreach $line (@lines)
444 my ($modname, $modpath) = split(':', $line);
445 my ($dir, $file) = ($modpath=~ m"(.*)[\\/]($modname)");
447 if ($autolib = _lookforAuto($dir, $file)) { push(@return, $autolib); }
456 # if ($Config{'osname'} eq 'MSWin32')
457 # { $return = "C:\\TEMP\\comp$$.p"; }
459 # { $return = "/tmp/comp$$.p"; }
461 $return = "comp$$.p";
463 my $fd = new FileHandle( "> $return") || die "Couldn't open $return!\n";
464 print $fd $options->{'e'};
473 my ($dir, $file) = @_;
475 my ($relabs, $relshared);
478 my $sharedextension = $^O =~ /MSWin32|cygwin|os2/i
479 ? $Config{_a} : ".$Config{so}";
480 ($prefix = $file) =~ s"(.*)\.pm"$1";
482 my ($tmp, $modname) = ($prefix =~ m"(?:(.*)[\\/]){0,1}(.*)"s);
484 $relshared = "$pathsep$prefix$pathsep$modname$sharedextension";
485 $relabs = "$pathsep$prefix$pathsep$modname$Config{_a}";
486 # HACK . WHY DOES _a HAVE A '.'
489 my @searchpaths = map("$_${pathsep}auto", @INC);
492 foreach $path (@searchpaths)
494 if (-e ($return = "$path$relshared")) { return($return); }
495 if (-e ($return = "$path$relabs")) { return($return); }
500 sub _getRegexps # make the appropriate regexps for making executables,
503 my ($program_ext, $module_ext) = ([],[]);
506 @$program_ext = ($ENV{PERL_SCRIPT_EXT})? split(':', $ENV{PERL_SCRIPT_EXT}) :
507 ('.p$', '.pl$', '.bat$');
510 @$module_ext = ($ENV{PERL_MODULE_EXT})? split(':', $ENV{PERL_MODULE_EXT}) :
513 _mungeRegexp( $program_ext );
514 _mungeRegexp( $module_ext );
516 return($program_ext, $module_ext);
523 grep(s:(^|[^\\])\.:$1\x00\\.:g, @$regexp);
524 grep(s:(^|[^\x00])\\\.:$1\.:g, @$regexp);
525 grep(s:\x00::g, @$regexp);
530 my ($type, @args) = @_;
532 if ($type eq 'equal')
535 if ($args[0] eq $args[1])
537 _print ("ERROR: The object file '$args[0]' does not generate a legitimate executable file! Skipping!\n", -1);
541 elsif ($type eq 'badeval')
545 _print ("ERROR: $args[0]\n", -1);
549 elsif ($type eq 'noextension')
551 my $progext = join(',', @{$args[1]});
552 my $modext = join(',', @{$args[2]});
563 ERROR: '$args[0]' does not have a proper extension! Proper extensions are:
566 SHARED OBJECT: $modext
568 Use the '-prog' flag to force your files to be interpreted as programs.
569 Use the '-mod' flag to force your files to be interpreted as modules.
583 if ($options->{'log'})
585 $_fh = new FileHandle(">> $options->{'log'}") || push(@errors, "ERROR: Couldn't open $options->{'log'}\n");
588 if ($options->{'b'} && $options->{'c'})
591 "ERROR: The '-b' and '-c' options are incompatible. The '-c' option specifies
592 a name for the intermediate C code but '-b' generates byte code
595 if ($options->{'b'} && ($options->{'sav'} || $options->{'gen'}))
598 "ERROR: The '-sav' and '-gen' options are incompatible with the '-b' option.
599 They ask for intermediate C code to be saved by '-b' generates byte
603 if (($options->{'c'}) && (@ARGV > 1) && ($options->{'sav'} ))
606 "ERROR: The '-sav' and '-C' options are incompatible when you have more than
607 one input file! ('-C' explicitly names resulting C code, '-sav' saves it,
608 and hence, with more than one file, the c code will be overwritten for
609 each file that you compile)\n");
611 if (($options->{'o'}) && (@ARGV > 1))
614 "ERROR: The '-o' option is incompatible when you have more than one input
615 file! (-o explicitly names the resulting file, hence, with more than
616 one file the names clash)\n");
619 if ($options->{'e'} && ($options->{'sav'} || $options->{'gen'}) &&
623 "ERROR: You need to specify where you are going to save the resulting
624 C code when using '-sav' and '-e'. Use '-C'.\n");
627 if (($options->{'regex'} || $options->{'run'} || $options->{'o'})
628 && $options->{'gen'})
631 "ERROR: The options '-regex', '-run', and '-o' are incompatible with '-gen'.
632 '-gen' says to stop at C generation, and the other three modify the
633 compilation and/or running process!\n");
636 if ($options->{'run'} && $options->{'mod'})
639 "ERROR: Can't run modules that you are compiling! '-run' and '-mod' are
643 if ($options->{'e'} && @ARGV)
646 "ERROR: The option '-e' needs to be all by itself without any other
649 if ($options->{'e'} && !($options->{'o'} || $options->{'run'}))
651 $options->{'run'} = 1;
654 if (!defined($options->{'verbose'}))
656 $options->{'verbose'} = ($options->{'log'})? 64 : 7;
661 if ($options->{'verbose'} =~ m"[^tagfcd]" &&
662 !( $options->{'verbose'} eq '0' ||
663 ($options->{'verbose'} < 64 && $options->{'verbose'} > 0)))
667 "ERROR: Illegal verbosity level. Needs to have either the letters
668 't','a','g','f','c', or 'd' in it or be between 0 and 63, inclusive.\n");
671 $options->{'verbose'} = ($options->{'verbose'} =~ m"[tagfcd]")?
672 ($options->{'verbose'} =~ m"d") * 32 +
673 ($options->{'verbose'} =~ m"c") * 16 +
674 ($options->{'verbose'} =~ m"f") * 8 +
675 ($options->{'verbose'} =~ m"t") * 4 +
676 ($options->{'verbose'} =~ m"a") * 2 +
677 ($options->{'verbose'} =~ m"g") * 1
678 : $options->{'verbose'};
680 if (!$verbose_error && ( $options->{'log'} &&
682 ($options->{'verbose'} & 8) ||
683 ($options->{'verbose'} & 16) ||
684 ($options->{'verbose'} & 32 )
690 "ERROR: The verbosity level '$options->{'verbose'}' does not output anything
691 to a logfile, and you specified '-log'!\n");
694 if (!$verbose_error && ( !$options->{'log'} &&
696 ($options->{'verbose'} & 8) ||
697 ($options->{'verbose'} & 16) ||
698 ($options->{'verbose'} & 32) ||
699 ($options->{'verbose'} & 64)
705 "ERROR: The verbosity level '$options->{'verbose'}' requires that you also
706 specify a logfile via '-log'\n");
710 (_print( "\n". join("\n", @errors), -1), return(0)) if (@errors);
716 my ($text, $flag ) = @_;
718 my $logflag = int($flag/8) * 8;
719 my $regflag = $flag % 8;
721 if ($flag == -1 || ($flag & $options->{'verbose'}))
723 my $dolog = ((($logflag & $options->{'verbose'}) || $flag == -1)
724 && $options->{'log'});
726 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
728 if ($doreg) { print( STDERR $text ); }
729 if ($dolog) { print $_fh $text; }
735 my ($command, $flag) = @_;
737 my $logflag = ($flag != -1)? int($flag/8) * 8 : 0;
738 my $regflag = $flag % 8;
740 if ($flag == -1 || ($flag & $options->{'verbose'}))
742 my $dolog = ($logflag & $options->{'verbose'} && $options->{'log'});
743 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
745 if ($doreg && !$dolog)
747 print _interruptrun("$command");
749 elsif ($doreg && $dolog)
751 my $text = _interruptrun($command);
757 my $text = _interruptrun($command);
763 _interruptrun($command);
771 my $pid = open (FD, "$command |");
773 local($SIG{HUP}) = sub {
775 # HACK... 2>&1 doesn't propogate
776 # kill, comment out for quick and dirty
777 # process killing of child.
782 local($SIG{INT}) = sub {
784 # HACK... 2>&1 doesn't propogate
785 # kill, comment out for quick and dirty
786 # process killing of child.
792 ($ENV{'PERLCC_TIMEOUT'} &&
793 $Config{'osname'} ne 'MSWin32' && $command =~ m"^perlc");
798 local($SIG{ALRM}) = sub { die "INFINITE LOOP"; };
799 alarm($ENV{'PERLCC_TIMEOUT'}) if ($needalarm);
800 $text = join('', <FD>);
801 alarm(0) if ($needalarm);
806 eval { kill 'HUP', $pid; };
807 _print("SYSTEM TIMEOUT (infinite loop?)\n", 36);
820 Usage: $0 <file_list>
822 WARNING: The whole compiler suite ('perlcc' included) is considered VERY
823 experimental. Use for production purposes is strongly discouraged.
826 -L < extra library dirs for installation (form of 'dir1:dir2') >
827 -I < extra include dirs for installation (form of 'dir1:dir2') >
828 -C < explicit name of resulting C code >
829 -o < explicit name of resulting executable >
830 -e < to compile 'one liners'. Need executable name (-o) or '-run'>
831 -regex < rename regex, -regex 's/\.p/\.exe/' compiles a.p to a.exe >
832 -verbose < verbose level < 1-63, or following letters 'gatfcd' >
833 -argv < arguments for the executables to be run via '-run' or '-e' >
836 -b ( to generate byte code )
837 -opt ( to generated optimised C code. May not work in some cases. )
838 -gen ( to just generate the C code. Implies '-sav' )
839 -sav ( to save intermediate C code, (and executables with '-run'))
840 -run ( to run the compiled program on the fly, as were interpreted.)
841 -prog ( to indicate that the files on command line are programs )
842 -mod ( to indicate that the files on command line are modules )
856 perlcc - frontend for perl compiler
860 %prompt perlcc a.p # compiles into executable 'a'
862 %prompt perlcc A.pm # compile into 'A.so'
864 %prompt perlcc a.p -o execute # compiles 'a.p' into 'execute'.
866 %prompt perlcc a.p -o execute -run # compiles 'a.p' into execute, runs on
869 %prompt perlcc a.p -o execute -run -argv 'arg1 arg2 arg3'
870 # compiles into execute, runs with
871 # arg1 arg2 arg3 as @ARGV
873 %prompt perlcc a.p b.p c.p -regex 's/\.p/\.exe'
874 # compiles into 'a.exe','b.exe','c.exe'.
876 %prompt perlcc a.p -log compilelog # compiles into 'a', saves compilation
877 # info into compilelog, as well
878 # as mirroring to screen
880 %prompt perlcc a.p -log compilelog -verbose cdf
881 # compiles into 'a', saves compilation
882 # info into compilelog, being silent
885 %prompt perlcc a.p -C a.c -gen # generates C code (into a.c) and
886 # stops without compile.
888 %prompt perlcc a.p -L ../lib a.c
889 # Compiles with the perl libraries
890 # inside ../lib included.
894 'perlcc' is the frontend into the perl compiler. Typing 'perlcc a.p'
895 compiles the code inside a.p into a standalone executable, and
896 perlcc A.pm will compile into a shared object, A.so, suitable for inclusion
897 into a perl program via "use A".
899 There are quite a few flags to perlcc which help with such issues as compiling
900 programs in bulk, testing compiled programs for compatibility with the
901 interpreter, and controlling.
907 =item -L < library_directories >
909 Adds directories in B<library_directories> to the compilation command.
911 =item -I < include_directories >
913 Adds directories inside B<include_directories> to the compilation command.
915 =item -C < c_code_name >
917 Explicitly gives the name B<c_code_name> to the generated file containing
918 the C code which is to be compiled. Can only be used if compiling one file
921 =item -o < executable_name >
923 Explicitly gives the name B<executable_name> to the executable which is to be
924 compiled. Can only be used if compiling one file on the command line.
926 =item -e < perl_line_to_execute>
928 Compiles 'one liners', in the same way that B<perl -e> runs text strings at
929 the command line. Default is to have the 'one liner' be compiled, and run all
930 in one go (see B<-run>); giving the B<-o> flag saves the resultant executable,
931 rather than throwing it away. Use '-argv' to pass arguments to the executable
936 Generates bytecode instead of C code.
940 Uses the optimized C backend (C<B::CC>)rather than the simple C backend
941 (C<B::C>). Beware that the optimized C backend creates very large
942 switch structures and structure initializations. Many C compilers
943 find it a challenge to compile the resulting output in finite amounts
944 of time. Many Perl features such as C<goto LABEL> are also not
945 supported by the optimized C backend. The simple C backend should
946 work in more instances, but can only offer modest speed increases.
948 =item -regex <rename_regex>
950 Gives a rule B<rename_regex> - which is a legal perl regular expression - to
951 create executable file names.
953 =item -verbose <verbose_level>
955 Show exactly what steps perlcc is taking to compile your code. You can
956 change the verbosity level B<verbose_level> much in the same way that
957 the C<-D> switch changes perl's debugging level, by giving either a
958 number which is the sum of bits you want or a list of letters
959 representing what you wish to see. Here are the verbosity levels so
962 Bit 1(g): Code Generation Errors to STDERR
963 Bit 2(a): Compilation Errors to STDERR
964 Bit 4(t): Descriptive text to STDERR
965 Bit 8(f): Code Generation Errors to file (B<-log> flag needed)
966 Bit 16(c): Compilation Errors to file (B<-log> flag needed)
967 Bit 32(d): Descriptive text to file (B<-log> flag needed)
969 If the B<-log> tag is given, the default verbose level is 63 (ie: mirroring
970 all of perlcc's output to both the screen and to a log file). If no B<-log>
971 tag is given, then the default verbose level is 7 (ie: outputting all of
972 perlcc's output to STDERR).
974 NOTE: Because of buffering concerns, you CANNOT shadow the output of '-run' to
975 both a file, and to the screen! Suggestions are welcome on how to overcome this
976 difficulty, but for now it simply does not work properly, and hence will only go
981 Opens, for append, a logfile to save some or all of the text for a given
982 compile command. No rewrite version is available, so this needs to be done
985 =item -argv <arguments>
987 In combination with C<-run> or C<-e>, tells perlcc to run the resulting
988 executable with the string B<arguments> as @ARGV.
992 Tells perl to save the intermediate C code. Usually, this C code is the name
993 of the perl code, plus '.c'; 'perlcode.p' gets generated in 'perlcode.p.c',
994 for example. If used with the C<-e> operator, you need to tell perlcc where to
995 save resulting executables.
999 Tells perlcc to only create the intermediate C code, and not compile the
1000 results. Does an implicit B<-sav>, saving the C code rather than deleting it.
1004 Immediately run the perl code that has been generated. NOTE: IF YOU GIVE THE
1005 B<-run> FLAG TO B<perlcc>, THEN THE REST OF @ARGV WILL BE INTERPRETED AS
1006 ARGUMENTS TO THE PROGRAM THAT YOU ARE COMPILING.
1010 Indicate that the programs at the command line are programs, and should be
1011 compiled as such. B<perlcc> will automatically determine files to be
1012 programs if they have B<.p>, B<.pl>, B<.bat> extensions.
1016 Indicate that the programs at the command line are modules, and should be
1017 compiled as such. B<perlcc> will automatically determine files to be
1018 modules if they have the extension B<.pm>.
1024 Most of the work of B<perlcc> is done at the command line. However, you can
1025 change the heuristic which determines what is a module and what is a program.
1026 As indicated above, B<perlcc> assumes that the extensions:
1028 .p$, .pl$, and .bat$
1030 indicate a perl program, and:
1034 indicate a library, for the purposes of creating executables. And furthermore,
1035 by default, these extensions will be replaced (and dropped) in the process of
1036 creating an executable.
1038 To change the extensions which are programs, and which are modules, set the
1039 environmental variables:
1044 These two environmental variables take colon-separated, legal perl regular
1045 expressions, and are used by perlcc to decide which objects are which.
1048 setenv PERL_SCRIPT_EXT '.prl$:.perl$'
1049 prompt% perlcc sample.perl
1051 will compile the script 'sample.perl' into the executable 'sample', and
1053 setenv PERL_MODULE_EXT '.perlmod$:.perlmodule$'
1055 prompt% perlcc sample.perlmod
1057 will compile the module 'sample.perlmod' into the shared object
1060 NOTE: the '.' in the regular expressions for PERL_SCRIPT_EXT and PERL_MODULE_EXT
1061 is a literal '.', and not a wild-card. To get a true wild-card, you need to
1062 backslash the '.'; as in:
1064 setenv PERL_SCRIPT_EXT '\.\.\.\.\.'
1066 which would have the effect of compiling ANYTHING (except what is in
1067 PERL_MODULE_EXT) into an executable with 5 less characters in its name.
1069 The PERLCC_OPTS environment variable can be set to the default flags
1070 that must be used by the compiler.
1072 The PERLCC_TIMEOUT environment variable can be set to the number of
1073 seconds to wait for the backends before giving up. This is sometimes
1074 necessary to avoid some compilers taking forever to compile the
1075 generated output. May not work on Windows and similar platforms.
1079 'perlcc' uses a temporary file when you use the B<-e> option to evaluate
1080 text and compile it. This temporary file is 'perlc$$.p'. The temporary C code is
1081 perlc$$.p.c, and the temporary executable is perlc$$.
1083 When you use '-run' and don't save your executable, the temporary executable is
1088 The whole compiler suite (C<perlcc> included) should be considered very
1089 experimental. Use for production purposes is strongly discouraged.
1091 perlcc currently cannot compile shared objects on Win32. This should be fixed
1094 Bugs in the various compiler backends still exist, and are perhaps too
1095 numerous to list here.
1101 close OUT or die "Can't close $file: $!";
1102 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
1103 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';