X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=warnings.pl;h=835fd7c5e4edd46505ee71597d88bc78f9c3a1e4;hb=9c3f2640bc47839fced0ccc78bae4b814ae82e97;hp=9149f691949cd5fe6bb0743b5b9509c65eafc98e;hpb=c3186b657097c822f3b2e667eea90ac8342b05f0;p=p5sagit%2Fp5-mst-13.2.git

diff --git a/warnings.pl b/warnings.pl
index 9149f69..835fd7c 100644
--- a/warnings.pl
+++ b/warnings.pl
@@ -1,10 +1,23 @@
 #!/usr/bin/perl
+# 
+# Regenerate (overwriting only if changed):
+#
+#    lib/warnings.pm
+#    warnings.h
+#
+# from information hardcoded into this script (the $tree hash), plus the
+# template for warnings.pm in the DATA section.
+#
+# With an argument of 'tree', just dump the contents of $tree and exits.
+# Also accepts the standard regen_lib -q and -v args.
+#
+# This script is normally invoked from regen.pl.
 
-
-$VERSION = '1.00';
+$VERSION = '1.02_03';
 
 BEGIN {
-  push @INC, './lib';
+    require 'regen_lib.pl';
+    push @INC, './lib';
 }
 use strict ;
 
@@ -13,56 +26,61 @@ sub DEFAULT_OFF () { 2 }
 
 my $tree = {
 
-'all' => {
-       	'io'  		=> { 	'pipe' 		=> DEFAULT_OFF,
-       				'unopened'	=> DEFAULT_OFF,
-       				'closed'	=> DEFAULT_OFF,
-       				'newline'	=> DEFAULT_OFF,
-       				'exec'		=> DEFAULT_OFF,
-			   },
-       	'syntax'	=> { 	'ambiguous'	=> DEFAULT_OFF,
-			     	'semicolon'	=> DEFAULT_OFF,
-			     	'precedence'	=> DEFAULT_OFF,
-			     	'bareword'	=> DEFAULT_OFF,
-			     	'reserved'	=> DEFAULT_OFF,
-				'digit'		=> DEFAULT_OFF,
-			     	'parenthesis'	=> DEFAULT_OFF,
-       	 			'printf'	=> DEFAULT_OFF,
-       	 			'prototype'	=> DEFAULT_OFF,
-       	 			'qw'		=> DEFAULT_OFF,
-			   },
-       	'severe'	=> { 	'inplace'	=> DEFAULT_ON,
-	 			'internal'	=> DEFAULT_ON,
-         			'debugging'	=> DEFAULT_ON,
-         			'malloc'	=> DEFAULT_ON,
-	 		   },
-        'deprecated'	=> DEFAULT_OFF,
-       	'void'		=> DEFAULT_OFF,
-       	'recursion'	=> DEFAULT_OFF,
-       	'redefine'	=> DEFAULT_OFF,
-       	'numeric'	=> DEFAULT_OFF,
-        'uninitialized'	=> DEFAULT_OFF,
-       	'once'		=> DEFAULT_OFF,
-       	'misc'		=> DEFAULT_OFF,
-       	'regexp'	=> DEFAULT_OFF,
-       	'glob'		=> DEFAULT_OFF,
-       	'y2k'		=> DEFAULT_OFF,
-       	'untie'		=> DEFAULT_OFF,
-	'substr'	=> DEFAULT_OFF,
-	'taint'		=> DEFAULT_OFF,
-	'signal'	=> DEFAULT_OFF,
-	'closure'	=> DEFAULT_OFF,
-	'overflow'	=> DEFAULT_OFF,
-	'portable'	=> DEFAULT_OFF,
-	'utf8'		=> DEFAULT_OFF,
-       	'exiting'	=> DEFAULT_OFF,
-       	'pack'		=> DEFAULT_OFF,
-       	'unpack'	=> DEFAULT_OFF,
-       	 #'default'	=> DEFAULT_ON,
-  	}
+'all' => [ 5.008, {
+	'io'		=> [ 5.008, { 	
+				'pipe' 		=> [ 5.008, DEFAULT_OFF],
+       				'unopened'	=> [ 5.008, DEFAULT_OFF],
+       				'closed'	=> [ 5.008, DEFAULT_OFF],
+       				'newline'	=> [ 5.008, DEFAULT_OFF],
+       				'exec'		=> [ 5.008, DEFAULT_OFF],
+       				'layer'		=> [ 5.008, DEFAULT_OFF],
+			   }],
+     	'syntax'	=> [ 5.008, { 	
+				'ambiguous'	=> [ 5.008, DEFAULT_OFF],
+			     	'semicolon'	=> [ 5.008, DEFAULT_OFF],
+			     	'precedence'	=> [ 5.008, DEFAULT_OFF],
+			     	'bareword'	=> [ 5.008, DEFAULT_OFF],
+			     	'reserved'	=> [ 5.008, DEFAULT_OFF],
+				'digit'		=> [ 5.008, DEFAULT_OFF],
+			     	'parenthesis'	=> [ 5.008, DEFAULT_OFF],
+       	 			'printf'	=> [ 5.008, DEFAULT_OFF],
+       	 			'prototype'	=> [ 5.008, DEFAULT_OFF],
+       	 			'qw'		=> [ 5.008, DEFAULT_OFF],
+			   }],
+       	'severe'	=> [ 5.008, { 	
+				'inplace'	=> [ 5.008, DEFAULT_ON],
+	 			'internal'	=> [ 5.008, DEFAULT_ON],
+         			'debugging'	=> [ 5.008, DEFAULT_ON],
+         			'malloc'	=> [ 5.008, DEFAULT_ON],
+	 		   }],
+        'deprecated'	=> [ 5.008, DEFAULT_OFF],
+       	'void'		=> [ 5.008, DEFAULT_OFF],
+       	'recursion'	=> [ 5.008, DEFAULT_OFF],
+       	'redefine'	=> [ 5.008, DEFAULT_OFF],
+       	'numeric'	=> [ 5.008, DEFAULT_OFF],
+        'uninitialized'	=> [ 5.008, DEFAULT_OFF],
+       	'once'		=> [ 5.008, DEFAULT_OFF],
+       	'misc'		=> [ 5.008, DEFAULT_OFF],
+       	'regexp'	=> [ 5.008, DEFAULT_OFF],
+       	'glob'		=> [ 5.008, DEFAULT_OFF],
+       	'untie'		=> [ 5.008, DEFAULT_OFF],
+	'substr'	=> [ 5.008, DEFAULT_OFF],
+	'taint'		=> [ 5.008, DEFAULT_OFF],
+	'signal'	=> [ 5.008, DEFAULT_OFF],
+	'closure'	=> [ 5.008, DEFAULT_OFF],
+	'overflow'	=> [ 5.008, DEFAULT_OFF],
+	'portable'	=> [ 5.008, DEFAULT_OFF],
+	'utf8'		=> [ 5.008, DEFAULT_OFF],
+       	'exiting'	=> [ 5.008, DEFAULT_OFF],
+       	'pack'		=> [ 5.008, DEFAULT_OFF],
+       	'unpack'	=> [ 5.008, DEFAULT_OFF],
+       	'threads'	=> [ 5.008, DEFAULT_OFF],
+       	'imprecision'	=> [ 5.011, DEFAULT_OFF],
+
+       	 #'default'	=> [ 5.008, DEFAULT_ON ],
+  	}],
 } ;
 
