This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
More POD corrections
[perl5.git] / ext / B / B.pm
index caccf4b..91dc5f5 100644 (file)
@@ -6,40 +6,51 @@
 #      License or the Artistic License, as specified in the README file.
 #
 package B;
+use strict;
 
-our $VERSION = '1.15';
-
-use XSLoader ();
 require Exporter;
-@ISA = qw(Exporter);
+@B::ISA = qw(Exporter);
 
 # walkoptree_slow comes from B.pm (you are there),
 # walkoptree comes from B.xs
-@EXPORT_OK = qw(minus_c ppname save_BEGINs
-               class peekop cast_I32 cstring cchar hash threadsv_names
-               main_root main_start main_cv svref_2object opnumber
-               sub_generation amagic_generation perlstring
-               walkoptree_slow walkoptree walkoptree_exec walksymtable
-               parents comppadlist sv_undef compile_stats timing_info
-               begin_av init_av check_av end_av regex_padav dowarn defstash
-               curstash warnhook diehook inc_gv
-               );
-push @EXPORT_OK, qw(unitcheck_av) if $] > 5.009;
-
-sub OPf_KIDS ();
-use strict;
+
+BEGIN {
+    $B::VERSION = '1.28';
+
+    @B::EXPORT_OK = qw(minus_c ppname save_BEGINs
+                      class peekop cast_I32 cstring cchar hash threadsv_names
+                      main_root main_start main_cv svref_2object opnumber
+                      sub_generation amagic_generation perlstring
+                      walkoptree_slow walkoptree walkoptree_exec walksymtable
+                      parents comppadlist sv_undef compile_stats timing_info
+                      begin_av init_av check_av end_av regex_padav dowarn
+                      defstash curstash warnhook diehook inc_gv @optype
+                      @specialsv_name
+                  );
+    push @B::EXPORT_OK, qw(unitcheck_av) if $] > 5.009;
+
+    # All the above in this BEGIN, because our BOOT code needs $VERSION set,
+    # and will append to @EXPORT_OK. And we need to run the BOOT code before
+    # we see OPf_KIDS below.
+    require XSLoader;
+    XSLoader::load();
+}
+
 @B::SV::ISA = 'B::OBJECT';
 @B::NULL::ISA = 'B::SV';
 @B::PV::ISA = 'B::SV';
 @B::IV::ISA = 'B::SV';
 @B::NV::ISA = 'B::SV';
-@B::RV::ISA = 'B::SV';
+# RV is eliminated with 5.11.0, but effectively is a specialisation of IV now.
+@B::RV::ISA = $] >= 5.011 ? 'B::IV' : 'B::SV';
 @B::PVIV::ISA = qw(B::PV B::IV);
 @B::PVNV::ISA = qw(B::PVIV B::NV);
 @B::PVMG::ISA = 'B::PVNV';
+@B::REGEXP::ISA = 'B::PVMG' if $] >= 5.011;
 # Change in the inheritance hierarchy post 5.9.0
 @B::PVLV::ISA = $] > 5.009 ? 'B::GV' : 'B::PVMG';
-@B::BM::ISA = 'B::PVMG';
+# BM is eliminated post 5.9.5, but effectively is a specialisation of GV now.
+@B::BM::ISA = $] > 5.009005 ? 'B::GV' : 'B::PVMG';
 @B::AV::ISA = 'B::PVMG';
 @B::GV::ISA = 'B::PVMG';
 @B::HV::ISA = 'B::PVMG';
@@ -61,6 +72,13 @@ use strict;
 
 @B::SPECIAL::ISA = 'B::OBJECT';
 
+@B::optype = qw(OP UNOP BINOP LOGOP LISTOP PMOP SVOP PADOP PVOP LOOP COP);
+# bytecode.pl contained the following comment:
+# Nullsv *must* come first in the following so that the condition
+# ($$sv == 0) can continue to be used to test (sv == Nullsv).
+@B::specialsv_name = qw(Nullsv &PL_sv_undef &PL_sv_yes &PL_sv_no
+                       (SV*)pWARN_ALL (SV*)pWARN_NONE (SV*)pWARN_STD);
+
 {
     # Stop "-w" from complaining about the lack of a real B::OBJECT class
     package B::OBJECT;
@@ -87,8 +105,15 @@ sub B::IV::int_value {
 }
 
 sub B::NULL::as_string() {""}
-sub B::IV::as_string()   {goto &B::IV::int_value}
-sub B::PV::as_string()   {goto &B::PV::PV}
+*B::IV::as_string = \&B::IV::int_value;
+*B::PV::as_string = \&B::PV::PV;
+
+#  The input typemap checking makes no distinction between different SV types,
+#  so the XS body will generate the same C code, despite the different XS
+#  "types". So there is no change in behaviour from doing "newXS" like this,
+#  compared with the old approach of having a (near) duplicate XS body.
+#  We should fix the typemap checking.
+*B::IV::RV = \&B::PV::RV if $] > 5.012;
 
 my $debug;
 my $op_count = 0;
