This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
[ PATCH 5.004_64 ] Integrated regression tests for compiler
[perl5.git] / utils / perlcc.PL
CommitLineData
52cebf5e
EP
1#!/usr/local/bin/perl
2
3use Config;
4use File::Basename qw(&basename &dirname);
5
6# List explicitly here the variables you want Configure to
7# generate. Metaconfig only looks for shell variables, so you
8# have to mention them as if they were shell variables, not
9# %Config entries. Thus you write
10# $startperl
11# to ensure Configure will look for $Config{startperl}.
12# Wanted: $archlibexp
13
14# This forces PL files to create target in same directory as PL file.
15# This is so that make depend always knows where to find PL derivatives.
16chdir dirname($0);
17$file = basename($0, '.PL');
18$file .= '.com' if $^O eq 'VMS';
19
20open OUT,">$file" or die "Can't create $file: $!";
21
22print "Extracting $file (with variable substitutions)\n";
23
24# In this section, perl variables will be expanded during extraction.
25# You can use $Config{...} to use Configure variables.
26
27print OUT <<"!GROK!THIS!";
28$Config{startperl}
29 eval 'exec $Config{perlpath} -S \$0 \${1+"\$@"}'
30 if \$running_under_some_shell;
31!GROK!THIS!
32
33# In the following, perl variables are not expanded during extraction.
34
35print OUT <<'!NO!SUBS!';
36
37use Config;
38use strict;
39use FileHandle;
40use File::Basename qw(&basename &dirname);
41
42use Getopt::Long;
43
44$Getopt::Long::bundling_override = 1;
45$Getopt::Long::passthrough = 0;
46$Getopt::Long::ignore_case = 0;
47
48my $options = {};
49my $_fh;
50
51main();
52
53sub main
54{
55
56 GetOptions
57 (
58 $options, "L:s",
59 "I:s",
60 "C:s",
61 "o:s",
62 "e:s",
63 "regex:s",
64 "verbose:s",
65 "log:s",
66 "argv:s",
67 "gen",
68 "sav",
69 "run",
70 "prog",
71 "mod"
72 );
73
74
75 my $key;
76
77 local($") = "|";
78
79 _usage() if (!_checkopts());
80 push(@ARGV, _maketempfile()) if ($options->{'e'});
81
82 _usage() if (!@ARGV);
83
84 my $file;
85 foreach $file (@ARGV)
86 {
87 _print("
88--------------------------------------------------------------------------------
89Compiling $file:
90--------------------------------------------------------------------------------
91", 36 );
92 _doit($file);
93 }
94}
95
96sub _doit
97{
98 my ($file) = @_;
99
100 my ($program_ext, $module_ext) = _getRegexps();
101 my ($obj, $objfile, $so, $type);
102
103 if (
104 (($file =~ m"@$program_ext") && ($file !~ m"@$module_ext"))
105 || (defined($options->{'prog'}) || defined($options->{'run'}))
106 )
107 {
108 $objfile = ($options->{'C'}) ? $options->{'C'} : "$file.c";
109 $type = 'program';
110
111 $obj = ($options->{'o'})? $options->{'o'} :
112 _getExecutable( $file,$program_ext);
113
114 return() if (!$obj);
115
116 }
117 elsif (($file =~ m"@$module_ext") || ($options->{'mod'}))
118 {
119 die "Shared objects are not supported on Win32 yet!!!!\n"
120 if ($Config{'osname'} eq 'MSWin32');
121
122 $obj = ($options->{'o'})? $options->{'o'} :
123 _getExecutable($file, $module_ext);
124 $so = "$obj.so";
125 $type = 'sharedlib';
126 return() if (!$obj);
127 }
128 else
129 {
130 _error("noextension", $file, $program_ext, $module_ext);
131 return();
132 }
133
134 if ($type eq 'program')
135 {
136 _print("Making C($objfile) for $file!\n", 36 );
137
138 my $errcode = _createCode($objfile, $file);
139 (_print( "ERROR: In generating code for $file!\n", -1), return())
140 if ($errcode);
141
142 _print("Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'});
143 my $errcode = _compileCode($file, $objfile, $obj)
144 if (!$options->{'gen'});
145
146 if ($errcode)
147 {
148 _print( "ERROR: In compiling code for $objfile !\n", -1);
149 my $ofile = File::Basename::basename($objfile);
150 $ofile =~ s"\.c$"\.o"s;
151
152 _removeCode("$ofile");
153 return()
154 }
155
156 _runCode($obj) if ($options->{'run'});
157
158 _removeCode($objfile) if (!$options->{'sav'} ||
159 ($options->{'e'} && !$options->{'C'}));
160
161 _removeCode($file) if ($options->{'e'});
162
163 _removeCode($obj) if (($options->{'e'} &&
164 ((!$options->{'sav'}) || !$options->{'o'})) ||
165 ($options->{'run'} && (!$options->{'sav'})));
166 }
167 else
168 {
169 _print( "Making C($objfile) for $file!\n", 36 );
170 my $errcode = _createCode($objfile, $file, $obj);
171 (_print( "ERROR: In generating code for $file!\n", -1), return())
172 if ($errcode);
173
174 _print( "Compiling C($obj) for $file!\n", 36 ) if (!$options->{'gen'});
175
176 my $errorcode =
177 _compileCode($file, $objfile, $obj, $so ) if (!$options->{'gen'});
178
179 (_print( "ERROR: In compiling code for $objfile!\n", -1), return())
180 if ($errcode);
181 }
182}
183
184sub _getExecutable
185{
186 my ($sourceprog, $ext) = @_;
187 my ($obj);
188
189 if (defined($options->{'regex'}))
190 {
191 eval("(\$obj = \$sourceprog) =~ $options->{'regex'}");
192 return(0) if (_error('badeval', $@));
193 return(0) if (_error('equal', $obj, $sourceprog));
194 }
195 elsif (defined ($options->{'ext'}))
196 {
197 ($obj = $sourceprog) =~ s"@$ext"$options->{ext}"g;
198 return(0) if (_error('equal', $obj, $sourceprog));
199 }
200 elsif (defined ($options->{'run'}))
201 {
202 $obj = "perlc$$";
203 }
204 else
205 {
206 ($obj = $sourceprog) =~ s"@$ext""g;
207 return(0) if (_error('equal', $obj, $sourceprog));
208 }
209 return($obj);
210}
211
212sub _createCode
213{
214 my ( $generated_cfile, $file, $final_output ) = @_;
215 my $return;
216
217 local($") = " -I";
218
219 if (@_ == 2) # compiling a program
220 {
221 _print( "$^X -I@INC -MO=CC,-o$generated_cfile $file\n", 36);
222 $return = _run("$\18 -I@INC -MO=CC,-o$generated_cfile $file", 9);
223 $return;
224 }
225 else # compiling a shared object
226 {
227 _print(
228 "$\18 -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file\n", 36);
229 $return =
230 _run("$\18 -I@INC -MO=CC,-m$final_output,-o$generated_cfile $file", 9);
231 $return;
232 }
233}
234
235sub _compileCode
236{
237 my ($sourceprog, $generated_cfile, $output_executable, $shared_object) = @_;
238 my @return;
239
240 if (@_ == 3) # just compiling a program
241 {
242 $return[0] =
243 _ccharness($sourceprog, "-o", $output_executable, $generated_cfile);
244 $return[0];
245 }
246 else
247 {
248 my $object_file = $generated_cfile;
249 $object_file =~ s"\.c$"\.o";
250
251 $return[0] = _ccharness($sourceprog, "-c", $generated_cfile);
252 $return[1] = _ccharness
253 (
254 $sourceprog, "-shared","-o",
255 $shared_object, $object_file
256 );
257 return(1) if (grep ($_, @return));
258 return(0);
259 }
260}
261
262sub _runCode
263{
264 my ($executable) = @_;
265 _print("$executable $options->{'argv'}\n", 36);
266 _run("$executable $options->{'argv'}", -1 );
267}
268
269sub _removeCode
270{
271 my ($file) = @_;
272 unlink($file) if (-e $file);
273}
274
275sub _ccharness
276{
277 my (@args) = @_;
278 local($") = " ";
279
280 my $sourceprog = shift(@args);
281 my ($libdir, $incdir);
282
283 if (-d "$Config{installarchlib}/CORE")
284 {
285 $libdir = "-L$Config{installarchlib}/CORE";
286 $incdir = "-I$Config{installarchlib}/CORE";
287 }
288 else
289 {
290 $libdir = "-L..";
291 $incdir = "-I..";
292 }
293
294 $libdir .= " -L$options->{L}" if (defined($options->{L}));
295 $incdir .= " -I$options->{L}" if (defined($options->{L}));
296
297 my $linkargs;
298
299 if (!grep(/^-[cS]$/, @ARGV))
300 {
301 $linkargs = sprintf("%s $libdir -lperl %s",@Config{qw(ldflags libs)});
302 }
303
304 my @sharedobjects = _getSharedObjects($sourceprog);
305
306 my $cccmd =
307 "$Config{cc} $Config{ccflags} $incdir @sharedobjects @args $linkargs";
308
309
310 _print ("$cccmd\n", 36);
311 _run("$cccmd", 18 );
312}
313
314sub _getSharedObjects
315{
316 my ($sourceprog) = @_;
317 my ($tmpfile, $incfile);
318 my (@return);
319 local($") = " -I";
320
321 if ($Config{'osname'} eq 'MSWin32')
322 {
323 # _addstuff;
324 }
325 else
326 {
327 my ($tmpprog);
328 ($tmpprog = $sourceprog) =~ s"(.*)[\/\\](.*)"$2";
329 $tmpfile = "/tmp/$tmpprog.tst";
330 $incfile = "/tmp/$tmpprog.val";
331 }
332
333 my $fd = new FileHandle("> $tmpfile") || die "Couldn't open $tmpfile!\n";
334 my $fd2 =
335 new FileHandle("$sourceprog") || die "Couldn't open $sourceprog!\n";
336
337 my $perl = <$fd2>; # strip off header;
338
339 print $fd
340<<"EOF";
341 use FileHandle;
342 my \$fh3 = new FileHandle("> $incfile")
343 || die "Couldn't open $incfile\\n";
344
345 my \$key;
346 foreach \$key (keys(\%INC)) { print \$fh3 "\$key:\$INC{\$key}\\n"; }
347 close(\$fh3);
348 exit();
349EOF
350
351 print $fd ( <$fd2> );
352 close($fd);
353
354 _print("$\18 -I@INC $tmpfile\n", 36);
355 _run("$\18 -I@INC $tmpfile", 9 );
356
357 my $fd = new FileHandle ("$incfile");
358 my @lines = <$fd>;
359
360 unlink($tmpfile);
361 unlink($incfile);
362
363 my $line;
364 my $autolib;
365
366 foreach $line (@lines)
367 {
368 chomp($line);
369 my ($modname, $modpath) = split(':', $line);
370 my ($dir, $file) = ($modpath=~ m"(.*)[\\/]($modname)");
371
372 if ($autolib = _lookforAuto($dir, $file))
373 {
374 push(@return, $autolib);
375 }
376 }
377
378 return(@return);
379}
380
381sub _maketempfile
382{
383 my $return;
384
385# if ($Config{'osname'} eq 'MSWin32')
386# { $return = "C:\\TEMP\\comp$$.p"; }
387# else
388# { $return = "/tmp/comp$$.p"; }
389
390 $return = "comp$$.p";
391
392 my $fd = new FileHandle( "> $return") || die "Couldn't open $return!\n";
393 print $fd $options->{'e'};
394 close($fd);
395
396 return($return);
397}
398
399
400sub _lookforAuto
401{
402 my ($dir, $file) = @_;
403
404 my $relshared;
405 my $return;
406
407 ($relshared = $file) =~ s"(.*)\.pm"$1";
408
409 my ($tmp, $modname) = ($relshared =~ m"(?:(.*)[\\/]){0,1}(.*)"s);
410
411 $relshared .=
412 ($Config{'osname'} eq 'MSWin32')? "\\$modname.dll" : "/$modname.so";
413
414
415
416 if (-e ($return = "$Config{'installarchlib'}/auto/$relshared") )
417 {
418 return($return);
419 }
420 elsif (-e ($return = "$Config{'installsitearch'}/auto/$relshared"))
421 {
422 return($return);
423 }
424 elsif (-e ($return = "$dir/arch/auto/$relshared"))
425 {
426 return($return);
427 }
428 else
429 {
430 return(undef);
431 }
432}
433
434sub _getRegexps # make the appropriate regexps for making executables,
435{ # shared libs
436
437 my ($program_ext, $module_ext) = ([],[]);
438
439
440 @$program_ext = ($ENV{PERL_SCRIPT_EXT})? split(':', $ENV{PERL_SCRIPT_EXT}) :
441 ('.p$', '.pl$', '.bat$');
442
443
444 @$module_ext = ($ENV{PERL_MODULE_EXT})? split(':', $ENV{PERL_MODULE_EXT}) :
445 ('.pm$');
446
447
448 _mungeRegexp( $program_ext );
449 _mungeRegexp( $module_ext );
450
451 return($program_ext, $module_ext);
452}
453
454sub _mungeRegexp
455{
456 my ($regexp) = @_;
457
458 grep(s"(^|[^\\])\."$1\x0\\."g, @$regexp);
459 grep(s"(^|[^\x0])\\\."$1\."g, @$regexp);
460 grep(s"\x0""g, @$regexp);
461}
462
463
464sub _error
465{
466 my ($type, @args) = @_;
467
468 if ($type eq 'equal')
469 {
470
471 if ($args[0] eq $args[1])
472 {
473 _print ("ERROR: The object file '$args[0]' does not generate a legitimate executable file! Skipping!\n", -1);
474 return(1);
475 }
476 }
477 elsif ($type eq 'badeval')
478 {
479 if ($args[0])
480 {
481 _print ("ERROR: $args[0]\n", -1);
482 return(1);
483 }
484 }
485 elsif ($type eq 'noextension')
486 {
487 my $progext = join(',', @{$args[1]});
488 my $modext = join(',', @{$args[2]});
489
490 $progext =~ s"\\""g;
491 $modext =~ s"\\""g;
492
493 $progext =~ s"\$""g;
494 $modext =~ s"\$""g;
495
496 _print
497 (
498"
499ERROR: '$args[0]' does not have a proper extension! Proper extensions are:
500
501 PROGRAM: $progext
502 SHARED OBJECT: $modext
503
504Use the '-prog' flag to force your files to be interpreted as programs.
505Use the '-mod' flag to force your files to be interpreted as modules.
506", -1
507 );
508 return(1);
509 }
510
511 return(0);
512}
513
514sub _checkopts
515{
516 my @errors;
517 local($") = "\n";
518
519 if ($options->{'log'})
520 {
521 $_fh = new FileHandle(">> $options->{'log'}") || push(@errors, "ERROR: Couldn't open $options->{'log'}\n");
522 }
523
524 if (($options->{'c'}) && (@ARGV > 1) && ($options->{'sav'} ))
525 {
526 push(@errors,
527"ERROR: The '-sav' and '-C' options are incompatible when you have more than
528 one input file! ('-C' explicitly names resulting C code, '-sav' saves it,
529 and hence, with more than one file, the c code will be overwritten for
530 each file that you compile)\n");
531 }
532 if (($options->{'o'}) && (@ARGV > 1))
533 {
534 push(@errors,
535"ERROR: The '-o' option is incompatible when you have more than one input file!
536 (-o explicitly names the resulting executable, hence, with more than
537 one file the names clash)\n");
538 }
539
540 if ($options->{'e'} && $options->{'sav'} && !$options->{'o'} &&
541 !$options->{'C'})
542 {
543 push(@errors,
544"ERROR: You need to specify where you are going to save the resulting
545 executable or C code, when using '-sav' and '-e'. Use '-o' or '-C'.\n");
546 }
547
548 if (($options->{'regex'} || $options->{'run'} || $options->{'o'})
549 && $options->{'gen'})
550 {
551 push(@errors,
552"ERROR: The options '-regex', '-run', and '-o' are incompatible with '-gen'.
553 '-gen' says to stop at C generation, and the other three modify the
554 compilation and/or running process!\n");
555 }
556
557 if ($options->{'run'} && $options->{'mod'})
558 {
559 push(@errors,
560"ERROR: Can't run modules that you are compiling! '-run' and '-mod' are
561 incompatible!\n");
562 }
563
564 if ($options->{'e'} && @ARGV)
565 {
566 push (@errors,
567"ERROR: The option '-e' needs to be all by itself without any other
568 file arguments!\n");
569 }
570 if ($options->{'e'} && !($options->{'o'} || $options->{'run'}))
571 {
572 $options->{'run'} = 1;
573 }
574
575 if (!defined($options->{'verbose'}))
576 {
577 $options->{'verbose'} = ($options->{'log'})? 64 : 7;
578 }
579
580 my $verbose_error;
581
582 if ($options->{'verbose'} =~ m"[^tagfcd]" &&
583 !( $options->{'verbose'} eq '0' ||
584 ($options->{'verbose'} < 64 && $options->{'verbose'} > 0)))
585 {
586 $verbose_error = 1;
587 push(@errors,
588"ERROR: Illegal verbosity level. Needs to have either the letters
589 't','a','g','f','c', or 'd' in it or be between 0 and 63, inclusive.\n");
590 }
591
592 $options->{'verbose'} = ($options->{'verbose'} =~ m"[tagfcd]")?
593 ($options->{'verbose'} =~ m"d") * 32 +
594 ($options->{'verbose'} =~ m"c") * 16 +
595 ($options->{'verbose'} =~ m"f") * 8 +
596 ($options->{'verbose'} =~ m"t") * 4 +
597 ($options->{'verbose'} =~ m"a") * 2 +
598 ($options->{'verbose'} =~ m"g") * 1
599 : $options->{'verbose'};
600
601 if (!$verbose_error && ( $options->{'log'} &&
602 !(
603 ($options->{'verbose'} & 8) ||
604 ($options->{'verbose'} & 16) ||
605 ($options->{'verbose'} & 32 )
606 )
607 )
608 )
609 {
610 push(@errors,
611"ERROR: The verbosity level '$options->{'verbose'}' does not output anything
612 to a logfile, and you specified '-log'!\n");
613 } # }
614
615 if (!$verbose_error && ( !$options->{'log'} &&
616 (
617 ($options->{'verbose'} & 8) ||
618 ($options->{'verbose'} & 16) ||
619 ($options->{'verbose'} & 32) ||
620 ($options->{'verbose'} & 64)
621 )
622 )
623 )
624 {
625 push(@errors,
626"ERROR: The verbosity level '$options->{'verbose'}' requires that you also
627 specify a logfile via '-log'\n");
628 } # }
629
630
631 (_print( "\n". join("\n", @errors), -1), return(0)) if (@errors);
632 return(1);
633}
634
635sub _print
636{
637 my ($text, $flag ) = @_;
638
639 my $logflag = int($flag/8) * 8;
640 my $regflag = $flag % 8;
641
642 if ($flag == -1 || ($flag & $options->{'verbose'}))
643 {
644 my $dolog = ((($logflag & $options->{'verbose'}) || $flag == -1)
645 && $options->{'log'});
646
647 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
648
649 if ($doreg) { print( STDERR $text ); }
650 if ($dolog) { print $_fh $text; }
651 }
652}
653
654sub _run
655{
656 my ($command, $flag) = @_;
657
658 my $logflag = ($flag != -1)? int($flag/8) * 8 : 0;
659 my $regflag = $flag % 8;
660
661 if ($flag == -1 || ($flag & $options->{'verbose'}))
662 {
663 my $dolog = ($logflag & $options->{'verbose'} && $options->{'log'});
664 my $doreg = (($regflag & $options->{'verbose'}) || $flag == -1);
665
666 if ($doreg && !$dolog)
667 { system("$command"); }
668
669 elsif ($doreg && $dolog)
670 { my $text = `$command 2>&1`; print $_fh $text; print STDERR $text;}
671 else
672 { my $text = `$command 2>&1`; print $_fh $text; }
673 }
674 else
675 {
676 `$command 2>&1`;
677 }
678 return($?);
679}
680
681sub _usage
682{
683 _print
684 (
685 <<"EOF"
686
687Usage: $0 <file_list>
688
689 Flags with arguments
690 -L < extra library dirs for installation (form of 'dir1:dir2') >
691 -I < extra include dirs for installation (form of 'dir1:dir2') >
692 -C < explicit name of resulting C code >
693 -o < explicit name of resulting executable >
694 -e < to compile 'one liners'. Need executable name (-o) or '-run'>
695 -regex < rename regex, -regex 's/\.p/\.exe/' compiles a.p to a.exe >
696 -verbose < verbose level (1-63, or following letters 'gatfcd' >
697 -argv < arguments for the executables to be run via '-run' or '-e' >
698
699 Boolean flags
700 -gen ( to just generate the c code. Implies '-sav' )
701 -sav ( to save intermediate c code, (and executables with '-run'))
702 -run ( to run the compiled program on the fly, as were interpreted.)
703 -prog ( to indicate that the files on command line are programs )
704 -mod ( to indicate that the files on command line are modules )
705
706EOF
707, -1
708
709 );
710 exit(255);
711}
712
713
714__END__
715
716=head1 NAME
717
718perlcc - frontend for perl compiler
719
720=head1 SYNOPSIS
721
722 %prompt perlcc a.p # compiles into executable 'a'
723
724 %prompt perlcc A.pm # compile into 'A.so'
725
726 %prompt perlcc a.p -o execute # compiles 'a.p' into 'execute'.
727
728 %prompt perlcc a.p -o execute -run # compiles 'a.p' into execute, runs on
729 # the fly
730
731 %prompt perlcc a.p -o execute -run -argv 'arg1 arg2 arg3'
732 # compiles into execute, runs with
733 # arg1 arg2 arg3 as @ARGV
734
735 %prompt perlcc a.p b.p c.p -regex 's/\.p/\.exe'
736 # compiles into 'a.exe','b.exe','c.exe'.
737
738 %prompt perlcc a.p -log compilelog # compiles into 'a', saves compilation
739 # info into compilelog, as well
740 # as mirroring to screen
741
742 %prompt perlcc a.p -log compilelog -verbose cdf
743 # compiles into 'a', saves compilation
744 # info into compilelog, being silent
745 # on screen.
746
747 %prompt perlcc a.p -C a.c -gen # generates C code (into a.c) and
748 # stops without compile.
749
750 %prompt perlcc a.p -L ../lib a.c
751 # Compiles with the perl libraries
752 # inside ../lib included.
753
754=head1 DESCRIPTION
755
756'perlcc' is the frontend into the perl compiler. Typing 'perlcc a.p'
757compiles the code inside a.p into a standalone executable, and
758perlcc A.pm will compile into a shared object, A.so, suitable for inclusion
759into a perl program via "use A".
760
761There are quite a few flags to perlcc which help with such issues as compiling
762programs in bulk, testing compiled programs for compatibility with the
763interpreter, and controlling.
764
765=head1 OPTIONS
766
767=over 4
768
769=item -L < library_directories >
770
771Adds directories in B<library_directories> to the compilation command.
772
773=item -I < include_directories >
774
775Adds directories inside B<include_directories> to the compilation command.
776
777=item -C < c_code_name >
778
779Explicitly gives the name B<c_code_name> to the generated c code which is to
780be compiled. Can only be used if compiling one file on the command line.
781
782=item -o < executable_name >
783
784Explicitly gives the name B<executable_name> to the executable which is to be
785compiled. Can only be used if compiling one file on the command line.
786
787=item -e < perl_line_to_execute>
788
789Compiles 'one liners', in the same way that B<perl -e> runs text strings at
790the command line. Default is to have the 'one liner' be compiled, and run all
791in one go (see B<-run>); giving the B<-o> flag saves the resultant executable,
792rather than throwing it away. Use '-argv' to pass arguments to the executable
793created.
794
795=item -regex <rename_regex>
796
797Gives a rule B<rename_regex> - which is a legal perl regular expression - to
798create executable file names.
799
800=item -verbose <verbose_level>
801
802Show exactly what steps perlcc is taking to compile your code. You can change
803the verbosity level B<verbose_level> much in the same way that the '-D' switch
804changes perl's debugging level, by giving either a number which is the sum of
805bits you want or a list of letters representing what you wish to see. Here are
806the verbosity levels so far :
807
808 Bit 1(g): Code Generation Errors to STDERR
809 Bit 2(a): Compilation Errors to STDERR
810 Bit 4(t): Descriptive text to STDERR
811 Bit 8(f): Code Generation Errors to file (B<-log> flag needed)
812 Bit 16(c): Compilation Errors to file (B<-log> flag needed)
813 Bit 32(d): Descriptive text to file (B<-log> flag needed)
814
815If the B<-log> tag is given, the default verbose level is 63 (ie: mirroring
816all of perlcc's output to both the screen and to a log file). If no B<-log>
817tag is given, then the default verbose level is 7 (ie: outputting all of
818perlcc's output to STDERR).
819
820NOTE: Because of buffering concerns, you CANNOT shadow the output of '-run' to
821both a file, and to the screen! Suggestions are welcome on how to overcome this
822difficulty, but for now it simply does not work properly, and hence will only go
823to the screen.
824
825=item -log <logname>
826
827Opens, for append, a logfile to save some or all of the text for a given
828compile command. No rewrite version is available, so this needs to be done
829manually.
830
831=item -argv <arguments>
832
833In combination with '-run' or '-e', tells perlcc to run the resulting
834executable with the string B<arguments> as @ARGV.
835
836=item -sav
837
838Tells perl to save the intermediate C code. Usually, this C code is the name
839of the perl code, plus '.c'; 'perlcode.p' gets generated in 'perlcode.p.c',
840for example. If used with the '-e' operator, you need to tell perlcc where to
841save resulting executables.
842
843=item -gen
844
845Tells perlcc to only create the intermediate C code, and not compile the
846results. Does an implicit B<-sav>, saving the C code rather than deleting it.
847
848=item -run
849
850Immediately run the perl code that has been generated. NOTE: IF YOU GIVE THE
851B<-run> FLAG TO B<perlcc>, THEN THE REST OF @ARGV WILL BE INTERPRETED AS
852ARGUMENTS TO THE PROGRAM THAT YOU ARE COMPILING.
853
854=item -prog
855
856Indicate that the programs at the command line are programs, and should be
857compiled as such. B<perlcc> will automatically determine files to be
858programs if they have B<.p>, B<.pl>, B<.bat> extensions.
859
860=item -mod
861
862Indicate that the programs at the command line are modules, and should be
863compiled as such. B<perlcc> will automatically determine files to be
864modules if they have the extension B<.pm>.
865
866=back
867
868=head1 ENVIRONMENT
869
870Most of the work of B<perlcc> is done at the command line. However, you can
871change the heuristic which determines what is a module and what is a program.
872As indicated above, B<perlcc> assumes that the extensions:
873
874.p$, .pl$, and .bat$
875
876indicate a perl program, and:
877
878.pm$
879
880indicate a library, for the purposes of creating executables. And furthermore,
881by default, these extensions will be replaced (and dropped ) in the process of
882creating an executable.
883
884To change the extensions which are programs, and which are modules, set the
885environmental variables:
886
887PERL_SCRIPT_EXT
888PERL_MODULE_EXT
889
890These two environmental variables take colon-separated, legal perl regular
891expressions, and are used by perlcc to decide which objects are which.
892For example:
893
894setenv PERL_SCRIPT_EXT '.prl$:.perl$'
895prompt% perlcc sample.perl
896
897will compile the script 'sample.perl' into the executable 'sample', and
898
899setenv PERL_MODULE_EXT '.perlmod$:.perlmodule$'
900
901prompt% perlcc sample.perlmod
902
903will compile the module 'sample.perlmod' into the shared object
904'sample.so'
905
906NOTE: the '.' in the regular expressions for PERL_SCRIPT_EXT and PERL_MODULE_EXT
907is a literal '.', and not a wild-card. To get a true wild-card, you need to
908backslash the '.'; as in:
909
910setenv PERL_SCRIPT_EXT '\.\.\.\.\.'
911
912which would have the effect of compiling ANYTHING (except what is in
913PERL_MODULE_EXT) into an executable with 5 less characters in its name.
914
915=head1 FILES
916
917'perlcc' uses a temporary file when you use the B<-e> option to evaluate
918text and compile it. This temporary file is 'perlc$$.p'. The temporary C code is
919perlc$$.p.c, and the temporary executable is perlc$$.
920
921When you use '-run' and don't save your executable, the temporary executable is
922perlc$$
923
924=head1 BUGS
925
926perlcc currently cannot compile shared objects on Win32. This should be fixed
927by perl5.005.
928
929=cut
930
931!NO!SUBS!
932
933close OUT or die "Can't close $file: $!";
934chmod 0755, $file or die "Can't reset permissions for $file: $!\n";
935exec("$Config{'eunicefix'} $file") if $Config{'eunicefix'} ne ':';