-
 ###########################################################################
 sub tab {
     my($l, $t) = @_;
@@ -74,8 +92,49 @@ sub tab {
 
 my %list ;
 my %Value ;
+my %ValueToName ;
+my %NameToValue ;
 my $index ;
 
+my %v_list = () ;
+
+sub valueWalk
+{
+    my $tre = shift ;
+    my @list = () ;
+    my ($k, $v) ;
+
+    foreach $k (sort keys %$tre) {
+	$v = $tre->{$k};
+	die "duplicate key $k\n" if defined $list{$k} ;
+	die "Value associated with key '$k' is not an ARRAY reference"
+	    if !ref $v || ref $v ne 'ARRAY' ;
+
+	my ($ver, $rest) = @{ $v } ;
+	push @{ $v_list{$ver} }, $k;
+	
+	if (ref $rest)
+	  { valueWalk ($rest) }
+
+    }
+
+}
+
+sub orderValues
+{
+    my $index = 0;
+    foreach my $ver ( sort { $a <=> $b } keys %v_list ) {
+        foreach my $name (@{ $v_list{$ver} } ) {
+	    $ValueToName{ $index } = [ uc $name, $ver ] ;
+	    $NameToValue{ uc $name } = $index ++ ;
+        }
+    }
+
+    return $index ;
+}
+
+###########################################################################
+
 sub walk
 {
     my $tre = shift ;
@@ -85,10 +144,17 @@ sub walk
     foreach $k (sort keys %$tre) {
 	$v = $tre->{$k};
 	die "duplicate key $k\n" if defined $list{$k} ;
-	$Value{$index} = uc $k ;
-        push @{ $list{$k} }, $index ++ ;
-	if (ref $v)
-	  { push (@{ $list{$k} }, walk ($v)) }
+	#$Value{$index} = uc $k ;
+	die "Can't find key '$k'"
+	    if ! defined $NameToValue{uc $k} ;
+        push @{ $list{$k} }, $NameToValue{uc $k} ;
+	die "Value associated with key '$k' is not an ARRAY reference"
+	    if !ref $v || ref $v ne 'ARRAY' ;
+	
+	my ($ver, $rest) = @{ $v } ;
+	if (ref $rest)
+	  { push (@{ $list{$k} }, walk ($rest)) }
+
 	push @list, @{ $list{$k} } ;
     }
 
@@ -120,20 +186,33 @@ sub printTree
 {
     my $tre = shift ;
     my $prefix = shift ;
-    my $indent = shift ;
     my ($k, $v) ;
 
     my $max = (sort {$a <=> $b} map { length $_ } keys %$tre)[-1] ;
+    my @keys = sort keys %$tre ;
 
-    $prefix .= " " x $indent ;
-    foreach $k (sort keys %$tre) {
+    while ($k = shift @keys) {
 	$v = $tre->{$k};
-	print $prefix . "|\n" ;
-	print $prefix . "+- $k" ;
-	if (ref $v)
+	die "Value associated with key '$k' is not an ARRAY reference"
+	    if !ref $v || ref $v ne 'ARRAY' ;
+	
+        my $offset ;
+	if ($tre ne $tree) {
+	    print $prefix . "|\n" ;
+	    print $prefix . "+- $k" ;
+	    $offset = ' ' x ($max + 4) ;
+	}
+	else {
+	    print $prefix . "$k" ;
+	    $offset = ' ' x ($max + 1) ;
+	}
+
+	my ($ver, $rest) = @{ $v } ;
+	if (ref $rest)
 	{
-	    print " " . "-" x ($max - length $k ) . "+\n" ;
-	    printTree ($v, $prefix . "|" , $max + $indent - 1)
+	    my $bar = @keys ? "|" : " ";
+	    print " -" . "-" x ($max - length $k ) . "+\n" ;
+	    printTree ($rest, $prefix . $bar . $offset )
 	}
 	else
 	  { print "\n" }
@@ -180,18 +259,16 @@ sub mkOct
 
 if (@ARGV && $ARGV[0] eq "tree")
 {
-    #print "  all -+\n" ;
-    printTree($tree, "   ", 4) ;
+    printTree($tree, "    ") ;
     exit ;
 }
 
-unlink "warnings.h";
-unlink "lib/warnings.pm";
-open(WARN, ">warnings.h") || die "Can't create warnings.h: $!\n";
-open(PM, ">lib/warnings.pm") || die "Can't create lib/warnings.pm: $!\n";
+my $warn = safer_open("warnings.h-new");
+my $pm = safer_open("lib/warnings.pm-new");
 
-print WARN <<'EOM' ;
-/* !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
+print $warn <<'EOM' ;
+/* -*- buffer-read-only: t -*-
+   !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
    This file is built by warnings.pl
    Any changes made here will be lost!
 */
@@ -209,110 +286,79 @@ print WARN <<'EOM' ;
 #define G_WARN_ONCE		8	/* set if 'once' ever enabled */
 #define G_WARN_ALL_MASK		(G_WARN_ALL_ON|G_WARN_ALL_OFF)
 
-#define pWARN_STD		Nullsv
-#define pWARN_ALL		(Nullsv+1)	/* use warnings 'all' */
-#define pWARN_NONE		(Nullsv+2)	/* no  warnings 'all' */
+#define pWARN_STD		NULL
+#define pWARN_ALL		(((STRLEN*)0)+1)    /* use warnings 'all' */
+#define pWARN_NONE		(((STRLEN*)0)+2)    /* no  warnings 'all' */
 
 #define specialWARN(x)		((x) == pWARN_STD || (x) == pWARN_ALL ||	\
 				 (x) == pWARN_NONE)
+
+/* if PL_warnhook is set to this value, then warnings die */
+#define PERL_WARNHOOK_FATAL	(&PL_sv_placeholder)
 EOM
 
 my $offset = 0 ;
 
 $index = $offset ;
 #@{ $list{"all"} } = walk ($tree) ;
-walk ($tree) ;
+valueWalk ($tree) ;
+my $index = orderValues();
 
 die <<EOM if $index > 255 ;
 Too many warnings categories -- max is 255
     rewrite packWARN* & unpackWARN* macros 
 EOM
 
+walk ($tree) ;
+
 $index *= 2 ;
 my $warn_size = int($index / 8) + ($index % 8 != 0) ;
 
 my $k ;
-foreach $k (sort { $a <=> $b } keys %Value) {
-    print WARN tab(5, "#define WARN_$Value{$k}"), "$k\n" ;
+my $last_ver = 0;
+foreach $k (sort { $a <=> $b } keys %ValueToName) {
+    my ($name, $version) = @{ $ValueToName{$k} };
+    print $warn "\n/* Warnings Categories added in Perl $version */\n\n"
+        if $last_ver != $version ;
+    print $warn tab(5, "#define WARN_$name"), "$k\n" ;
+    $last_ver = $version ;
 }
-print WARN "\n" ;
+print $warn "\n" ;
 
-print WARN tab(5, '#define WARNsize'),	"$warn_size\n" ;
+print $warn tab(5, '#define WARNsize'),	"$warn_size\n" ;
 #print WARN tab(5, '#define WARN_ALLstring'), '"', ('\377' x $warn_size) , "\"\n" ;
-print WARN tab(5, '#define WARN_ALLstring'), '"', ('\125' x $warn_size) , "\"\n" ;
-print WARN tab(5, '#define WARN_NONEstring'), '"', ('\0' x $warn_size) , "\"\n" ;
-my $WARN_TAINTstring = mkOct($warn_size, map $_ * 2, @{ $list{'taint'} });
-
-print WARN tab(5, '#define WARN_TAINTstring'), qq["$WARN_TAINTstring"\n] ;
+print $warn tab(5, '#define WARN_ALLstring'), '"', ('\125' x $warn_size) , "\"\n" ;
+print $warn tab(5, '#define WARN_NONEstring'), '"', ('\0' x $warn_size) , "\"\n" ;
 
-print WARN <<'EOM';
+print $warn <<'EOM';
 
 #define isLEXWARN_on 	(PL_curcop->cop_warnings != pWARN_STD)
 #define isLEXWARN_off	(PL_curcop->cop_warnings == pWARN_STD)
 #define isWARN_ONCE	(PL_dowarn & (G_WARN_ON|G_WARN_ONCE))
-#define isWARN_on(c,x)	(IsSet(SvPVX(c), 2*(x)))
-#define isWARNf_on(c,x)	(IsSet(SvPVX(c), 2*(x)+1))
-
-#define ckWARN(x)							\
-	( (isLEXWARN_on && PL_curcop->cop_warnings != pWARN_NONE &&	\
-	      (PL_curcop->cop_warnings == pWARN_ALL ||			\
-	       isWARN_on(PL_curcop->cop_warnings, x) ) )		\
-	  || (isLEXWARN_off && PL_dowarn & G_WARN_ON) )
-
-#define ckWARN2(x,y)							\
-	  ( (isLEXWARN_on && PL_curcop->cop_warnings != pWARN_NONE &&	\
-	      (PL_curcop->cop_warnings == pWARN_ALL ||			\
-	        isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, y) ) ) 		\
-	    ||	(isLEXWARN_off && PL_dowarn & G_WARN_ON) )
-
-#define ckWARN3(x,y,z)							\
-	  ( (isLEXWARN_on && PL_curcop->cop_warnings != pWARN_NONE &&	\
-	      (PL_curcop->cop_warnings == pWARN_ALL ||			\
-	        isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, y)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, z) ) ) 		\
-	    ||	(isLEXWARN_off && PL_dowarn & G_WARN_ON) )
-
-#define ckWARN4(x,y,z,t)						\
-	  ( (isLEXWARN_on && PL_curcop->cop_warnings != pWARN_NONE &&	\
-	      (PL_curcop->cop_warnings == pWARN_ALL ||			\
-	        isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, y)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, z)  ||		\
-	        isWARN_on(PL_curcop->cop_warnings, t) ) ) 		\
-	    ||	(isLEXWARN_off && PL_dowarn & G_WARN_ON) )
-
-#define ckWARN_d(x)							\
-	  (isLEXWARN_off || PL_curcop->cop_warnings == pWARN_ALL ||	\
-	     (PL_curcop->cop_warnings != pWARN_NONE &&			\
-	      isWARN_on(PL_curcop->cop_warnings, x) ) )
-
-#define ckWARN2_d(x,y)							\
-	  (isLEXWARN_off || PL_curcop->cop_warnings == pWARN_ALL ||	\
-	     (PL_curcop->cop_warnings != pWARN_NONE &&			\
-	        (isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, y) ) ) )
-
-#define ckWARN3_d(x,y,z)						\
-	  (isLEXWARN_off || PL_curcop->cop_warnings == pWARN_ALL ||	\
-	     (PL_curcop->cop_warnings != pWARN_NONE &&			\
-	        (isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, y)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, z) ) ) )
-
-#define ckWARN4_d(x,y,z,t)						\
-	  (isLEXWARN_off || PL_curcop->cop_warnings == pWARN_ALL ||	\
-	     (PL_curcop->cop_warnings != pWARN_NONE &&			\
-	        (isWARN_on(PL_curcop->cop_warnings, x)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, y)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, z)  ||		\
-	         isWARN_on(PL_curcop->cop_warnings, t) ) ) )
-
-#define packWARN(a)		(a                                 )
-#define packWARN2(a,b)		((a) | (b)<<8                      )
-#define packWARN3(a,b,c)	((a) | (b)<<8 | (c) <<16           )
-#define packWARN4(a,b,c,d)	((a) | (b)<<8 | (c) <<16 | (d) <<24)
+#define isWARN_on(c,x)	(IsSet((U8 *)(c + 1), 2*(x)))
+#define isWARNf_on(c,x)	(IsSet((U8 *)(c + 1), 2*(x)+1))
+
+#define DUP_WARNINGS(p)		\
+    (specialWARN(p) ? (STRLEN*)(p)	\
+    : (STRLEN*)CopyD(p, PerlMemShared_malloc(sizeof(*p)+*p), sizeof(*p)+*p, \
+		     			     char))
+
+#define ckWARN(w)		Perl_ckwarn(aTHX_ packWARN(w))
+#define ckWARN2(w1,w2)		Perl_ckwarn(aTHX_ packWARN2(w1,w2))
+#define ckWARN3(w1,w2,w3)	Perl_ckwarn(aTHX_ packWARN3(w1,w2,w3))
+#define ckWARN4(w1,w2,w3,w4)	Perl_ckwarn(aTHX_ packWARN4(w1,w2,w3,w4))
+
+#define ckWARN_d(w)		Perl_ckwarn_d(aTHX_ packWARN(w))
+#define ckWARN2_d(w1,w2)	Perl_ckwarn_d(aTHX_ packWARN2(w1,w2))
+#define ckWARN3_d(w1,w2,w3)	Perl_ckwarn_d(aTHX_ packWARN3(w1,w2,w3))
+#define ckWARN4_d(w1,w2,w3,w4)	Perl_ckwarn_d(aTHX_ packWARN4(w1,w2,w3,w4))
+
+#define WARNshift		8
+
+#define packWARN(a)		(a                                      )
+#define packWARN2(a,b)		((a) | ((b)<<8)                         )
+#define packWARN3(a,b,c)	((a) | ((b)<<8) | ((c)<<16)             )
+#define packWARN4(a,b,c,d)	((a) | ((b)<<8) | ((c)<<16) | ((d) <<24))
 
 #define unpackWARN1(x)		((x)        & 0xFF)
 #define unpackWARN2(x)		(((x) >>8)  & 0xFF)
