This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
regnodes.h: Add two convenience bit masks
authorKarl Williamson <khw@cpan.org>
Fri, 3 Apr 2020 16:22:19 +0000 (10:22 -0600)
committerKarl Williamson <khw@cpan.org>
Fri, 16 Oct 2020 13:01:41 +0000 (07:01 -0600)
These categorize the many types of EXACT nodes, so that code can refer
to a particular subset of such nodes without having to list all of them
out.  This simplifies some 'if' statements, and makes updating things
easier.

globvar.sym
pod/perldebguts.pod
regcomp.sym
regen/regcomp.pl
regnodes.h

index f020879..03c3248 100644 (file)
@@ -12,6 +12,8 @@ PL_c9_utf8_dfa_tab
 PL_charclass
 PL_check
 PL_core_reg_engine
+PL_EXACTFish_bitmask
+PL_EXACT_REQ8_bitmask
 PL_extended_utf8_dfa_tab
 PL_fold
 PL_fold_latin1
index 2a3152a..2803cdd 100644 (file)
@@ -700,7 +700,6 @@ will be lost.
  EXACTFLU8        str        Like EXACTFU, but use /il, UTF-8, (string
                              is folded, and everything in it is above
                              255
-
  EXACT_REQ8       str        Like EXACT, but only UTF-8 encoded targets
                              can match
  LEXACT_REQ8      len:str 1  Like LEXACT, but only UTF-8 encoded targets
index 1105173..510a616 100644 (file)
@@ -129,6 +129,9 @@ BRANCH      BRANCH,     node 0 V  ; Match this alternative, or the next...
 
 #*Literals
 # NOTE: the relative ordering of these types is important do not change it
+# By convention, folding nodes begin with EXACTF; A digit 8 is in the name if
+# and only if it it requires a UTF-8 target string in order to successfully
+# match.
 
 EXACT       EXACT,      str       ; Match this string (flags field is the length).
 
@@ -158,8 +161,6 @@ EXACTFUP    EXACT,      str   ; Like EXACT, but match using /iu rules; (string n
 # representable in the UTF-8 target string.
 
 EXACTFLU8   EXACT,      str      ; Like EXACTFU, but use /il, UTF-8, (string is folded, and everything in it is above 255
-
-
 EXACT_REQ8   EXACT,      str      ; Like EXACT, but only UTF-8 encoded targets can match
 LEXACT_REQ8  EXACT,  len:str 1    ; Like LEXACT, but only UTF-8 encoded targets can match
 EXACTFU_REQ8 EXACT,    str        ; Like EXACTFU, but only UTF-8 encoded targets can match
index a72b697..fc4de6a 100644 (file)
@@ -244,6 +244,49 @@ EXTCONST U8 PL_${varname}_bitmask[] = {
 EOP
 }
 
+sub print_process_EXACTish {
+    my ($out)= @_;
+
+    # Creates some bitmaps for EXACTish nodes.
+
+    my @folded;
+    my @req8;
+
+    my $base;
+    for my $node (@ops) {
+        next unless $node->{type} eq 'EXACT';
+        my $name = $node->{name};
+        $base = $node->{id} if $name eq 'EXACT';
+
+        my $index = $node->{id} - $base;
+
+        # This depends entirely on naming conventions in regcomp.sym
+        $folded[$index] = $name =~ /^EXACTF/ || 0;
+        $req8[$index] = $name =~ /8/ || 0;
+    }
+
+    die "Can't cope with > 32 EXACTish nodes" if @folded > 32;
+
+    my $exactf = sprintf "%X", oct("0b" . join "", reverse @folded);
+    my $req8 =   sprintf "%X", oct("0b" . join "", reverse @req8);
+    print $out <<EOP,
+
+/* Is 'op', known to be of type EXACT, folding? */
+#define isEXACTFish(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACTFish_bitmask & (1U << (op - EXACT))))
+
+/* Do only UTF-8 target strings match 'op', known to be of type EXACT? */
+#define isEXACT_REQ8(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACT_REQ8_bitmask & (1U << (op - EXACT))))
+
+#ifndef DOINIT
+EXTCONST U32 PL_EXACTFish_bitmask;
+EXTCONST U32 PL_EXACT_REQ8_bitmask;
+#else
+EXTCONST U32 PL_EXACTFish_bitmask = 0x$exactf;
+EXTCONST U32 PL_EXACT_REQ8_bitmask = 0x$req8;
+#endif /* DOINIT */
+EOP
+}
+
 sub read_definition {
     my ( $file )= @_;
     my ( $seen_sep, $pod_comment )= "";
@@ -752,6 +795,7 @@ print_reg_name($out);
 print_reg_extflags_name($out);
 print_reg_intflags_name($out);
 print_process_flags($out);
+print_process_EXACTish($out);
 read_only_bottom_close_and_rename($out);
 
 do_perldebguts();
index 3e5723d..2719b82 100644 (file)
@@ -1753,4 +1753,18 @@ EXTCONST U8 PL_simple_bitmask[] = {
 };
 #endif /* DOINIT */
 
+/* Is 'op', known to be of type EXACT, folding? */
+#define isEXACTFish(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACTFish_bitmask & (1U << (op - EXACT))))
+
+/* Do only UTF-8 target strings match 'op', known to be of type EXACT? */
+#define isEXACT_REQ8(op) (__ASSERT_(PL_regkind[op] == EXACT) (PL_EXACT_REQ8_bitmask & (1U << (op - EXACT))))
+
+#ifndef DOINIT
+EXTCONST U32 PL_EXACTFish_bitmask;
+EXTCONST U32 PL_EXACT_REQ8_bitmask;
+#else
+EXTCONST U32 PL_EXACTFish_bitmask = 0x33F8;
+EXTCONST U32 PL_EXACT_REQ8_bitmask = 0x1E00;
+#endif /* DOINIT */
+
 /* ex: set ro: */