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 open(GENFILE, "> $generated_file") || die "Can't open $generated_file: $!";
262 if ($backend eq "Bytecode")
266 print GENFILE "#!$^X\n" if @_ == 3;
267 print GENFILE "use ByteLoader $ByteLoader::VERSION;\n";
274 if (@_ == 3) # compiling a program
276 chmod $generated_file, 0777 & ~umask if $backend eq "Bytecode";
277 my $null=File::Spec->devnull;
278 _print( "$^X -I@INC -MB::Stash -c $file\n", 36);
279 my @stash=`$^X -I@INC -MB::Stash -c $file 2>$null`;
280 my $stash=$stash[-1];
283 _print( "$^X -I@INC -MO=$backend,$stash $file\n", 36);
284 $return = _run("$^X -I@INC -MO=$backend,$stash,-$output_switch$generated_file $file", 9);
287 else # compiling a shared object
290 "$^X -I@INC -MO=$backend,-m$final_output $file\n", 36);
292 _run("$^X -I@INC -MO=$backend,-m$final_output,-$output_switch$generated_file $file ", 9);
299 my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
302 if (@_ == 3) # just compiling a program
305 _ccharness('static', $sourceprog, "-o", $output_executable,
311 my $object_file = $generated_cfile;
312 $object_file =~ s"\.c$"$Config{_o}";
314 $return[0] = _ccharness('compile', $sourceprog, "-c", $generated_cfile);
315 $return[1] = _ccharness
319 $shared_object, $object_file
321 return(1) if (grep ($_, @return));
328 my ($executable) = @_;
329 _print("$executable $options->{'argv'}\n", 36);
330 _run("$executable $options->{'argv'}", -1 );
336 unlink($file) if (-e $file);
345 my $sourceprog = shift(@args);
346 my ($libdir, $incdir);
348 if (-d "$Config{installarchlib}/CORE")
350 $libdir = "-L$Config{installarchlib}/CORE";
351 $incdir = "-I$Config{installarchlib}/CORE";
355 $libdir = "-L.. -L.";
356 $incdir = "-I.. -I.";
359 $libdir .= " -L$options->{L}" if (defined($options->{L}));
360 $incdir .= " -I$options->{L}" if (defined($options->{L}));
367 if (!grep(/^-[cS]$/, @args))
369 my $lperl = $^O eq 'os2' ? '-llibperl'
370 : $^O eq 'MSWin32' ? "$Config{archlibexp}\\CORE\\perl.lib"
373 $optimize = $Config{'optimize'} =~ /-O\d/ ? '' : $Config{'optimize'};
375 $flags = $type eq 'dynamic' ? $Config{lddlflags} : $Config{ldflags};
376 $linkargs = "$flags $libdir $lperl @Config{libs}";
379 my $libs = _getSharedObjects($sourceprog);
381 my $ccflags = $Config{ccflags};
382 $ccflags .= ' -DUSEIMPORTLIB' if $Config{osname} =~ /cygwin/i;
383 my $cccmd = "$Config{cc} $ccflags $optimize $incdir "
384 ."@args $dynaloader $linkargs @$libs";
386 _print ("$cccmd\n", 36);
390 sub _getSharedObjects
392 my ($sourceprog) = @_;
393 my ($tmpfile, $incfile);
394 my (@sharedobjects, @libraries);
398 ($tmpprog = $sourceprog) =~ s"(.*)[\\/](.*)"$2";
400 my $tempdir= File::Spec->tmpdir;
402 $tmpfile = "$tempdir/$tmpprog.tst";
403 $incfile = "$tempdir/$tmpprog.val";
405 my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
407 new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";
411 my \$fh3 = new FileHandle("> $incfile")
412 || die "Couldn't open $incfile\\n";
415 foreach \$key (keys(\%INC)) { print \$fh3 "\$key:\$INC{\$key}\\n"; }
420 print $fd ( <$fd2> );
423 _print("$^X -I@INC $tmpfile\n", 36);
424 _run("$^X -I@INC $tmpfile", 9 );
426 $fd = new FileHandle ("$incfile");
437 foreach $line (@lines)
441 my ($modname, $modpath) = split(':', $line);
442 my ($dir, $file) = ($modpath=~ m"(.*)[\\/]($modname)");
444 if ($autolib = _lookforAuto($dir, $file)) { push(@return, $autolib); }
453 # if ($Config{'osname'} eq 'MSWin32')
454 # { $return = "C:\\TEMP\\comp$$.p"; }
456 # { $return = "/tmp/comp$$.p"; }
458 $return = "comp$$.p";
460 my $fd = new FileHandle( "> $return") || die "Couldn't open $return!\n";
461 print $fd $options->{'e'};
470 my ($dir, $file) = @_;
472 my ($relabs, $relshared);
475 my $sharedextension = $^O =~ /MSWin32|cygwin|os2/i
476 ? $Config{_a} : ".$Config{so}";
477 ($prefix = $file) =~ s"(.*)\.pm"$1";
479 my ($tmp, $modname) = ($prefix =~ m"(?:(.*)[\\/]){0,1}(.*)"s);
481 $relshared = "$pathsep$prefix$pathsep$modname$sharedextension";
482 $relabs = "$pathsep$prefix$pathsep$modname$Config{_a}";
483 # HACK . WHY DOES _a HAVE A '.'
486 my @searchpaths = map("$_${pathsep}auto", @INC);
489 foreach $path (@searchpaths)
491 if (-e ($return = "$path$relshared")) { return($return); }
492 if (-e ($return = "$path$relabs")) { return($return); }
497 sub _getRegexps # make the appropriate regexps for making executables,
500 my ($program_ext, $module_ext) = ([],[]);
503 @$program_ext = ($ENV{PERL_SCRIPT_EXT})? split(':', $ENV{PERL_SCRIPT_EXT}) :
504 ('.p$', '.pl$', '.bat$');
507 @$module_ext = ($ENV{PERL_MODULE_EXT})? split(':', $ENV{PERL_MODULE_EXT}) :
510 _mungeRegexp( $program_ext );
511 _mungeRegexp( $module_ext );
513 return($program_ext, $module_ext);
520 grep(s:(^|[^\\])\.:$1\x00\\.:g, @$regexp);
521 grep(s:(^|[^\x00])\\\.:$1\.:g, @$regexp);
522 grep(s:\x00::g, @$regexp);
527 my ($type, @args) = @_;
529 if ($type eq 'equal')
532 if ($args[0] eq $args[1])
534 _print ("ERROR: The object file '$args[0]' does not generate a legitimate executable file! Skipping!\n", -1);
538 elsif ($type eq 'badeval')
542 _print ("ERROR: $args[0]\n", -1);
546 elsif ($type eq 'noextension')
548 my $progext = join(',', @{$args[1]});
549 my $modext = join(',', @{$args[2]});
560 ERROR: '$args[0]' does not have a proper extension! Proper extensions are:
563 SHARED OBJECT: $modext
565 Use the '-prog' flag to force your files to be interpreted as programs.
566 Use the '-mod' flag to force your files to be interpreted as modules.
580 if ($options->{'log'})
582 $_fh = new FileHandle(">> $options->{'log'}") || push(@errors, "ERROR: Couldn't open $options->{'log'}\n");
585 if ($options->{'b'} && $options->{'c'})
588 "ERROR: The '-b' and '-c' options are incompatible. The '-c' option specifies
589 a name for the intermediate C code but '-b' generates byte code
592 if ($options->{'b'} && ($options->{'sav'} || $options->{'gen'}))
595 "ERROR: The '-sav' and '-gen' options are incompatible with the '-b' option.
596 They ask for intermediate C code to be saved by '-b' generates byte
600 if (($options->{'c'}) && (@ARGV > 1) && ($options->{'sav'} ))
603 "ERROR: The '-sav' and '-C' options are incompatible when you have more than
604 one input file! ('-C' explicitly names resulting C code, '-sav' saves it,
605 and hence, with more than one file, the c code will be overwritten for
606 each file that you compile)\n");
608 if (($options->{'o'}) && (@ARGV > 1))
611 "ERROR: The '-o' option is incompatible when you have more than one input
612 file! (-o explicitly names the resulting file, hence, with more than
613 one file the names clash)\n");
616 if ($options->{'e'} && ($options->{'sav'} || $options->{'gen'}) &&
620 "ERROR: You need to specify where you are going to save the resulting
621 C code when using '-sav' and '-e'. Use '-C'.\n");
624 if (($options->{'regex'} || $options->{'run'} || $options->{'o'})
625 && $options->{'gen'})
628 "ERROR: The options '-regex', '-run', and '-o' are incompatible with '-gen'.
629 '-gen' says to stop at C generation, and the other three modify the
630 compilation and/or running process!\n");
633 if ($options->{'run'} && $options->{'mod'})
636 "ERROR: Can't run modules that you are compiling! '-run' and '-mod' are
640 if ($options->{'e'} && @ARGV)
643 "ERROR: The option '-e' needs to be all by itself without any other
646 if ($options->{'e'} && !($options->{'o'} || $options->{'run'}))
648 $options->{'run'} = 1;
651 if (!defined($options->{'verbose'}))
653 $options->{'verbose'} = ($options->{'log'})? 64 : 7;
658 if ($options->{'verbose'} =~ m"[^tagfcd]" &&
659 !( $options->{'verbose'} eq '0' ||
660 ($options->{'verbose'} < 64 && $options->{'verbose'} > 0)))
664 "ERROR: Illegal verbosity level. Needs to have either the letters
665 't','a','g','f','c', or 'd' in it or be between 0 and 63, inclusive.\n");
668 $options->{'verbose'} = ($options->{'verbose'} =~ m"[tagfcd]")?
669 ($options->{'verbose'} =~ m"d") * 32 +
670 ($options->{'verbose'} =~ m"c") * 16 +
671 ($options->{'verbose'} =~ m"f") * 8 +
672 ($options->{'verbose'} =~ m"t") * 4 +
673 ($options->{'verbose'} =~ m"a") * 2 +
674 ($options->{'verbose'} =~ m"g") * 1
675 : $options->{'verbose'};
677 if (!$verbose_error && ( $options->{'log'} &&
679 ($options->{'verbose'} & 8) ||
680 ($options->{'verbose'} & 16) ||
681 ($options->{'verbose'} & 32 )
687 "ERROR: The verbosity level '$options->{'verbose'}' does not output anything
688 to a logfile, and you specified '-log'!\n");
691 if (!$verbose_error && ( !$options->{'log'} &&
693 ($options->{'verbose'} & 8) ||
694 ($options->{'verbose'} & 16) ||
695 ($options->{'verbose'} & 32) ||
696 ($options->{'verbose'} & 64)
702 "ERROR: The verbosity level '$options->{'verbose'}' requires that you also
703 specify a logfile via '-log'\n");
707 (_print( "\n". join("\n", @errors), -1), return(0)) if (@errors);
713 my ($text, $flag ) = @_;
715 my $logflag = int($flag/8) * 8;
716 my $regflag = $flag % 8;
718 if ($flag == -1 || ($flag & $options->{'verbose'}))
720 my $dolog = ((($logflag & $options->{'verbose'}) || $flag == -1)
721 && $options->{'log'});
723 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
725 if ($doreg) { print( STDERR $text ); }
726 if ($dolog) { print $_fh $text; }
732 my ($command, $flag) = @_;
734 my $logflag = ($flag != -1)? int($flag/8) * 8 : 0;
735 my $regflag = $flag % 8;
737 if ($flag == -1 || ($flag & $options->{'verbose'}))
739 my $dolog = ($logflag & $options->{'verbose'} && $options->{'log'});
740 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
742 if ($doreg && !$dolog)
744 print _interruptrun("$command");
746 elsif ($doreg && $dolog)
748 my $text = _interruptrun($command);
754 my $text = _interruptrun($command);
760 _interruptrun($command);
768 my $pid = open (FD, "$command |");
770 local($SIG{HUP}) = sub {
772 # HACK... 2>&1 doesn't propogate
773 # kill, comment out for quick and dirty
774 # process killing of child.
779 local($SIG{INT}) = sub {
781 # HACK... 2>&1 doesn't propogate
782 # kill, comment out for quick and dirty
783 # process killing of child.
789 ($ENV{'PERLCC_TIMEOUT'} &&
790 $Config{'osname'} ne 'MSWin32' && $command =~ m"^perlc");
795 local($SIG{ALRM}) = sub { die "INFINITE LOOP"; };
796 alarm($ENV{'PERLCC_TIMEOUT'}) if ($needalarm);
797 $text = join('', <FD>);
798 alarm(0) if ($needalarm);
803 eval { kill 'HUP', $pid; };
804 _print("SYSTEM TIMEOUT (infinite loop?)\n", 36);
817 Usage: $0 <file_list>
819 WARNING: The whole compiler suite ('perlcc' included) is considered VERY
820 experimental. Use for production purposes is strongly discouraged.
823 -L < extra library dirs for installation (form of 'dir1:dir2') >
824 -I < extra include dirs for installation (form of 'dir1:dir2') >
825 -C < explicit name of resulting C code >
826 -o < explicit name of resulting executable >
827 -e < to compile 'one liners'. Need executable name (-o) or '-run'>
828 -regex < rename regex, -regex 's/\.p/\.exe/' compiles a.p to a.exe >
829 -verbose < verbose level < 1-63, or following letters 'gatfcd' >
830 -argv < arguments for the executables to be run via '-run' or '-e' >
833 -b ( to generate byte code )
834 -opt ( to generated optimised C code. May not work in some cases. )
835 -gen ( to just generate the C code. Implies '-sav' )
836 -sav ( to save intermediate C code, (and executables with '-run'))
837 -run ( to run the compiled program on the fly, as were interpreted.)
838 -prog ( to indicate that the files on command line are programs )
839 -mod ( to indicate that the files on command line are modules )
853 perlcc - frontend for perl compiler
857 %prompt perlcc a.p # compiles into executable 'a'
859 %prompt perlcc A.pm # compile into 'A.so'
861 %prompt perlcc a.p -o execute # compiles 'a.p' into 'execute'.
863 %prompt perlcc a.p -o execute -run # compiles 'a.p' into execute, runs on
866 %prompt perlcc a.p -o execute -run -argv 'arg1 arg2 arg3'
867 # compiles into execute, runs with
868 # arg1 arg2 arg3 as @ARGV
870 %prompt perlcc a.p b.p c.p -regex 's/\.p/\.exe'
871 # compiles into 'a.exe','b.exe','c.exe'.
873 %prompt perlcc a.p -log compilelog # compiles into 'a', saves compilation
874 # info into compilelog, as well
875 # as mirroring to screen
877 %prompt perlcc a.p -log compilelog -verbose cdf
878 # compiles into 'a', saves compilation
879 # info into compilelog, being silent
882 %prompt perlcc a.p -C a.c -gen # generates C code (into a.c) and
883 # stops without compile.
885 %prompt perlcc a.p -L ../lib a.c
886 # Compiles with the perl libraries
887 # inside ../lib included.
891 'perlcc' is the frontend into the perl compiler. Typing 'perlcc a.p'
892 compiles the code inside a.p into a standalone executable, and
893 perlcc A.pm will compile into a shared object, A.so, suitable for inclusion
894 into a perl program via "use A".
896 There are quite a few flags to perlcc which help with such issues as compiling
897 programs in bulk, testing compiled programs for compatibility with the
898 interpreter, and controlling.
904 =item -L < library_directories >
906 Adds directories in B<library_directories> to the compilation command.
908 =item -I < include_directories >
910 Adds directories inside B<include_directories> to the compilation command.
912 =item -C < c_code_name >
914 Explicitly gives the name B<c_code_name> to the generated file containing
915 the C code which is to be compiled. Can only be used if compiling one file
918 =item -o < executable_name >
920 Explicitly gives the name B<executable_name> to the executable which is to be
921 compiled. Can only be used if compiling one file on the command line.
923 =item -e < perl_line_to_execute>
925 Compiles 'one liners', in the same way that B<perl -e> runs text strings at
926 the command line. Default is to have the 'one liner' be compiled, and run all
927 in one go (see B<-run>); giving the B<-o> flag saves the resultant executable,
928 rather than throwing it away. Use '-argv' to pass arguments to the executable
933 Generates bytecode instead of C code.
937 Uses the optimized C backend (C<B::CC>)rather than the simple C backend
938 (C<B::C>). Beware that the optimized C backend creates very large
939 switch structures and structure initializations. Many C compilers
940 find it a challenge to compile the resulting output in finite amounts
941 of time. Many Perl features such as C<goto LABEL> are also not
942 supported by the optimized C backend. The simple C backend should
943 work in more instances, but can only offer modest speed increases.
945 =item -regex <rename_regex>
947 Gives a rule B<rename_regex> - which is a legal perl regular expression - to
948 create executable file names.
950 =item -verbose <verbose_level>
952 Show exactly what steps perlcc is taking to compile your code. You can
953 change the verbosity level B<verbose_level> much in the same way that
954 the C<-D> switch changes perl's debugging level, by giving either a
955 number which is the sum of bits you want or a list of letters
956 representing what you wish to see. Here are the verbosity levels so
959 Bit 1(g): Code Generation Errors to STDERR
960 Bit 2(a): Compilation Errors to STDERR
961 Bit 4(t): Descriptive text to STDERR
962 Bit 8(f): Code Generation Errors to file (B<-log> flag needed)
963 Bit 16(c): Compilation Errors to file (B<-log> flag needed)
964 Bit 32(d): Descriptive text to file (B<-log> flag needed)
966 If the B<-log> tag is given, the default verbose level is 63 (ie: mirroring
967 all of perlcc's output to both the screen and to a log file). If no B<-log>
968 tag is given, then the default verbose level is 7 (ie: outputting all of
969 perlcc's output to STDERR).
971 NOTE: Because of buffering concerns, you CANNOT shadow the output of '-run' to
972 both a file, and to the screen! Suggestions are welcome on how to overcome this
973 difficulty, but for now it simply does not work properly, and hence will only go
978 Opens, for append, a logfile to save some or all of the text for a given
979 compile command. No rewrite version is available, so this needs to be done
982 =item -argv <arguments>
984 In combination with C<-run> or C<-e>, tells perlcc to run the resulting
985 executable with the string B<arguments> as @ARGV.
989 Tells perl to save the intermediate C code. Usually, this C code is the name
990 of the perl code, plus '.c'; 'perlcode.p' gets generated in 'perlcode.p.c',
991 for example. If used with the C<-e> operator, you need to tell perlcc where to
992 save resulting executables.
996 Tells perlcc to only create the intermediate C code, and not compile the
997 results. Does an implicit B<-sav>, saving the C code rather than deleting it.
1001 Immediately run the perl code that has been generated. NOTE: IF YOU GIVE THE
1002 B<-run> FLAG TO B<perlcc>, THEN THE REST OF @ARGV WILL BE INTERPRETED AS
1003 ARGUMENTS TO THE PROGRAM THAT YOU ARE COMPILING.
1007 Indicate that the programs at the command line are programs, and should be
1008 compiled as such. B<perlcc> will automatically determine files to be
1009 programs if they have B<.p>, B<.pl>, B<.bat> extensions.
1013 Indicate that the programs at the command line are modules, and should be
1014 compiled as such. B<perlcc> will automatically determine files to be
1015 modules if they have the extension B<.pm>.
1021 Most of the work of B<perlcc> is done at the command line. However, you can
1022 change the heuristic which determines what is a module and what is a program.
1023 As indicated above, B<perlcc> assumes that the extensions:
1025 .p$, .pl$, and .bat$
1027 indicate a perl program, and:
1031 indicate a library, for the purposes of creating executables. And furthermore,
1032 by default, these extensions will be replaced (and dropped) in the process of
1033 creating an executable.
1035 To change the extensions which are programs, and which are modules, set the
1036 environmental variables:
1041 These two environmental variables take colon-separated, legal perl regular
1042 expressions, and are used by perlcc to decide which objects are which.
1045 setenv PERL_SCRIPT_EXT '.prl$:.perl$'
1046 prompt% perlcc sample.perl
1048 will compile the script 'sample.perl' into the executable 'sample', and
1050 setenv PERL_MODULE_EXT '.perlmod$:.perlmodule$'
1052 prompt% perlcc sample.perlmod
1054 will compile the module 'sample.perlmod' into the shared object
1057 NOTE: the '.' in the regular expressions for PERL_SCRIPT_EXT and PERL_MODULE_EXT
1058 is a literal '.', and not a wild-card. To get a true wild-card, you need to
1059 backslash the '.'; as in:
1061 setenv PERL_SCRIPT_EXT '\.\.\.\.\.'
1063 which would have the effect of compiling ANYTHING (except what is in
1064 PERL_MODULE_EXT) into an executable with 5 less characters in its name.
1066 The PERLCC_OPTS environment variable can be set to the default flags
1067 that must be used by the compiler.
1069 The PERLCC_TIMEOUT environment variable can be set to the number of
1070 seconds to wait for the backends before giving up. This is sometimes
1071 necessary to avoid some compilers taking forever to compile the
1072 generated output. May not work on Windows and similar platforms.
1076 'perlcc' uses a temporary file when you use the B<-e> option to evaluate
1077 text and compile it. This temporary file is 'perlc$$.p'. The temporary C code is
1078 perlc$$.p.c, and the temporary executable is perlc$$.
1080 When you use '-run' and don't save your executable, the temporary executable is
1085 The whole compiler suite (C<perlcc> included) should be considered very
1086 experimental. Use for production purposes is strongly discouraged.
1088 perlcc currently cannot compile shared objects on Win32. This should be fixed
1091 Bugs in the various compiler backends still exist, and are perhaps too
1092 numerous to list here.
1098 close OUT or die "Can't close $file: $!";
1099 chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
1100 exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';