@@ -328,74 +374,91 @@ print WARN <<'EOM';
 	      isWARNf_on(PL_curcop->cop_warnings, unpackWARN4(x))))
 
 /* end of file warnings.h */
-
+/* ex: set ro: */
 EOM
 
-close WARN ;
+safer_close $warn;
+rename_if_different("warnings.h-new", "warnings.h");
 
 while (<DATA>) {
     last if /^KEYWORDS$/ ;
-    print PM $_ ;
+    print $pm $_ ;
 }
 
 #$list{'all'} = [ $offset .. 8 * ($warn_size/2) - 1 ] ;
 
-#my %Keys = map {lc $Value{$_}, $_} keys %Value ;
-
-print PM "%Offsets = (\n" ;
-foreach my $k (sort { $a <=> $b } keys %Value) {
-    my $v = lc $Value{$k} ;
+$last_ver = 0;
+print $pm "our %Offsets = (\n" ;
+foreach my $k (sort { $a <=> $b } keys %ValueToName) {
+    my ($name, $version) = @{ $ValueToName{$k} };
+    $name = lc $name;
     $k *= 2 ;
-    print PM tab(4, "    '$v'"), "=> $k,\n" ;
+    if ( $last_ver != $version ) {
+        print $pm "\n";
+        print $pm tab(4, "    # Warnings Categories added in Perl $version");
+        print $pm "\n\n";
+    }
+    print $pm tab(4, "    '$name'"), "=> $k,\n" ;
+    $last_ver = $version;
 }
 
-print PM "  );\n\n" ;
+print $pm "  );\n\n" ;
 
-print PM "%Bits = (\n" ;
+print $pm "our %Bits = (\n" ;
 foreach $k (sort keys  %list) {
 
     my $v = $list{$k} ;
     my @list = sort { $a <=> $b } @$v ;
 
-    print PM tab(4, "    '$k'"), '=> "',
+    print $pm tab(4, "    '$k'"), '=> "',
 		# mkHex($warn_size, @list),
 		mkHex($warn_size, map $_ * 2 , @list),
 		'", # [', mkRange(@list), "]\n" ;
 }
 
-print PM "  );\n\n" ;
+print $pm "  );\n\n" ;
 
-print PM "%DeadBits = (\n" ;
+print $pm "our %DeadBits = (\n" ;
 foreach $k (sort keys  %list) {
 
     my $v = $list{$k} ;
     my @list = sort { $a <=> $b } @$v ;
 
-    print PM tab(4, "    '$k'"), '=> "',
+    print $pm tab(4, "    '$k'"), '=> "',
 		# mkHex($warn_size, @list),
 		mkHex($warn_size, map $_ * 2 + 1 , @list),
 		'", # [', mkRange(@list), "]\n" ;
 }
 
-print PM "  );\n\n" ;
-print PM '$NONE     = "', ('\0' x $warn_size) , "\";\n" ;
-print PM '$LAST_BIT = ' . "$index ;\n" ;
-print PM '$BYTES    = ' . "$warn_size ;\n" ;
+print $pm "  );\n\n" ;
+print $pm '$NONE     = "', ('\0' x $warn_size) , "\";\n" ;
+print $pm '$LAST_BIT = ' . "$index ;\n" ;
+print $pm '$BYTES    = ' . "$warn_size ;\n" ;
 while (<DATA>) {
-    print PM $_ ;
+    print $pm $_ ;
 }
 
-close PM ;
+print $pm "# ex: set ro:\n";
+safer_close $pm;
+rename_if_different("lib/warnings.pm-new", "lib/warnings.pm");
 
 __END__
-
+# -*- buffer-read-only: t -*-
+# !!!!!!!   DO NOT EDIT THIS FILE   !!!!!!!
 # This file was created by warnings.pl
 # Any changes made here will be lost.
 #
 
 package warnings;
 
-our $VERSION = '1.00';
+our $VERSION = '1.08';
+
+# Verify that we're called correctly so that warnings will work.
+# see also strict.pm.
+unless ( __FILE__ =~ /(^|[\/\\])\Q${\__PACKAGE__}\E\.pmc?$/ ) {
+    my (undef, $f, $l) = caller;
+    die("Incorrect use of pragma '${\__PACKAGE__}' at $f line $l.\n");
+}
 
 =head1 NAME
 
@@ -428,6 +491,10 @@ warnings - Perl pragma to control optional warnings
 
 =head1 DESCRIPTION
 
+The C<warnings> pragma is a replacement for the command line flag C<-w>,
+but the pragma is limited to the enclosing block, while the flag is global.
+See L<perllexwarn> for more information.
+
 If no import list is supplied, all possible warnings are either enabled
 or disabled.
 
@@ -462,6 +529,27 @@ Return TRUE if that warnings category is enabled in the first scope
 where the object is used.
 Otherwise returns FALSE.
 
+=item warnings::fatal_enabled()
+
+Return TRUE if the warnings category with the same name as the current
+package has been set to FATAL in the calling module.
+Otherwise returns FALSE.
+
+=item warnings::fatal_enabled($category)
+
+Return TRUE if the warnings category C<$category> has been set to FATAL in
+the calling module.
+Otherwise returns FALSE.
+
+=item warnings::fatal_enabled($object)
+
+Use the name of the class for the object reference, C<$object>, as the
+warnings category.
+
+Return TRUE if that warnings category has been set to FATAL in the first
+scope where the object is used.
+Otherwise returns FALSE.
+
 =item warnings::warn($message)
 
 Print C<$message> to STDERR.
@@ -516,29 +604,42 @@ See L<perlmodlib/Pragmatic Modules> and L<perllexwarn>.
 
 =cut
 
-use Carp ;
-
 KEYWORDS
 
 $All = "" ; vec($All, $Offsets{'all'}, 2) = 3 ;
 
 sub Croaker
 {
+    require Carp; # this initializes %CarpInternal
+    local $Carp::CarpInternal{'warnings'};
     delete $Carp::CarpInternal{'warnings'};
-    croak @_ ;
+    Carp::croak(@_);
 }
 
-sub bits {
-    my $mask ;
+sub bits
+{
+    # called from B::Deparse.pm
+
+    push @_, 'all' unless @_;
+
+    my $mask;
     my $catmask ;
     my $fatal = 0 ;
-    foreach my $word (@_) {
-	if  ($word eq 'FATAL') {
+    my $no_fatal = 0 ;
+
+    foreach my $word ( @_ ) {
+	if ($word eq 'FATAL') {
 	    $fatal = 1;
+	    $no_fatal = 0;
+	}
+	elsif ($word eq 'NONFATAL') {
+	    $fatal = 0;
+	    $no_fatal = 1;
 	}
 	elsif ($catmask = $Bits{$word}) {
 	    $mask |= $catmask ;
 	    $mask |= $DeadBits{$word} if $fatal ;
+	    $mask &= ~($DeadBits{$word}|$All) if $no_fatal ;
 	}
 	else
           { Croaker("Unknown warnings category '$word'")}
@@ -547,26 +648,74 @@ sub bits {
     return $mask ;
 }
 
-sub import {
+sub import 
+{
     shift;
+
+    my $catmask ;
+    my $fatal = 0 ;
+    my $no_fatal = 0 ;
+
     my $mask = ${^WARNING_BITS} ;
+
     if (vec($mask, $Offsets{'all'}, 1)) {
         $mask |= $Bits{'all'} ;
         $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1);
     }
-    ${^WARNING_BITS} = $mask | bits(@_ ? @_ : 'all') ;
+    
+    push @_, 'all' unless @_;
+
+    foreach my $word ( @_ ) {
+	if ($word eq 'FATAL') {
+	    $fatal = 1;
+	    $no_fatal = 0;
+	}
+	elsif ($word eq 'NONFATAL') {
+	    $fatal = 0;
+	    $no_fatal = 1;
+	}
+	elsif ($catmask = $Bits{$word}) {
+	    $mask |= $catmask ;
+	    $mask |= $DeadBits{$word} if $fatal ;
+	    $mask &= ~($DeadBits{$word}|$All) if $no_fatal ;
+	}
+	else
+          { Croaker("Unknown warnings category '$word'")}
+    }
+
+    ${^WARNING_BITS} = $mask ;
 }
 
-sub unimport {
+sub unimport 
+{
     shift;
+
+    my $catmask ;
     my $mask = ${^WARNING_BITS} ;
+
     if (vec($mask, $Offsets{'all'}, 1)) {
         $mask |= $Bits{'all'} ;
         $mask |= $DeadBits{'all'} if vec($mask, $Offsets{'all'}+1, 1);
     }
-    ${^WARNING_BITS} = $mask & ~ (bits('FATAL' => (@_ ? @_ : 'all')) | $All) ;
+
+    push @_, 'all' unless @_;
+
+    foreach my $word ( @_ ) {
+	if ($word eq 'FATAL') {
+	    next; 
+	}
+	elsif ($catmask = $Bits{$word}) {
+	    $mask &= ~($catmask | $DeadBits{$word} | $All);
+	}
+	else
+          { Croaker("Unknown warnings category '$word'")}
+    }
+
+    ${^WARNING_BITS} = $mask ;
 }
 
+my %builtin_type; @builtin_type{qw(SCALAR ARRAY HASH CODE REF GLOB LVALUE Regexp)} = ();
+
 sub __chk
 {
     my $category ;
@@ -576,10 +725,10 @@ sub __chk
     if (@_) {
         # check the category supplied.
         $category = shift ;
-        if (ref $category) {
-            Croaker ("not an object")
-                if $category !~ /^([^=]+)=/ ;
-	    $category = $1 ;
+        if (my $type = ref $category) {
+            Croaker("not an object")
+                if exists $builtin_type{$type};
+	    $category = $type;
             $isobj = 1 ;
         }
         $offset = $Offsets{$category};
@@ -604,17 +753,18 @@ sub __chk
 	$i -= 2 ;
     }
     else {
-        for ($i = 2 ; $pkg = (caller($i))[0] ; ++ $i) {
-            last if $pkg ne $this_pkg ;
-        }
-        $i = 2
-            if !$pkg || $pkg eq $this_pkg ;
+        $i = _error_loc(); # see where Carp will allocate the error
     }
 
     my $callers_bitmask = (caller($i))[9] ;
     return ($callers_bitmask, $offset, $i) ;
 }
 
+sub _error_loc {
+    require Carp;
+    goto &Carp::short_error_loc; # don't introduce another stack frame
+}                                                             
+
 sub enabled
 {
     Croaker("Usage: warnings::enabled([category])")
@@ -627,6 +777,17 @@ sub enabled
            vec($callers_bitmask, $Offsets{'all'}, 1) ;
 }
 
+sub fatal_enabled
+{
+    Croaker("Usage: warnings::fatal_enabled([category])")
+  unless @_ == 1 || @_ == 0 ;
+
+    my ($callers_bitmask, $offset, $i) = __chk(@_) ;
+
+    return 0 unless defined $callers_bitmask;
+    return vec($callers_bitmask, $offset + 1, 1) ||
+           vec($callers_bitmask, $Offsets{'all'} + 1, 1) ;
+}
 
 sub warn
 {
@@ -635,10 +796,11 @@ sub warn
 
     my $message = pop ;
     my ($callers_bitmask, $offset, $i) = __chk(@_) ;
-    croak($message)
+    require Carp;
+    Carp::croak($message)
 	if vec($callers_bitmask, $offset+1, 1) ||
 	   vec($callers_bitmask, $Offsets{'all'}+1, 1) ;
-    carp($message) ;
+    Carp::carp($message) ;
 }
 
 sub warnif
@@ -654,10 +816,12 @@ sub warnif
             	(vec($callers_bitmask, $offset, 1) ||
             	vec($callers_bitmask, $Offsets{'all'}, 1)) ;
 
-    croak($message)
+    require Carp;
+    Carp::croak($message)
 	if vec($callers_bitmask, $offset+1, 1) ||
 	   vec($callers_bitmask, $Offsets{'all'}+1, 1) ;
 
-    carp($message) ;
+    Carp::carp($message) ;
 }
+
 1;