@@ -230,7 +255,7 @@ sub walksymtable {
         $fullname = "*main::".$prefix.$sym;
        if ($sym =~ /::$/) {
            $sym = $prefix . $sym;
-           if ($sym ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
+           if (svref_2object(\*$sym)->NAME ne "main::" && $sym ne "<none>::" && &$recurse($sym)) {
                walksymtable(\%$fullname, $method, $recurse, $sym);
            }
        } else {
@@ -305,15 +330,13 @@ sub walksymtable {
     }
 }
 
-XSLoader::load 'B';
-
 1;
 
 __END__
 
 =head1 NAME
 
-B - The Perl Compiler
+B - The Perl Compiler Backend
 
 =head1 SYNOPSIS
 
@@ -520,7 +543,26 @@ per-thread threadsv variables.
 
 =back
 
+=head2 Exported utility variables
+
+=over 4
+
+=item @optype
+
+  my $op_type = $optype[$op_type_num];
+
+A simple mapping of the op type number to its type (like 'COP' or 'BINOP').
+
+=item @specialsv_name
+
+  my $sv_name = $specialsv_name[$sv_index];
+
+Certain SV types are considered 'special'.  They're represented by
+B::SPECIAL and are referred to by a number from the specialsv_list.
+This array maps that number back to the name of the SV (like 'Nullsv'
+or '&PL_sv_undef').
 
+=back
 
 
 =head1 OVERVIEW OF CLASSES
@@ -544,20 +586,20 @@ give incomprehensible results, or worse.
 
 =head2 SV-RELATED CLASSES
 
-B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM, B::PVLV,
-B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes correspond in
-the obvious way to the underlying C structures of similar names. The
-inheritance hierarchy mimics the underlying C "inheritance". For 5.9.1
-and later this is:
-
-                             B::SV
-                               |
-                +--------------+----------+------------+
-                |              |          |            |
-              B::PV          B::IV      B::NV        B::RV
-                   \         /          /
-                    \       /          /
-                     B::PVIV          /
+B::IV, B::NV, B::RV, B::PV, B::PVIV, B::PVNV, B::PVMG, B::BM (5.9.5 and
+earlier), B::PVLV, B::AV, B::HV, B::CV, B::GV, B::FM, B::IO. These classes
+correspond in the obvious way to the underlying C structures of similar names.
+The inheritance hierarchy mimics the underlying C "inheritance". For the
+5.10.x branch, (I<ie> 5.10.0, 5.10.1 I<etc>) this is:
+
+                           B::SV
+                             |
+                +------------+------------+------------+
+                |            |            |            |
+              B::PV        B::IV        B::NV        B::RV
+                  \         /           /
+                   \       /           /
+                    B::PVIV           /
                          \           /
                           \         /
                            \       /
@@ -566,26 +608,53 @@ and later this is:
                                |
                             B::PVMG
                                |
-                    +-----+----+------+-----+-----+
-                    |     |    |      |     |     |
-                  B::BM B::AV B::GV B::HV B::CV B::IO
-                               |            |
-                            B::PVLV         |
-                                          B::FM
+                   +-----+-----+-----+-----+
+                   |     |     |     |     |
+                 B::AV B::GV B::HV B::CV B::IO
+                         |           |
+                         |           |
+                      B::PVLV      B::FM
 
+For 5.9.0 and earlier, PVLV is a direct subclass of PVMG, and BM is still
+present as a distinct type, so the base of this diagram is
 
-For 5.9.0 and earlier, PVLV is a direct subclass of PVMG, so the base
-of this diagram is
 
-                           |
-                        B::PVMG
-                           |
-         +------+-----+----+------+-----+-----+
-         |      |     |    |      |     |     |
-      B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO
-                                        |
-                                        |
-                                      B::FM
+                               |
+                               |
+                            B::PVMG
+                               |
+            +------+-----+-----+-----+-----+-----+
+            |      |     |     |     |     |     |
+         B::PVLV B::BM B::AV B::GV B::HV B::CV B::IO
+                                           |
+                                           |
+                                         B::FM
+
+For 5.11.0 and later, B::RV is abolished, and IVs can be used to store
+references, and a new type B::REGEXP is introduced, giving this structure:
+
+                           B::SV
+                             |
+                +------------+------------+
+                |            |            |
+              B::PV        B::IV        B::NV
+                  \         /           /
+                   \       /           /
+                    B::PVIV           /
+                         \           /
+                          \         /
+                           \       /
+                            B::PVNV
+                               |
+                               |
+                            B::PVMG
+                               |
+           +-------+-------+---+---+-------+-------+
+           |       |       |       |       |       |
+         B::AV   B::GV   B::HV   B::CV   B::IO B::REGEXP
+                   |               |
+                   |               |
+                B::PVLV          B::FM
 
 
 Access methods correspond to the underlying C macros for field access,
@@ -991,8 +1060,6 @@ This returns the op description from the global C PL_op_desc array
 
 =item opt
 
-=item static
-
 =item flags
 
 =item private
@@ -1043,13 +1110,13 @@ This returns the op description from the global C PL_op_desc array
 
 =item pmnext
 
-=item pmregexp
+Only up to Perl 5.9.4
 
 =item pmflags
 
-=item pmdynflags
+=item extflags
 
-=item pmpermflags
+Since Perl 5.9.5
 
 =item precomp
 
@@ -1121,6 +1188,8 @@ Only when perl was compiled with ithreads.
 
 =item hints
 
+=item hints_hash
+
 =back