This is a live mirror of the Perl 5 development currently hosted at https://github.com/perl/perl5
support USE_THREADS+MULTIPLICITY; source compat tweaks for
authorGurusamy Sarathy <gsar@cpan.org>
Fri, 20 Aug 1999 15:24:08 +0000 (15:24 +0000)
committerGurusamy Sarathy <gsar@cpan.org>
Fri, 20 Aug 1999 15:24:08 +0000 (15:24 +0000)
USE_THREADS and MULTIPLICITY; minor pod adjustments

p4raw-id: //depot/perl@4007

Porting/patching.pod
Todo
Todo-5.005
XSUB.h
embed.pl
embedvar.h
perl.c
perl.h
pod/perlguts.pod
util.c

index caada0c..5659f23 100644 (file)
@@ -30,7 +30,7 @@ attempt to make everybody's life easier.
 
 The most common problems appear to be patches being mangled by certain
 mailers (I won't name names, but most of these seem to be originating on
-boxes running a certain popular commercial operating system). Other problems
+boxes running a certain popular commercial operating system).  Other problems
 include patches not rooted in the appropriate place in the directory structure,
 and patches not produced using standard utilities (such as diff).
 
@@ -52,7 +52,7 @@ First, back up the original files.  This can't be stressed enough,
 back everything up _first_.
 
 Also, please create patches against a clean distribution of the perl source.
-This insures that everyone else can apply your patch without clobbering their
+This ensures that everyone else can apply your patch without clobbering their
 source tree.
 
 =item diff
@@ -63,15 +63,18 @@ respectively, unified diffs (where the changed line appears immediately next
 to the original) and context diffs (where several lines surrounding the changes
 are included).  See the manpage for diff for more details.
 
-Also, the preferred method for patching is -
+The preferred method for creating a unified diff suitable for feeding
+to the patch program is:
 
-C<diff [C<-c> | C<-u>] E<lt>old-fileE<gt> E<lt>new-fileE<gt>>
+       diff -u old-file new-file > patch-file
 
-Note the order of files.
+Note the order of files.  See below for how to create a patch from
+two directory trees.
 
-Also, if your patch is to the core (rather than to a module) it
-is better to create it as a context diff as some machines have
-broken patch utilities that choke on unified diffs.
+If your patch is for wider consumption, it may be better to create it as
+a context diff as some machines have broken patch utilities that choke on
+unified diffs.  A context diff is made using C<diff -c> rather than
+C<diff -u>.
 
 GNU diff has many desirable features not provided by most vendor-supplied
 diffs.  Some examples using GNU diff:
@@ -94,23 +97,34 @@ diffs.  Some examples using GNU diff:
 
 =item Directories
 
-Patches should be generated from the source root directory, not from the
-directory that the patched file resides in.  This insures that the maintainer
-patches the proper file and avoids name collisions (especially common when trying
-to apply patches to files that appear in both $src_root/ext/* and $src_root/lib/*).
-It is better to diff the file in $src_root/ext than the file in $src_root/lib.
+IMPORTANT: Patches should be generated from the source root directory, not
+from the directory that the patched file resides in.  This ensures that the
+maintainer patches the proper file.
+
+Many files in the distribution are derivative--avoid patching them.
+Patch the originals instead.  Most utilities (like perldoc) are in
+this category, i.e. patch utils/perldoc.PL rather than utils/perldoc.
+Similarly, don't create patches for files under $src_root/ext from
+their copies found in $install_root/lib.  If you are unsure about the
+proper location of a file that may have gotten copied while building
+the source distribution, consult the C<MANIFEST>.
 
 =item Filenames
 
 The most usual convention when submitting patches for a single file is to make
 your changes to a copy of the file with the same name as the original.  Rename
-the original file in such a way that it is obvious what is being patched ($file~ or
-$file.old seem to be popular).
+the original file in such a way that it is obvious what is being patched
+($file.dist or $file.old seem to be popular).
+
+If you are submitting patches that affect multiple files then you should
+backup the entire directory tree (to $source_root.old/ for example).  This
+will allow C<diff -ruN old-dir new-dir> to create all the patches at once.
 
-If you are submitting patches that affect multiple files then you should backup
-the entire directory tree (to $source_root.old/ for example).  This will allow
-C<diff C<-c> E<lt>old-dirE<gt> E<lt>new-dirE<gt>> to create all the patches
-at once.
+=item Try it yourself
+
+Just to make sure your patch "works", be sure to apply it to the Perl
+distribution, rebuild everything, and make sure the testsuite runs
+without incident.
 
 =back
 
@@ -125,7 +139,7 @@ the patch corrects.  If it is a code patch (rather than a documentation
 patch) you should also include a small test case that illustrates the
 bug.
 
-=item Direction for application
+=item Directions for application
 
 You should include instructions on how to properly apply your patch.
 These should include the files affected, any shell scripts or commands
@@ -150,15 +164,35 @@ side of adding too many comments than too few.
 
 =item Style
 
-Please follow the indentation style and nesting style in use in the
-block of code that you are patching.
+In general, please follow the particular style of the code you are patching.
+
+In particular, follow these general guidelines for patching Perl sources:
+
+    8-wide tabs (no exceptions!)
+    4-wide indents for code, 2-wide indents for nested CPP #defines
+    try hard not to exceed 79-columns
+    ANSI C prototypes
+    uncuddled elses and "K&R" style for indenting control constructs
+    no C++ style (//) comments, most C compilers will choke on them
+    mark places that need to be revisited with XXX (and revisit often!)
+    opening brace lines up with "if" when conditional spans multiple
+        lines; should be at end-of-line otherwise
+    in function definitions, name starts in column 0 (return value is on
+        previous line)
+    single space after keywords that are followed by parens, no space
+        between function name and following paren
+    avoid assignments in conditionals, but if they're unavoidable, use
+        extra paren, e.g. "if (a && (b = c)) ..."
+    "return foo;" rather than "return(foo);"
+    "if (!foo) ..." rather than "if (foo == FALSE) ..." etc.
+
 
 =item Testsuite
 
 When submitting a patch you should make every effort to also include
 an addition to perl's regression tests to properly exercise your
 patch.  Your testsuite additions should generally follow these
-guidelines (courtesy of Gurusamy Sarathy (gsar@engin.umich.edu))-
+guidelines (courtesy of Gurusamy Sarathy <gsar@activestate.com>):
 
        Know what you're testing.  Read the docs, and the source.
        Tend to fail, not succeed.
@@ -173,16 +207,16 @@ guidelines (courtesy of Gurusamy Sarathy (gsar@engin.umich.edu))-
          do use them, make sure that you cover _all_ perl platforms.
        Unlink any temporary files you create.
        Promote unforeseen warnings to errors with $SIG{__WARN__}.
-       Be sure to use the libraries and modules shipped with version 
+       Be sure to use the libraries and modules shipped with the version 
           being tested, not those that were already installed.
        Add comments to the code explaining what you are testing for.
        Make updating the '1..42' string unnecessary.  Or make sure that 
           you update it.
-       Test _all_ behaviors of a given operator, library, or function-
-         All optional arguments
-         Return values in various contexts (boolean, scalar, list, lvalue)
-         Use both global and lexical variables
-         Don't forget the exceptional, pathological cases.
+       Test _all_ behaviors of a given operator, library, or function:
+         All optional arguments
+         Return values in various contexts (boolean, scalar, list, lvalue)
+         Use both global and lexical variables
+         Don't forget the exceptional, pathological cases.
 
 =back
 
@@ -196,7 +230,7 @@ patch, didn't you).
 
 =head2 An example patch creation
 
-This should work for most patches-
+This should work for most patches:
 
       cp MANIFEST MANIFEST.old
       emacs MANIFEST
@@ -222,7 +256,7 @@ word wraps your patch or that MIME encodes it.  Both of these leave
 the patch essentially worthless to the maintainer.
 
 If you have no choice in mailers and no way to get your hands on a
-better one there is, of course, a perl solution.  Just do this-
+better one there is, of course, a perl solution.  Just do this:
 
       perl -ne 'print pack("u*",$_)' patch > patch.uue
 
@@ -234,27 +268,37 @@ and post patch.uue with a note saying to unpack it using
 
 The subject line on your patch should read
 
-[PATCH]5.xxx_xx (Area) Description
+    [PATCH 5.xxx_xx AREA] Description
 
-where the x's are replaced by the appropriate version number,
-area is a short keyword identifying what area of perl you are
-patching, and description is a very brief summary of the
+where the x's are replaced by the appropriate version number.
+The description should be a very brief but accurate summary of the
 problem (don't forget this is an email header).
 
-Examples-
+Examples:
 
-[PATCH]5.004_04 (DOC) fix minor typos
+    [PATCH 5.004_04 DOC] fix minor typos
 
-[PATCH]5.004_99 (CORE) New warning for foo() when frobbing
+    [PATCH 5.004_99 CORE] New warning for foo() when frobbing
 
-[PATCH]5.005_42 (CONFIG) Added support for fribnatz 1.5
+    [PATCH 5.005_42 CONFIG] Added support for fribnatz 1.5
+
+The name of the file being patched makes for a poor subject line if
+no other descriptive text accompanies it.
 
 =item Where to send your patch
 
-If your patch is for the perl core it should be sent perlbug@perl.org.
+If your patch is for a specific bug in the Perl core, it should be sent
+using the perlbug utility.  Don't forget to describe the problem and the
+fix adequately.
+
 If it is a patch to a module that you downloaded from CPAN you should
 submit your patch to that module's author.
 
+If your patch addresses one of the items described in perltodo.pod,
+please discuss your approach B<before> you make the patch at
+<perl5-porters@perl.org>.  Be sure to browse the archives of past
+discussions (see perltodo.pod for archive locations).
+
 =back
 
 =head2 Applying a patch
@@ -270,19 +314,21 @@ to your perl distribution.
 
 =item patch C<-p>
 
-It is generally easier to apply patches with the C<-p> argument to
-patch.  This helps reconcile differing paths between the machine the
-patch was created on and the machine on which it is being applied.
+It is generally easier to apply patches with the C<-p N> argument to
+patch (where N is the number of path components to skip in the files
+found in the headers).  This helps reconcile differing paths between
+the machine the patch was created on and the machine on which it is
+being applied.
 
 =item Cut and paste
 
-_Never_ cut and paste a patch into your editor.  This usually clobbers
+B<Never> cut and paste a patch into your editor.  This usually clobbers
 the tabs and confuses patch.
 
 =item Hand editing patches
 
-Avoid hand editing patches as this frequently screws up the whitespace
-in the patch and confuses the patch program.
+Avoid hand editing patches as this almost always screws up the line
+numbers and offsets in the patch, making it useless.
 
 =back
 
diff --git a/Todo b/Todo
index b8d9012..028a95e 100644 (file)
--- a/Todo
+++ b/Todo
@@ -1,5 +1,5 @@
-Check out always the latest perl5-porters discussions on these subjects
-before embaring on an implementation tour.
+Always check out the latest perl5-porters discussions on these subjects
+before embarking on an implementation tour.
 
 Tie Modules
        VecArray                Implement array using vec()
@@ -9,71 +9,69 @@ Tie Modules
 
 Would be nice to have
        pack "(stuff)*", "(stuff)4", ...
-       Contiguous bitfields in pack/unpack
+       contiguous bitfields in pack/unpack
        lexperl
-       Bundled perl preprocessor
-       Use posix calls internally where possible
+       bundled perl preprocessor
+       use posix calls internally where possible
        gettimeofday (possibly best left for a module?)
        format BOTTOM
        -i rename file only when successfully changed
-       All ARGV input should act like <>
+       all ARGV input should act like <>
        report HANDLE [formats].
        support in perlmain to rerun debugger
        regression tests using __DIE__ hook
-       reference to compiled regexp
        lexically scoped functions: my sub foo { ... }
        lvalue functions
-           wantlvalue?  more generalized want()?
-       named prototypes: sub ($foo, @bar) foo { ... }
+           wantlvalue?  more generalized want()/caller()?
+       named prototypes: sub foo ($foo, @bar) { ... } ?
        regression/sanity tests for suidperl
        iterators/lazy evaluation/continuations/first/
            first_defined/short-circuiting grep/??
            This is a very thorny and hotly debated subject,
-           tread carefully and do your homework first.
-       Full 64 bit support (i.e. "long long").  Things to consider:
+           tread carefully and do your homework first
+       full 64 bit support (i.e. "long long").  Things to consider:
            how to store/retrieve 32+ integers into/from Perl scalars?
            32+ constants in Perl code? (non-portable!)
            32+ arguments/return values to/from system calls? (seek et al)
            32+ bit ops (&|^~, currently explicitly disabled)
-       Generalise Errno way of extracting cpp symbols and use that in
+       generalise Errno way of extracting cpp symbols and use that in
            Errno and Fcntl (ExtUtils::CppSymbol?)
-       The _r-problem: for all the {set,get,end}*() system database
+       the _r-problem: for all the {set,get,end}*() system database
             calls (and a couple more: readdir, *rand*, crypt, *time,
             tmpnam) there are in many systems the _r versions
-            to be used in re-entrant (=multithreaded) code.
+            to be used in re-entrant (=multithreaded) code
             Icky things: the _r API is not standardized and
-            the _r-forms require per-thread data to store their state.
-       Memory profiler: turn malloc.c:Perl_dump_mstats() into
+            the _r-forms require per-thread data to store their state
+       memory profiler: turn malloc.c:Perl_dump_mstats() into
            an extension (Devel::MProf?) that would return the malloc
            stats in a nice Perl datastructure (also a simple interface
-           to return just the grand total would be good).
+           to return just the grand total would be good)
 
 Possible pragmas
        debugger
-       optimize (use less memory, CPU)
+       optimize (use less qw[memory cpu])
 
 Optimizations
        constant function cache
        switch structures
        foreach(reverse...)
-       Set KEEP on constant split
-       Cache eval tree (unless lexical outer scope used (mark in &compiling?))
+       optimize away constant split at compile time (a la qw[f o o])
+       cache eval tree (unless lexical outer scope used (mark in &compiling?))
        rcatmaybe
-       Shrink opcode tables via multiple implementations selected in peep
-       Cache hash value?  (Not a win, according to Guido)
-       Optimize away @_ where possible
+       shrink opcode tables via multiple implementations selected in peep
+       cache hash value?  (Not a win, according to Guido)
+       optimize away @_ where possible
        "one pass" global destruction
-       Rewrite regexp parser for better integrated optimization
+       rewrite regexp parser for better integrated optimization
        LRU cache of regexp: foreach $pat (@pats) { foo() if /$pat/ }
 
 Vague possibilities
-       ref function in list context
+       ref function in list context?
        make tr/// return histogram in list context?
-       Loop control on do{} et al
-       Explicit switch statements
+       loop control on do{} et al
+       explicit switch statements
        built-in globbing
        compile to real threaded code
        structured types
        autocroak?
-       Modifiable $1 et al
-
+       modifiable $1 et al
index b700603..6abc9d8 100644 (file)
@@ -41,6 +41,7 @@ Regexen
    approximate matching
 
 Reliable Signals
+    custom opcodes
     alternate runops() for signal despatch
     figure out how to die() in delayed sighandler
     add tests for Thread::Signal
@@ -58,7 +59,7 @@ Miscellaneous
     rename and alter ISA.pm
     magic_setisa should be made to update %FIELDS [???]
     add new modules (Archive::Tar, Compress::Zlib, CPAN::FTP?)
-    fix pod2html to generate relative URLs
+    fix pod2html to generate relative URLs (replace with new PodtoHtml?)
     automate testing with large parts of CPAN
 
 Ongoing
diff --git a/XSUB.h b/XSUB.h
index 0389201..adbbd63 100644 (file)
--- a/XSUB.h
+++ b/XSUB.h
 #  include "objXSUB.h"
 #endif /* PERL_OBJECT || PERL_CAPI */
 
-#if defined(PERL_CAPI)
+#if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_NO_GET_CONTEXT)
 #  undef aTHX
 #  undef aTHX_
 #  undef _aTHX
-#  if defined(PERL_NO_GET_CONTEXT)
-#    define aTHX        my_perl
-#  else
-#    define aTHX        PERL_GET_INTERP
-#  endif /* PERL_NO_GET_CONTEXT */
-#  define aTHX_        aTHX,
-#  define _aTHX        ,aTHX
+#  define aTHX         PERL_GET_THX
+#  define aTHX_                aTHX,
+#  define _aTHX                ,aTHX
+#endif
+
+#if defined(PERL_CAPI)
 #  ifndef NO_XSLOCKS
 #    undef closedir
 #    undef opendir
index 09035e8..7016de2 100755 (executable)
--- a/embed.pl
+++ b/embed.pl
@@ -257,16 +257,11 @@ sub objxsub_var ($$) {
     undefine("PL_$sym") . hide("PL_$sym", "(*Perl_${pfx}${sym}_ptr($arg))");
 }
 
-sub embedvar ($) {
-    my ($sym) = @_;
-#   hide($sym, "Perl_$sym");
-    return '';
-}
-
 sub multon ($$$) {
     my ($sym,$pre,$ptr) = @_;
     hide("PL_$sym", "($ptr$pre$sym)");
 }
+
 sub multoff ($$) {
     my ($sym,$pre) = @_;
     return hide("PL_$pre$sym", "PL_$sym");
@@ -533,42 +528,45 @@ print EM <<'END';
 
 /* (Doing namespace management portably in C is really gross.) */
 
-/* Put interpreter-specific symbols into a struct? */
-
-#ifdef MULTIPLICITY
-
-#ifndef USE_THREADS
-/* If we do not have threads then per-thread vars are per-interpreter */
-
-#ifdef PERL_IMPLICIT_CONTEXT
-
-/* everything has an implicit context pointer */
-
-END
-
-for $sym (sort keys %thread) {
-    print EM multon($sym,'T','my_perl->');
-}
-
-print EM <<'END';
+/*
+   The following combinations of MULTIPLICITY, USE_THREADS, PERL_OBJECT
+   and PERL_IMPLICIT_CONTEXT are supported:
+     1) none
+     2) MULTIPLICITY   # supported for compatibility
+     3) MULTIPLICITY && PERL_IMPLICIT_CONTEXT
+     4) USE_THREADS && PERL_IMPLICIT_CONTEXT
+     5) MULTIPLICITY && USE_THREADS && PERL_IMPLICIT_CONTEXT
+     6) PERL_OBJECT && PERL_IMPLICIT_CONTEXT
+
+   All other combinations of these flags are errors.
+
+   #3, #4, #5, and #6 are supported directly, while #2 is a special
+   case of #3 (supported by redefining vTHX appropriately).
+*/
 
-#else /* !PERL_IMPLICIT_CONTEXT */
+#if defined(MULTIPLICITY)
+/* cases 2, 3 and 5 above */
 
-/* traditional MULTIPLICITY (intepreter is in a global) */
+#  if defined(PERL_IMPLICIT_CONTEXT)
+#    define vTHX       aTHX
+#  else
+#    define vTHX       PERL_GET_INTERP
+#  endif
 
 END
 
-
 for $sym (sort keys %thread) {
-    print EM multon($sym,'T','PERL_GET_INTERP->');
+    print EM multon($sym,'T','vTHX->');
 }
 
 print EM <<'END';
 
-#endif /* !PERL_IMPLICIT_CONTEXT */
-#endif /* !USE_THREADS */
+#  if defined(PERL_OBJECT)
+#    include "error: PERL_OBJECT + MULTIPLICITY don't go together"
+#  endif
 
-/* These are always per-interpreter if there is more than one */
+#  if defined(USE_THREADS)
+/* case 5 above */
 
 END
 
@@ -578,66 +576,56 @@ for $sym (sort keys %intrp) {
 
 print EM <<'END';
 
-#else  /* !MULTIPLICITY */
+#  else                /* !USE_THREADS */
+/* cases 2 and 3 above */
 
 END
 
 for $sym (sort keys %intrp) {
-    print EM multoff($sym,'I');
-}
-
-print EM <<'END';
-
-#ifndef USE_THREADS
-
-END
-
-for $sym (sort keys %thread) {
-    print EM multoff($sym,'T');
+    print EM multon($sym,'I','vTHX->');
 }
 
 print EM <<'END';
 
-#endif /* USE_THREADS */
+#  endif       /* USE_THREADS */
 
-/* Hide what would have been interpreter-specific symbols? */
+#else  /* !MULTIPLICITY */
+/* cases 1, 4 and 6 above */
 
 END
 
 for $sym (sort keys %intrp) {
-    print EM embedvar($sym);
+    print EM multoff($sym,'I');
 }
 
 print EM <<'END';
 
-#ifndef USE_THREADS
+#  if defined(USE_THREADS)
+/* case 4 above */
 
 END
 
 for $sym (sort keys %thread) {
-    print EM embedvar($sym);
+    print EM multon($sym,'T','aTHX->');
 }
 
 print EM <<'END';
 
-#endif /* USE_THREADS */
-#endif /* MULTIPLICITY */
-
-/* Now same trickey for per-thread variables */
-
-#ifdef USE_THREADS
+#  else                /* !USE_THREADS */
+/* cases 1 and 6 above */
 
 END
 
 for $sym (sort keys %thread) {
-    print EM multon($sym,'T','thr->');
+    print EM multoff($sym,'T');
 }
 
 print EM <<'END';
 
-#endif /* USE_THREADS */
+#  endif       /* USE_THREADS */
+#endif /* MULTIPLICITY */
 
-#ifdef PERL_GLOBAL_STRUCT
+#if defined(PERL_GLOBAL_STRUCT)
 
 END
 
@@ -657,20 +645,8 @@ for $sym (sort keys %globvar) {
 
 print EM <<'END';
 
-END
-
-for $sym (sort keys %globvar) {
-    print EM embedvar($sym);
-}
-
-print EM <<'END';
-
 #endif /* PERL_GLOBAL_STRUCT */
 
-END
-
-print EM <<'END';
-
 #ifdef PERL_POLLUTE            /* disabled by default in 5.006 */
 
 END
@@ -684,7 +660,6 @@ print EM <<'END';
 #endif /* PERL_POLLUTE */
 END
 
-
 close(EM);
 
 unlink 'objXSUB.h';
index 39bf22b..3e83de1 100644 (file)
 
 /* (Doing namespace management portably in C is really gross.) */
 
-/* Put interpreter-specific symbols into a struct? */
+/*
+   The following combinations of MULTIPLICITY, USE_THREADS, PERL_OBJECT
+   and PERL_IMPLICIT_CONTEXT are supported:
+     1) none
+     2) MULTIPLICITY   # supported for compatibility
+     3) MULTIPLICITY && PERL_IMPLICIT_CONTEXT
+     4) USE_THREADS && PERL_IMPLICIT_CONTEXT
+     5) MULTIPLICITY && USE_THREADS && PERL_IMPLICIT_CONTEXT
+     6) PERL_OBJECT && PERL_IMPLICIT_CONTEXT
 
-#ifdef MULTIPLICITY
+   All other combinations of these flags are errors.
 
-#ifndef USE_THREADS
-/* If we do not have threads then per-thread vars are per-interpreter */
-
-#ifdef PERL_IMPLICIT_CONTEXT
-
-/* everything has an implicit context pointer */
-
-#define PL_Sv                  (my_perl->TSv)
-#define PL_Xpv                 (my_perl->TXpv)
-#define PL_av_fetch_sv         (my_perl->Tav_fetch_sv)
-#define PL_bodytarget          (my_perl->Tbodytarget)
-#define PL_bostr               (my_perl->Tbostr)
-#define PL_chopset             (my_perl->Tchopset)
-#define PL_colors              (my_perl->Tcolors)
-#define PL_colorset            (my_perl->Tcolorset)
-#define PL_curcop              (my_perl->Tcurcop)
-#define PL_curpad              (my_perl->Tcurpad)
-#define PL_curpm               (my_perl->Tcurpm)
-#define PL_curstack            (my_perl->Tcurstack)
-#define PL_curstackinfo                (my_perl->Tcurstackinfo)
-#define PL_curstash            (my_perl->Tcurstash)
-#define PL_defoutgv            (my_perl->Tdefoutgv)
-#define PL_defstash            (my_perl->Tdefstash)
-#define PL_delaymagic          (my_perl->Tdelaymagic)
-#define PL_dirty               (my_perl->Tdirty)
-#define PL_dumpindent          (my_perl->Tdumpindent)
-#define PL_extralen            (my_perl->Textralen)
-#define PL_firstgv             (my_perl->Tfirstgv)
-#define PL_formtarget          (my_perl->Tformtarget)
-#define PL_hv_fetch_ent_mh     (my_perl->Thv_fetch_ent_mh)
-#define PL_hv_fetch_sv         (my_perl->Thv_fetch_sv)
-#define PL_in_eval             (my_perl->Tin_eval)
-#define PL_last_in_gv          (my_perl->Tlast_in_gv)
-#define PL_lastgotoprobe       (my_perl->Tlastgotoprobe)
-#define PL_lastscream          (my_perl->Tlastscream)
-#define PL_localizing          (my_perl->Tlocalizing)
-#define PL_mainstack           (my_perl->Tmainstack)
-#define PL_markstack           (my_perl->Tmarkstack)
-#define PL_markstack_max       (my_perl->Tmarkstack_max)
-#define PL_markstack_ptr       (my_perl->Tmarkstack_ptr)
-#define PL_maxscream           (my_perl->Tmaxscream)
-#define PL_modcount            (my_perl->Tmodcount)
-#define PL_na                  (my_perl->Tna)
-#define PL_nrs                 (my_perl->Tnrs)
-#define PL_ofs                 (my_perl->Tofs)
-#define PL_ofslen              (my_perl->Tofslen)
-#define PL_op                  (my_perl->Top)
-#define PL_opsave              (my_perl->Topsave)
-#define PL_protect             (my_perl->Tprotect)
-#define PL_reg_call_cc         (my_perl->Treg_call_cc)
-#define PL_reg_curpm           (my_perl->Treg_curpm)
-#define PL_reg_eval_set                (my_perl->Treg_eval_set)
-#define PL_reg_flags           (my_perl->Treg_flags)
-#define PL_reg_ganch           (my_perl->Treg_ganch)
-#define PL_reg_leftiter                (my_perl->Treg_leftiter)
-#define PL_reg_magic           (my_perl->Treg_magic)
-#define PL_reg_maxiter         (my_perl->Treg_maxiter)
-#define PL_reg_oldcurpm                (my_perl->Treg_oldcurpm)
-#define PL_reg_oldpos          (my_perl->Treg_oldpos)
-#define PL_reg_oldsaved                (my_perl->Treg_oldsaved)
-#define PL_reg_oldsavedlen     (my_perl->Treg_oldsavedlen)
-#define PL_reg_poscache                (my_perl->Treg_poscache)
-#define PL_reg_poscache_size   (my_perl->Treg_poscache_size)
-#define PL_reg_re              (my_perl->Treg_re)
-#define PL_reg_start_tmp       (my_perl->Treg_start_tmp)
-#define PL_reg_start_tmpl      (my_perl->Treg_start_tmpl)
-#define PL_reg_starttry                (my_perl->Treg_starttry)
-#define PL_reg_sv              (my_perl->Treg_sv)
-#define PL_reg_whilem_seen     (my_perl->Treg_whilem_seen)
-#define PL_regbol              (my_perl->Tregbol)
-#define PL_regcc               (my_perl->Tregcc)
-#define PL_regcode             (my_perl->Tregcode)
-#define PL_regcomp_parse       (my_perl->Tregcomp_parse)
-#define PL_regcomp_rx          (my_perl->Tregcomp_rx)
-#define PL_regcompp            (my_perl->Tregcompp)
-#define PL_regdata             (my_perl->Tregdata)
-#define PL_regdummy            (my_perl->Tregdummy)
-#define PL_regendp             (my_perl->Tregendp)
-#define PL_regeol              (my_perl->Tregeol)
-#define PL_regexecp            (my_perl->Tregexecp)
-#define PL_regflags            (my_perl->Tregflags)
-#define PL_regfree             (my_perl->Tregfree)
-#define PL_regindent           (my_perl->Tregindent)
-#define PL_reginput            (my_perl->Treginput)
-#define PL_regint_start                (my_perl->Tregint_start)
-#define PL_regint_string       (my_perl->Tregint_string)
-#define PL_reginterp_cnt       (my_perl->Treginterp_cnt)
-#define PL_reglastparen                (my_perl->Treglastparen)
-#define PL_regnarrate          (my_perl->Tregnarrate)
-#define PL_regnaughty          (my_perl->Tregnaughty)
-#define PL_regnpar             (my_perl->Tregnpar)
-#define PL_regprecomp          (my_perl->Tregprecomp)
-#define PL_regprev             (my_perl->Tregprev)
-#define PL_regprogram          (my_perl->Tregprogram)
-#define PL_regsawback          (my_perl->Tregsawback)
-#define PL_regseen             (my_perl->Tregseen)
-#define PL_regsize             (my_perl->Tregsize)
-#define PL_regstartp           (my_perl->Tregstartp)
-#define PL_regtill             (my_perl->Tregtill)
-#define PL_regxend             (my_perl->Tregxend)
-#define PL_restartop           (my_perl->Trestartop)
-#define PL_retstack            (my_perl->Tretstack)
-#define PL_retstack_ix         (my_perl->Tretstack_ix)
-#define PL_retstack_max                (my_perl->Tretstack_max)
-#define PL_rs                  (my_perl->Trs)
-#define PL_savestack           (my_perl->Tsavestack)
-#define PL_savestack_ix                (my_perl->Tsavestack_ix)
-#define PL_savestack_max       (my_perl->Tsavestack_max)
-#define PL_scopestack          (my_perl->Tscopestack)
-#define PL_scopestack_ix       (my_perl->Tscopestack_ix)
-#define PL_scopestack_max      (my_perl->Tscopestack_max)
-#define PL_screamfirst         (my_perl->Tscreamfirst)
-#define PL_screamnext          (my_perl->Tscreamnext)
-#define PL_secondgv            (my_perl->Tsecondgv)
-#define PL_seen_evals          (my_perl->Tseen_evals)
-#define PL_seen_zerolen                (my_perl->Tseen_zerolen)
-#define PL_sortcop             (my_perl->Tsortcop)
-#define PL_sortcxix            (my_perl->Tsortcxix)
-#define PL_sortstash           (my_perl->Tsortstash)
-#define PL_stack_base          (my_perl->Tstack_base)
-#define PL_stack_max           (my_perl->Tstack_max)
-#define PL_stack_sp            (my_perl->Tstack_sp)
-#define PL_start_env           (my_perl->Tstart_env)
-#define PL_statbuf             (my_perl->Tstatbuf)
-#define PL_statcache           (my_perl->Tstatcache)
-#define PL_statgv              (my_perl->Tstatgv)
-#define PL_statname            (my_perl->Tstatname)
-#define PL_tainted             (my_perl->Ttainted)
-#define PL_timesbuf            (my_perl->Ttimesbuf)
-#define PL_tmps_floor          (my_perl->Ttmps_floor)
-#define PL_tmps_ix             (my_perl->Ttmps_ix)
-#define PL_tmps_max            (my_perl->Ttmps_max)
-#define PL_tmps_stack          (my_perl->Ttmps_stack)
-#define PL_top_env             (my_perl->Ttop_env)
-#define PL_toptarget           (my_perl->Ttoptarget)
-#define PL_watchaddr           (my_perl->Twatchaddr)
-#define PL_watchok             (my_perl->Twatchok)
+   #3, #4, #5, and #6 are supported directly, while #2 is a special
+   case of #3 (supported by redefining vTHX appropriately).
+*/
 
-#else /* !PERL_IMPLICIT_CONTEXT */
+#if defined(MULTIPLICITY)
+/* cases 2, 3 and 5 above */
 
-/* traditional MULTIPLICITY (intepreter is in a global) */
+#  if defined(PERL_IMPLICIT_CONTEXT)
+#    define vTHX       aTHX
+#  else
+#    define vTHX       PERL_GET_INTERP
+#  endif
 
-#define PL_Sv                  (PERL_GET_INTERP->TSv)
-#define PL_Xpv                 (PERL_GET_INTERP->TXpv)
-#define PL_av_fetch_sv         (PERL_GET_INTERP->Tav_fetch_sv)
-#define PL_bodytarget          (PERL_GET_INTERP->Tbodytarget)
-#define PL_bostr               (PERL_GET_INTERP->Tbostr)
-#define PL_chopset             (PERL_GET_INTERP->Tchopset)
-#define PL_colors              (PERL_GET_INTERP->Tcolors)
-#define PL_colorset            (PERL_GET_INTERP->Tcolorset)
-#define PL_curcop              (PERL_GET_INTERP->Tcurcop)
-#define PL_curpad              (PERL_GET_INTERP->Tcurpad)
-#define PL_curpm               (PERL_GET_INTERP->Tcurpm)
-#define PL_curstack            (PERL_GET_INTERP->Tcurstack)
-#define PL_curstackinfo                (PERL_GET_INTERP->Tcurstackinfo)
-#define PL_curstash            (PERL_GET_INTERP->Tcurstash)
-#define PL_defoutgv            (PERL_GET_INTERP->Tdefoutgv)
-#define PL_defstash            (PERL_GET_INTERP->Tdefstash)
-#define PL_delaymagic          (PERL_GET_INTERP->Tdelaymagic)
-#define PL_dirty               (PERL_GET_INTERP->Tdirty)
-#define PL_dumpindent          (PERL_GET_INTERP->Tdumpindent)
-#define PL_extralen            (PERL_GET_INTERP->Textralen)
-#define PL_firstgv             (PERL_GET_INTERP->Tfirstgv)
-#define PL_formtarget          (PERL_GET_INTERP->Tformtarget)
-#define PL_hv_fetch_ent_mh     (PERL_GET_INTERP->Thv_fetch_ent_mh)
-#define PL_hv_fetch_sv         (PERL_GET_INTERP->Thv_fetch_sv)
-#define PL_in_eval             (PERL_GET_INTERP->Tin_eval)
-#define PL_last_in_gv          (PERL_GET_INTERP->Tlast_in_gv)
-#define PL_lastgotoprobe       (PERL_GET_INTERP->Tlastgotoprobe)
-#define PL_lastscream          (PERL_GET_INTERP->Tlastscream)
-#define PL_localizing          (PERL_GET_INTERP->Tlocalizing)
-#define PL_mainstack           (PERL_GET_INTERP->Tmainstack)
-#define PL_markstack           (PERL_GET_INTERP->Tmarkstack)
-#define PL_markstack_max       (PERL_GET_INTERP->Tmarkstack_max)
-#define PL_markstack_ptr       (PERL_GET_INTERP->Tmarkstack_ptr)
-#define PL_maxscream           (PERL_GET_INTERP->Tmaxscream)
-#define PL_modcount            (PERL_GET_INTERP->Tmodcount)
-#define PL_na                  (PERL_GET_INTERP->Tna)
-#define PL_nrs                 (PERL_GET_INTERP->Tnrs)
-#define PL_ofs                 (PERL_GET_INTERP->Tofs)
-#define PL_ofslen              (PERL_GET_INTERP->Tofslen)
-#define PL_op                  (PERL_GET_INTERP->Top)
-#define PL_opsave              (PERL_GET_INTERP->Topsave)
-#define PL_protect             (PERL_GET_INTERP->Tprotect)
-#define PL_reg_call_cc         (PERL_GET_INTERP->Treg_call_cc)
-#define PL_reg_curpm           (PERL_GET_INTERP->Treg_curpm)
-#define PL_reg_eval_set                (PERL_GET_INTERP->Treg_eval_set)
-#define PL_reg_flags           (PERL_GET_INTERP->Treg_flags)
-#define PL_reg_ganch           (PERL_GET_INTERP->Treg_ganch)
-#define PL_reg_leftiter                (PERL_GET_INTERP->Treg_leftiter)
-#define PL_reg_magic           (PERL_GET_INTERP->Treg_magic)
-#define PL_reg_maxiter         (PERL_GET_INTERP->Treg_maxiter)
-#define PL_reg_oldcurpm                (PERL_GET_INTERP->Treg_oldcurpm)
-#define PL_reg_oldpos          (PERL_GET_INTERP->Treg_oldpos)
-#define PL_reg_oldsaved                (PERL_GET_INTERP->Treg_oldsaved)
-#define PL_reg_oldsavedlen     (PERL_GET_INTERP->Treg_oldsavedlen)
-#define PL_reg_poscache                (PERL_GET_INTERP->Treg_poscache)
-#define PL_reg_poscache_size   (PERL_GET_INTERP->Treg_poscache_size)
-#define PL_reg_re              (PERL_GET_INTERP->Treg_re)
-#define PL_reg_start_tmp       (PERL_GET_INTERP->Treg_start_tmp)
-#define PL_reg_start_tmpl      (PERL_GET_INTERP->Treg_start_tmpl)
-#define PL_reg_starttry                (PERL_GET_INTERP->Treg_starttry)
-#define PL_reg_sv              (PERL_GET_INTERP->Treg_sv)
-#define PL_reg_whilem_seen     (PERL_GET_INTERP->Treg_whilem_seen)
-#define PL_regbol              (PERL_GET_INTERP->Tregbol)
-#define PL_regcc               (PERL_GET_INTERP->Tregcc)
-#define PL_regcode             (PERL_GET_INTERP->Tregcode)
-#define PL_regcomp_parse       (PERL_GET_INTERP->Tregcomp_parse)
-#define PL_regcomp_rx          (PERL_GET_INTERP->Tregcomp_rx)
-#define PL_regcompp            (PERL_GET_INTERP->Tregcompp)
-#define PL_regdata             (PERL_GET_INTERP->Tregdata)
-#define PL_regdummy            (PERL_GET_INTERP->Tregdummy)
-#define PL_regendp             (PERL_GET_INTERP->Tregendp)
-#define PL_regeol              (PERL_GET_INTERP->Tregeol)
-#define PL_regexecp            (PERL_GET_INTERP->Tregexecp)
-#define PL_regflags            (PERL_GET_INTERP->Tregflags)
-#define PL_regfree             (PERL_GET_INTERP->Tregfree)
-#define PL_regindent           (PERL_GET_INTERP->Tregindent)
-#define PL_reginput            (PERL_GET_INTERP->Treginput)
-#define PL_regint_start                (PERL_GET_INTERP->Tregint_start)
-#define PL_regint_string       (PERL_GET_INTERP->Tregint_string)
-#define PL_reginterp_cnt       (PERL_GET_INTERP->Treginterp_cnt)
-#define PL_reglastparen                (PERL_GET_INTERP->Treglastparen)
-#define PL_regnarrate          (PERL_GET_INTERP->Tregnarrate)
-#define PL_regnaughty          (PERL_GET_INTERP->Tregnaughty)
-#define PL_regnpar             (PERL_GET_INTERP->Tregnpar)
-#define PL_regprecomp          (PERL_GET_INTERP->Tregprecomp)
-#define PL_regprev             (PERL_GET_INTERP->Tregprev)
-#define PL_regprogram          (PERL_GET_INTERP->Tregprogram)
-#define PL_regsawback          (PERL_GET_INTERP->Tregsawback)
-#define PL_regseen             (PERL_GET_INTERP->Tregseen)
-#define PL_regsize             (PERL_GET_INTERP->Tregsize)
-#define PL_regstartp           (PERL_GET_INTERP->Tregstartp)
-#define PL_regtill             (PERL_GET_INTERP->Tregtill)
-#define PL_regxend             (PERL_GET_INTERP->Tregxend)
-#define PL_restartop           (PERL_GET_INTERP->Trestartop)
-#define PL_retstack            (PERL_GET_INTERP->Tretstack)
-#define PL_retstack_ix         (PERL_GET_INTERP->Tretstack_ix)
-#define PL_retstack_max                (PERL_GET_INTERP->Tretstack_max)
-#define PL_rs                  (PERL_GET_INTERP->Trs)
-#define PL_savestack           (PERL_GET_INTERP->Tsavestack)
-#define PL_savestack_ix                (PERL_GET_INTERP->Tsavestack_ix)
-#define PL_savestack_max       (PERL_GET_INTERP->Tsavestack_max)
-#define PL_scopestack          (PERL_GET_INTERP->Tscopestack)
-#define PL_scopestack_ix       (PERL_GET_INTERP->Tscopestack_ix)
-#define PL_scopestack_max      (PERL_GET_INTERP->Tscopestack_max)
-#define PL_screamfirst         (PERL_GET_INTERP->Tscreamfirst)
-#define PL_screamnext          (PERL_GET_INTERP->Tscreamnext)
-#define PL_secondgv            (PERL_GET_INTERP->Tsecondgv)
-#define PL_seen_evals          (PERL_GET_INTERP->Tseen_evals)
-#define PL_seen_zerolen                (PERL_GET_INTERP->Tseen_zerolen)
-#define PL_sortcop             (PERL_GET_INTERP->Tsortcop)
-#define PL_sortcxix            (PERL_GET_INTERP->Tsortcxix)
-#define PL_sortstash           (PERL_GET_INTERP->Tsortstash)
-#define PL_stack_base          (PERL_GET_INTERP->Tstack_base)
-#define PL_stack_max           (PERL_GET_INTERP->Tstack_max)
-#define PL_stack_sp            (PERL_GET_INTERP->Tstack_sp)
-#define PL_start_env           (PERL_GET_INTERP->Tstart_env)
-#define PL_statbuf             (PERL_GET_INTERP->Tstatbuf)
-#define PL_statcache           (PERL_GET_INTERP->Tstatcache)
-#define PL_statgv              (PERL_GET_INTERP->Tstatgv)
-#define PL_statname            (PERL_GET_INTERP->Tstatname)
-#define PL_tainted             (PERL_GET_INTERP->Ttainted)
-#define PL_timesbuf            (PERL_GET_INTERP->Ttimesbuf)
-#define PL_tmps_floor          (PERL_GET_INTERP->Ttmps_floor)
-#define PL_tmps_ix             (PERL_GET_INTERP->Ttmps_ix)
-#define PL_tmps_max            (PERL_GET_INTERP->Ttmps_max)
-#define PL_tmps_stack          (PERL_GET_INTERP->Ttmps_stack)
-#define PL_top_env             (PERL_GET_INTERP->Ttop_env)
-#define PL_toptarget           (PERL_GET_INTERP->Ttoptarget)
-#define PL_watchaddr           (PERL_GET_INTERP->Twatchaddr)
-#define PL_watchok             (PERL_GET_INTERP->Twatchok)
+#define PL_Sv                  (vTHX->TSv)
+#define PL_Xpv                 (vTHX->TXpv)
+#define PL_av_fetch_sv         (vTHX->Tav_fetch_sv)
+#define PL_bodytarget          (vTHX->Tbodytarget)
+#define PL_bostr               (vTHX->Tbostr)
+#define PL_chopset             (vTHX->Tchopset)
+#define PL_colors              (vTHX->Tcolors)
+#define PL_colorset            (vTHX->Tcolorset)
+#define PL_curcop              (vTHX->Tcurcop)
+#define PL_curpad              (vTHX->Tcurpad)
+#define PL_curpm               (vTHX->Tcurpm)
+#define PL_curstack            (vTHX->Tcurstack)
+#define PL_curstackinfo                (vTHX->Tcurstackinfo)
+#define PL_curstash            (vTHX->Tcurstash)
+#define PL_defoutgv            (vTHX->Tdefoutgv)
+#define PL_defstash            (vTHX->Tdefstash)
+#define PL_delaymagic          (vTHX->Tdelaymagic)
+#define PL_dirty               (vTHX->Tdirty)
+#define PL_dumpindent          (vTHX->Tdumpindent)
+#define PL_extralen            (vTHX->Textralen)
+#define PL_firstgv             (vTHX->Tfirstgv)
+#define PL_formtarget          (vTHX->Tformtarget)
+#define PL_hv_fetch_ent_mh     (vTHX->Thv_fetch_ent_mh)
+#define PL_hv_fetch_sv         (vTHX->Thv_fetch_sv)
+#define PL_in_eval             (vTHX->Tin_eval)
+#define PL_last_in_gv          (vTHX->Tlast_in_gv)
+#define PL_lastgotoprobe       (vTHX->Tlastgotoprobe)
+#define PL_lastscream          (vTHX->Tlastscream)
+#define PL_localizing          (vTHX->Tlocalizing)
+#define PL_mainstack           (vTHX->Tmainstack)
+#define PL_markstack           (vTHX->Tmarkstack)
+#define PL_markstack_max       (vTHX->Tmarkstack_max)
+#define PL_markstack_ptr       (vTHX->Tmarkstack_ptr)
+#define PL_maxscream           (vTHX->Tmaxscream)
+#define PL_modcount            (vTHX->Tmodcount)
+#define PL_na                  (vTHX->Tna)
+#define PL_nrs                 (vTHX->Tnrs)
+#define PL_ofs                 (vTHX->Tofs)
+#define PL_ofslen              (vTHX->Tofslen)
+#define PL_op                  (vTHX->Top)
+#define PL_opsave              (vTHX->Topsave)
+#define PL_protect             (vTHX->Tprotect)
+#define PL_reg_call_cc         (vTHX->Treg_call_cc)
+#define PL_reg_curpm           (vTHX->Treg_curpm)
+#define PL_reg_eval_set                (vTHX->Treg_eval_set)
+#define PL_reg_flags           (vTHX->Treg_flags)
+#define PL_reg_ganch           (vTHX->Treg_ganch)
+#define PL_reg_leftiter                (vTHX->Treg_leftiter)
+#define PL_reg_magic           (vTHX->Treg_magic)
+#define PL_reg_maxiter         (vTHX->Treg_maxiter)
+#define PL_reg_oldcurpm                (vTHX->Treg_oldcurpm)
+#define PL_reg_oldpos          (vTHX->Treg_oldpos)
+#define PL_reg_oldsaved                (vTHX->Treg_oldsaved)
+#define PL_reg_oldsavedlen     (vTHX->Treg_oldsavedlen)
+#define PL_reg_poscache                (vTHX->Treg_poscache)
+#define PL_reg_poscache_size   (vTHX->Treg_poscache_size)
+#define PL_reg_re              (vTHX->Treg_re)
+#define PL_reg_start_tmp       (vTHX->Treg_start_tmp)
+#define PL_reg_start_tmpl      (vTHX->Treg_start_tmpl)
+#define PL_reg_starttry                (vTHX->Treg_starttry)
+#define PL_reg_sv              (vTHX->Treg_sv)
+#define PL_reg_whilem_seen     (vTHX->Treg_whilem_seen)
+#define PL_regbol              (vTHX->Tregbol)
+#define PL_regcc               (vTHX->Tregcc)
+#define PL_regcode             (vTHX->Tregcode)
+#define PL_regcomp_parse       (vTHX->Tregcomp_parse)
+#define PL_regcomp_rx          (vTHX->Tregcomp_rx)
+#define PL_regcompp            (vTHX->Tregcompp)
+#define PL_regdata             (vTHX->Tregdata)
+#define PL_regdummy            (vTHX->Tregdummy)
+#define PL_regendp             (vTHX->Tregendp)
+#define PL_regeol              (vTHX->Tregeol)
+#define PL_regexecp            (vTHX->Tregexecp)
+#define PL_regflags            (vTHX->Tregflags)
+#define PL_regfree             (vTHX->Tregfree)
+#define PL_regindent           (vTHX->Tregindent)
+#define PL_reginput            (vTHX->Treginput)
+#define PL_regint_start                (vTHX->Tregint_start)
+#define PL_regint_string       (vTHX->Tregint_string)
+#define PL_reginterp_cnt       (vTHX->Treginterp_cnt)
+#define PL_reglastparen                (vTHX->Treglastparen)
+#define PL_regnarrate          (vTHX->Tregnarrate)
+#define PL_regnaughty          (vTHX->Tregnaughty)
+#define PL_regnpar             (vTHX->Tregnpar)
+#define PL_regprecomp          (vTHX->Tregprecomp)
+#define PL_regprev             (vTHX->Tregprev)
+#define PL_regprogram          (vTHX->Tregprogram)
+#define PL_regsawback          (vTHX->Tregsawback)
+#define PL_regseen             (vTHX->Tregseen)
+#define PL_regsize             (vTHX->Tregsize)
+#define PL_regstartp           (vTHX->Tregstartp)
+#define PL_regtill             (vTHX->Tregtill)
+#define PL_regxend             (vTHX->Tregxend)
+#define PL_restartop           (vTHX->Trestartop)
+#define PL_retstack            (vTHX->Tretstack)
+#define PL_retstack_ix         (vTHX->Tretstack_ix)
+#define PL_retstack_max                (vTHX->Tretstack_max)
+#define PL_rs                  (vTHX->Trs)
+#define PL_savestack           (vTHX->Tsavestack)
+#define PL_savestack_ix                (vTHX->Tsavestack_ix)
+#define PL_savestack_max       (vTHX->Tsavestack_max)
+#define PL_scopestack          (vTHX->Tscopestack)
+#define PL_scopestack_ix       (vTHX->Tscopestack_ix)
+#define PL_scopestack_max      (vTHX->Tscopestack_max)
+#define PL_screamfirst         (vTHX->Tscreamfirst)
+#define PL_screamnext          (vTHX->Tscreamnext)
+#define PL_secondgv            (vTHX->Tsecondgv)
+#define PL_seen_evals          (vTHX->Tseen_evals)
+#define PL_seen_zerolen                (vTHX->Tseen_zerolen)
+#define PL_sortcop             (vTHX->Tsortcop)
+#define PL_sortcxix            (vTHX->Tsortcxix)
+#define PL_sortstash           (vTHX->Tsortstash)
+#define PL_stack_base          (vTHX->Tstack_base)
+#define PL_stack_max           (vTHX->Tstack_max)
+#define PL_stack_sp            (vTHX->Tstack_sp)
+#define PL_start_env           (vTHX->Tstart_env)
+#define PL_statbuf             (vTHX->Tstatbuf)
+#define PL_statcache           (vTHX->Tstatcache)
+#define PL_statgv              (vTHX->Tstatgv)
+#define PL_statname            (vTHX->Tstatname)
+#define PL_tainted             (vTHX->Ttainted)
+#define PL_timesbuf            (vTHX->Ttimesbuf)
+#define PL_tmps_floor          (vTHX->Ttmps_floor)
+#define PL_tmps_ix             (vTHX->Ttmps_ix)
+#define PL_tmps_max            (vTHX->Ttmps_max)
+#define PL_tmps_stack          (vTHX->Ttmps_stack)
+#define PL_top_env             (vTHX->Ttop_env)
+#define PL_toptarget           (vTHX->Ttoptarget)
+#define PL_watchaddr           (vTHX->Twatchaddr)
+#define PL_watchok             (vTHX->Twatchok)
 
-#endif /* !PERL_IMPLICIT_CONTEXT */
-#endif /* !USE_THREADS */
+#  if defined(PERL_OBJECT)
+#    include "error: PERL_OBJECT + MULTIPLICITY don't go together"
+#  endif
 
-/* These are always per-interpreter if there is more than one */
+#  if defined(USE_THREADS)
+/* case 5 above */
 
 #define PL_Argv                        (PERL_GET_INTERP->IArgv)
 #define PL_Cmd                 (PERL_GET_INTERP->ICmd)
 #define PL_yynerrs             (PERL_GET_INTERP->Iyynerrs)
 #define PL_yyval               (PERL_GET_INTERP->Iyyval)
 
+#  else                /* !USE_THREADS */
+/* cases 2 and 3 above */
+
+#define PL_Argv                        (vTHX->IArgv)
+#define PL_Cmd                 (vTHX->ICmd)
+#define PL_DBcv                        (vTHX->IDBcv)
+#define PL_DBgv                        (vTHX->IDBgv)
+#define PL_DBline              (vTHX->IDBline)
+#define PL_DBsignal            (vTHX->IDBsignal)
+#define PL_DBsingle            (vTHX->IDBsingle)
+#define PL_DBsub               (vTHX->IDBsub)
+#define PL_DBtrace             (vTHX->IDBtrace)
+#define PL_Dir                 (vTHX->IDir)
+#define PL_Env                 (vTHX->IEnv)
+#define PL_LIO                 (vTHX->ILIO)
+#define PL_Mem                 (vTHX->IMem)
+#define PL_Proc                        (vTHX->IProc)
+#define PL_Sock                        (vTHX->ISock)
+#define PL_StdIO               (vTHX->IStdIO)
+#define PL_amagic_generation   (vTHX->Iamagic_generation)
+#define PL_ampergv             (vTHX->Iampergv)
+#define PL_an                  (vTHX->Ian)
+#define PL_archpat_auto                (vTHX->Iarchpat_auto)
+#define PL_argvgv              (vTHX->Iargvgv)
+#define PL_argvoutgv           (vTHX->Iargvoutgv)
+#define PL_basetime            (vTHX->Ibasetime)
+#define PL_beginav             (vTHX->Ibeginav)
+#define PL_bitcount            (vTHX->Ibitcount)
+#define PL_bufend              (vTHX->Ibufend)
+#define PL_bufptr              (vTHX->Ibufptr)
+#define PL_cddir               (vTHX->Icddir)
+#define PL_collation_ix                (vTHX->Icollation_ix)
+#define PL_collation_name      (vTHX->Icollation_name)
+#define PL_collation_standard  (vTHX->Icollation_standard)
+#define PL_collxfrm_base       (vTHX->Icollxfrm_base)
+#define PL_collxfrm_mult       (vTHX->Icollxfrm_mult)
+#define PL_compcv              (vTHX->Icompcv)
+#define PL_compiling           (vTHX->Icompiling)
+#define PL_comppad             (vTHX->Icomppad)
+#define PL_comppad_name                (vTHX->Icomppad_name)
+#define PL_comppad_name_fill   (vTHX->Icomppad_name_fill)
+#define PL_comppad_name_floor  (vTHX->Icomppad_name_floor)
+#define PL_cop_seqmax          (vTHX->Icop_seqmax)
+#define PL_copline             (vTHX->Icopline)
+#define PL_cred_mutex          (vTHX->Icred_mutex)
+#define PL_cryptseen           (vTHX->Icryptseen)
+#define PL_cshlen              (vTHX->Icshlen)
+#define PL_cshname             (vTHX->Icshname)
+#define PL_curcopdb            (vTHX->Icurcopdb)
+#define PL_curstname           (vTHX->Icurstname)
+#define PL_curthr              (vTHX->Icurthr)
+#define PL_dbargs              (vTHX->Idbargs)
+#define PL_debdelim            (vTHX->Idebdelim)
+#define PL_debname             (vTHX->Idebname)
+#define PL_debstash            (vTHX->Idebstash)
+#define PL_debug               (vTHX->Idebug)
+#define PL_defgv               (vTHX->Idefgv)
+#define PL_diehook             (vTHX->Idiehook)
+#define PL_dlevel              (vTHX->Idlevel)
+#define PL_dlmax               (vTHX->Idlmax)
+#define PL_doextract           (vTHX->Idoextract)
+#define PL_doswitches          (vTHX->Idoswitches)
+#define PL_dowarn              (vTHX->Idowarn)
+#define PL_e_script            (vTHX->Ie_script)
+#define PL_efloatbuf           (vTHX->Iefloatbuf)
+#define PL_efloatsize          (vTHX->Iefloatsize)
+#define PL_egid                        (vTHX->Iegid)
+#define PL_endav               (vTHX->Iendav)
+#define PL_envgv               (vTHX->Ienvgv)
+#define PL_errgv               (vTHX->Ierrgv)
+#define PL_error_count         (vTHX->Ierror_count)
+#define PL_euid                        (vTHX->Ieuid)
+#define PL_eval_cond           (vTHX->Ieval_cond)
+#define PL_eval_mutex          (vTHX->Ieval_mutex)
+#define PL_eval_owner          (vTHX->Ieval_owner)
+#define PL_eval_root           (vTHX->Ieval_root)
+#define PL_eval_start          (vTHX->Ieval_start)
+#define PL_evalseq             (vTHX->Ievalseq)
+#define PL_exitlist            (vTHX->Iexitlist)
+#define PL_exitlistlen         (vTHX->Iexitlistlen)
+#define PL_expect              (vTHX->Iexpect)
+#define PL_fdpid               (vTHX->Ifdpid)
+#define PL_filemode            (vTHX->Ifilemode)
+#define PL_filter_debug                (vTHX->Ifilter_debug)
+#define PL_forkprocess         (vTHX->Iforkprocess)
+#define PL_formfeed            (vTHX->Iformfeed)
+#define PL_generation          (vTHX->Igeneration)
+#define PL_gensym              (vTHX->Igensym)
+#define PL_gid                 (vTHX->Igid)
+#define PL_glob_index          (vTHX->Iglob_index)
+#define PL_globalstash         (vTHX->Iglobalstash)
+#define PL_he_root             (vTHX->Ihe_root)
+#define PL_hintgv              (vTHX->Ihintgv)
+#define PL_hints               (vTHX->Ihints)
+#define PL_in_clean_all                (vTHX->Iin_clean_all)
+#define PL_in_clean_objs       (vTHX->Iin_clean_objs)
+#define PL_in_my               (vTHX->Iin_my)
+#define PL_in_my_stash         (vTHX->Iin_my_stash)
+#define PL_incgv               (vTHX->Iincgv)
+#define PL_initav              (vTHX->Iinitav)
+#define PL_inplace             (vTHX->Iinplace)
+#define PL_last_lop            (vTHX->Ilast_lop)
+#define PL_last_lop_op         (vTHX->Ilast_lop_op)
+#define PL_last_swash_hv       (vTHX->Ilast_swash_hv)
+#define PL_last_swash_key      (vTHX->Ilast_swash_key)
+#define PL_last_swash_klen     (vTHX->Ilast_swash_klen)
+#define PL_last_swash_slen     (vTHX->Ilast_swash_slen)
+#define PL_last_swash_tmps     (vTHX->Ilast_swash_tmps)
+#define PL_last_uni            (vTHX->Ilast_uni)
+#define PL_lastfd              (vTHX->Ilastfd)
+#define PL_lastsize            (vTHX->Ilastsize)
+#define PL_lastspbase          (vTHX->Ilastspbase)
+#define PL_laststatval         (vTHX->Ilaststatval)
+#define PL_laststype           (vTHX->Ilaststype)
+#define PL_leftgv              (vTHX->Ileftgv)
+#define PL_lex_brackets                (vTHX->Ilex_brackets)
+#define PL_lex_brackstack      (vTHX->Ilex_brackstack)
+#define PL_lex_casemods                (vTHX->Ilex_casemods)
+#define PL_lex_casestack       (vTHX->Ilex_casestack)
+#define PL_lex_defer           (vTHX->Ilex_defer)
+#define PL_lex_dojoin          (vTHX->Ilex_dojoin)
+#define PL_lex_expect          (vTHX->Ilex_expect)
+#define PL_lex_fakebrack       (vTHX->Ilex_fakebrack)
+#define PL_lex_formbrack       (vTHX->Ilex_formbrack)
+#define PL_lex_inpat           (vTHX->Ilex_inpat)
+#define PL_lex_inwhat          (vTHX->Ilex_inwhat)
+#define PL_lex_op              (vTHX->Ilex_op)
+#define PL_lex_repl            (vTHX->Ilex_repl)
+#define PL_lex_starts          (vTHX->Ilex_starts)
+#define PL_lex_state           (vTHX->Ilex_state)
+#define PL_lex_stuff           (vTHX->Ilex_stuff)
+#define PL_lineary             (vTHX->Ilineary)
+#define PL_linestart           (vTHX->Ilinestart)
+#define PL_linestr             (vTHX->Ilinestr)
+#define PL_localpatches                (vTHX->Ilocalpatches)
+#define PL_main_cv             (vTHX->Imain_cv)
+#define PL_main_root           (vTHX->Imain_root)
+#define PL_main_start          (vTHX->Imain_start)
+#define PL_malloc_mutex                (vTHX->Imalloc_mutex)
+#define PL_max_intro_pending   (vTHX->Imax_intro_pending)
+#define PL_maxo                        (vTHX->Imaxo)
+#define PL_maxsysfd            (vTHX->Imaxsysfd)
+#define PL_mess_sv             (vTHX->Imess_sv)
+#define PL_min_intro_pending   (vTHX->Imin_intro_pending)
+#define PL_minus_F             (vTHX->Iminus_F)
+#define PL_minus_a             (vTHX->Iminus_a)
+#define PL_minus_c             (vTHX->Iminus_c)
+#define PL_minus_l             (vTHX->Iminus_l)
+#define PL_minus_n             (vTHX->Iminus_n)
+#define PL_minus_p             (vTHX->Iminus_p)
+#define PL_modglobal           (vTHX->Imodglobal)
+#define PL_multi_close         (vTHX->Imulti_close)
+#define PL_multi_end           (vTHX->Imulti_end)
+#define PL_multi_open          (vTHX->Imulti_open)
+#define PL_multi_start         (vTHX->Imulti_start)
+#define PL_multiline           (vTHX->Imultiline)
+#define PL_mystrk              (vTHX->Imystrk)
+#define PL_nexttoke            (vTHX->Inexttoke)
+#define PL_nexttype            (vTHX->Inexttype)
+#define PL_nextval             (vTHX->Inextval)
+#define PL_nice_chunk          (vTHX->Inice_chunk)
+#define PL_nice_chunk_size     (vTHX->Inice_chunk_size)
+#define PL_nomemok             (vTHX->Inomemok)
+#define PL_nthreads            (vTHX->Inthreads)
+#define PL_nthreads_cond       (vTHX->Inthreads_cond)
+#define PL_numeric_local       (vTHX->Inumeric_local)
+#define PL_numeric_name                (vTHX->Inumeric_name)
+#define PL_numeric_radix       (vTHX->Inumeric_radix)
+#define PL_numeric_standard    (vTHX->Inumeric_standard)
+#define PL_ofmt                        (vTHX->Iofmt)
+#define PL_oldbufptr           (vTHX->Ioldbufptr)
+#define PL_oldlastpm           (vTHX->Ioldlastpm)
+#define PL_oldname             (vTHX->Ioldname)
+#define PL_oldoldbufptr                (vTHX->Ioldoldbufptr)
+#define PL_op_mask             (vTHX->Iop_mask)
+#define PL_op_seqmax           (vTHX->Iop_seqmax)
+#define PL_origalen            (vTHX->Iorigalen)
+#define PL_origargc            (vTHX->Iorigargc)
+#define PL_origargv            (vTHX->Iorigargv)
+#define PL_origenviron         (vTHX->Iorigenviron)
+#define PL_origfilename                (vTHX->Iorigfilename)
+#define PL_ors                 (vTHX->Iors)
+#define PL_orslen              (vTHX->Iorslen)
+#define PL_osname              (vTHX->Iosname)
+#define PL_pad_reset_pending   (vTHX->Ipad_reset_pending)
+#define PL_padix               (vTHX->Ipadix)
+#define PL_padix_floor         (vTHX->Ipadix_floor)
+#define PL_parsehook           (vTHX->Iparsehook)
+#define PL_patchlevel          (vTHX->Ipatchlevel)
+#define PL_pending_ident       (vTHX->Ipending_ident)
+#define PL_perl_destruct_level (vTHX->Iperl_destruct_level)
+#define PL_perldb              (vTHX->Iperldb)
+#define PL_pidstatus           (vTHX->Ipidstatus)
+#define PL_preambleav          (vTHX->Ipreambleav)
+#define PL_preambled           (vTHX->Ipreambled)
+#define PL_preprocess          (vTHX->Ipreprocess)
+#define PL_profiledata         (vTHX->Iprofiledata)
+#define PL_replgv              (vTHX->Ireplgv)
+#define PL_rightgv             (vTHX->Irightgv)
+#define PL_rsfp                        (vTHX->Irsfp)
+#define PL_rsfp_filters                (vTHX->Irsfp_filters)
+#define PL_runops              (vTHX->Irunops)
+#define PL_sawampersand                (vTHX->Isawampersand)
+#define PL_sawstudy            (vTHX->Isawstudy)
+#define PL_sawvec              (vTHX->Isawvec)
+#define PL_sh_path             (vTHX->Ish_path)
+#define PL_siggv               (vTHX->Isiggv)
+#define PL_sighandlerp         (vTHX->Isighandlerp)
+#define PL_splitstr            (vTHX->Isplitstr)
+#define PL_srand_called                (vTHX->Isrand_called)
+#define PL_statusvalue         (vTHX->Istatusvalue)
+#define PL_statusvalue_vms     (vTHX->Istatusvalue_vms)
+#define PL_stdingv             (vTHX->Istdingv)
+#define PL_strchop             (vTHX->Istrchop)
+#define PL_strtab              (vTHX->Istrtab)
+#define PL_strtab_mutex                (vTHX->Istrtab_mutex)
+#define PL_sub_generation      (vTHX->Isub_generation)
+#define PL_sublex_info         (vTHX->Isublex_info)
+#define PL_subline             (vTHX->Isubline)
+#define PL_subname             (vTHX->Isubname)
+#define PL_sv_arenaroot                (vTHX->Isv_arenaroot)
+#define PL_sv_count            (vTHX->Isv_count)
+#define PL_sv_mutex            (vTHX->Isv_mutex)
+#define PL_sv_no               (vTHX->Isv_no)
+#define PL_sv_objcount         (vTHX->Isv_objcount)
+#define PL_sv_root             (vTHX->Isv_root)
+#define PL_sv_undef            (vTHX->Isv_undef)
+#define PL_sv_yes              (vTHX->Isv_yes)
+#define PL_svref_mutex         (vTHX->Isvref_mutex)
+#define PL_sys_intern          (vTHX->Isys_intern)
+#define PL_tainting            (vTHX->Itainting)
+#define PL_thisexpr            (vTHX->Ithisexpr)
+#define PL_thr_key             (vTHX->Ithr_key)
+#define PL_threadnum           (vTHX->Ithreadnum)
+#define PL_threads_mutex       (vTHX->Ithreads_mutex)
+#define PL_threadsv_names      (vTHX->Ithreadsv_names)
+#define PL_thrsv               (vTHX->Ithrsv)
+#define PL_tokenbuf            (vTHX->Itokenbuf)
+#define PL_uid                 (vTHX->Iuid)
+#define PL_unsafe              (vTHX->Iunsafe)
+#define PL_utf8_alnum          (vTHX->Iutf8_alnum)
+#define PL_utf8_alnumc         (vTHX->Iutf8_alnumc)
+#define PL_utf8_alpha          (vTHX->Iutf8_alpha)
+#define PL_utf8_ascii          (vTHX->Iutf8_ascii)
+#define PL_utf8_cntrl          (vTHX->Iutf8_cntrl)
+#define PL_utf8_digit          (vTHX->Iutf8_digit)
+#define PL_utf8_graph          (vTHX->Iutf8_graph)
+#define PL_utf8_lower          (vTHX->Iutf8_lower)
+#define PL_utf8_mark           (vTHX->Iutf8_mark)
+#define PL_utf8_print          (vTHX->Iutf8_print)
+#define PL_utf8_punct          (vTHX->Iutf8_punct)
+#define PL_utf8_space          (vTHX->Iutf8_space)
+#define PL_utf8_tolower                (vTHX->Iutf8_tolower)
+#define PL_utf8_totitle                (vTHX->Iutf8_totitle)
+#define PL_utf8_toupper                (vTHX->Iutf8_toupper)
+#define PL_utf8_upper          (vTHX->Iutf8_upper)
+#define PL_utf8_xdigit         (vTHX->Iutf8_xdigit)
+#define PL_uudmap              (vTHX->Iuudmap)
+#define PL_warnhook            (vTHX->Iwarnhook)
+#define PL_xiv_arenaroot       (vTHX->Ixiv_arenaroot)
+#define PL_xiv_root            (vTHX->Ixiv_root)
+#define PL_xnv_root            (vTHX->Ixnv_root)
+#define PL_xpv_root            (vTHX->Ixpv_root)
+#define PL_xrv_root            (vTHX->Ixrv_root)
+#define PL_yychar              (vTHX->Iyychar)
+#define PL_yydebug             (vTHX->Iyydebug)
+#define PL_yyerrflag           (vTHX->Iyyerrflag)
+#define PL_yylval              (vTHX->Iyylval)
+#define PL_yynerrs             (vTHX->Iyynerrs)
+#define PL_yyval               (vTHX->Iyyval)
+
+#  endif       /* USE_THREADS */
+
 #else  /* !MULTIPLICITY */
+/* cases 1, 4 and 6 above */
 
 #define PL_IArgv               PL_Argv
 #define PL_ICmd                        PL_Cmd
 #define PL_Iyynerrs            PL_yynerrs
 #define PL_Iyyval              PL_yyval
 
-#ifndef USE_THREADS
+#  if defined(USE_THREADS)
+/* case 4 above */
+
+#define PL_Sv                  (aTHX->TSv)
+#define PL_Xpv                 (aTHX->TXpv)
+#define PL_av_fetch_sv         (aTHX->Tav_fetch_sv)
+#define PL_bodytarget          (aTHX->Tbodytarget)
+#define PL_bostr               (aTHX->Tbostr)
+#define PL_chopset             (aTHX->Tchopset)
+#define PL_colors              (aTHX->Tcolors)
+#define PL_colorset            (aTHX->Tcolorset)
+#define PL_curcop              (aTHX->Tcurcop)
+#define PL_curpad              (aTHX->Tcurpad)
+#define PL_curpm               (aTHX->Tcurpm)
+#define PL_curstack            (aTHX->Tcurstack)
+#define PL_curstackinfo                (aTHX->Tcurstackinfo)
+#define PL_curstash            (aTHX->Tcurstash)
+#define PL_defoutgv            (aTHX->Tdefoutgv)
+#define PL_defstash            (aTHX->Tdefstash)
+#define PL_delaymagic          (aTHX->Tdelaymagic)
+#define PL_dirty               (aTHX->Tdirty)
+#define PL_dumpindent          (aTHX->Tdumpindent)
+#define PL_extralen            (aTHX->Textralen)
+#define PL_firstgv             (aTHX->Tfirstgv)
+#define PL_formtarget          (aTHX->Tformtarget)
+#define PL_hv_fetch_ent_mh     (aTHX->Thv_fetch_ent_mh)
+#define PL_hv_fetch_sv         (aTHX->Thv_fetch_sv)
+#define PL_in_eval             (aTHX->Tin_eval)
+#define PL_last_in_gv          (aTHX->Tlast_in_gv)
+#define PL_lastgotoprobe       (aTHX->Tlastgotoprobe)
+#define PL_lastscream          (aTHX->Tlastscream)
+#define PL_localizing          (aTHX->Tlocalizing)
+#define PL_mainstack           (aTHX->Tmainstack)
+#define PL_markstack           (aTHX->Tmarkstack)
+#define PL_markstack_max       (aTHX->Tmarkstack_max)
+#define PL_markstack_ptr       (aTHX->Tmarkstack_ptr)
+#define PL_maxscream           (aTHX->Tmaxscream)
+#define PL_modcount            (aTHX->Tmodcount)
+#define PL_na                  (aTHX->Tna)
+#define PL_nrs                 (aTHX->Tnrs)
+#define PL_ofs                 (aTHX->Tofs)
+#define PL_ofslen              (aTHX->Tofslen)
+#define PL_op                  (aTHX->Top)
+#define PL_opsave              (aTHX->Topsave)
+#define PL_protect             (aTHX->Tprotect)
+#define PL_reg_call_cc         (aTHX->Treg_call_cc)
+#define PL_reg_curpm           (aTHX->Treg_curpm)
+#define PL_reg_eval_set                (aTHX->Treg_eval_set)
+#define PL_reg_flags           (aTHX->Treg_flags)
+#define PL_reg_ganch           (aTHX->Treg_ganch)
+#define PL_reg_leftiter                (aTHX->Treg_leftiter)
+#define PL_reg_magic           (aTHX->Treg_magic)
+#define PL_reg_maxiter         (aTHX->Treg_maxiter)
+#define PL_reg_oldcurpm                (aTHX->Treg_oldcurpm)
+#define PL_reg_oldpos          (aTHX->Treg_oldpos)
+#define PL_reg_oldsaved                (aTHX->Treg_oldsaved)
+#define PL_reg_oldsavedlen     (aTHX->Treg_oldsavedlen)
+#define PL_reg_poscache                (aTHX->Treg_poscache)
+#define PL_reg_poscache_size   (aTHX->Treg_poscache_size)
+#define PL_reg_re              (aTHX->Treg_re)
+#define PL_reg_start_tmp       (aTHX->Treg_start_tmp)
+#define PL_reg_start_tmpl      (aTHX->Treg_start_tmpl)
+#define PL_reg_starttry                (aTHX->Treg_starttry)
+#define PL_reg_sv              (aTHX->Treg_sv)
+#define PL_reg_whilem_seen     (aTHX->Treg_whilem_seen)
+#define PL_regbol              (aTHX->Tregbol)
+#define PL_regcc               (aTHX->Tregcc)
+#define PL_regcode             (aTHX->Tregcode)
+#define PL_regcomp_parse       (aTHX->Tregcomp_parse)
+#define PL_regcomp_rx          (aTHX->Tregcomp_rx)
+#define PL_regcompp            (aTHX->Tregcompp)
+#define PL_regdata             (aTHX->Tregdata)
+#define PL_regdummy            (aTHX->Tregdummy)
+#define PL_regendp             (aTHX->Tregendp)
+#define PL_regeol              (aTHX->Tregeol)
+#define PL_regexecp            (aTHX->Tregexecp)
+#define PL_regflags            (aTHX->Tregflags)
+#define PL_regfree             (aTHX->Tregfree)
+#define PL_regindent           (aTHX->Tregindent)
+#define PL_reginput            (aTHX->Treginput)
+#define PL_regint_start                (aTHX->Tregint_start)
+#define PL_regint_string       (aTHX->Tregint_string)
+#define PL_reginterp_cnt       (aTHX->Treginterp_cnt)
+#define PL_reglastparen                (aTHX->Treglastparen)
+#define PL_regnarrate          (aTHX->Tregnarrate)
+#define PL_regnaughty          (aTHX->Tregnaughty)
+#define PL_regnpar             (aTHX->Tregnpar)
+#define PL_regprecomp          (aTHX->Tregprecomp)
+#define PL_regprev             (aTHX->Tregprev)
+#define PL_regprogram          (aTHX->Tregprogram)
+#define PL_regsawback          (aTHX->Tregsawback)
+#define PL_regseen             (aTHX->Tregseen)
+#define PL_regsize             (aTHX->Tregsize)
+#define PL_regstartp           (aTHX->Tregstartp)
+#define PL_regtill             (aTHX->Tregtill)
+#define PL_regxend             (aTHX->Tregxend)
+#define PL_restartop           (aTHX->Trestartop)
+#define PL_retstack            (aTHX->Tretstack)
+#define PL_retstack_ix         (aTHX->Tretstack_ix)
+#define PL_retstack_max                (aTHX->Tretstack_max)
+#define PL_rs                  (aTHX->Trs)
+#define PL_savestack           (aTHX->Tsavestack)
+#define PL_savestack_ix                (aTHX->Tsavestack_ix)
+#define PL_savestack_max       (aTHX->Tsavestack_max)
+#define PL_scopestack          (aTHX->Tscopestack)
+#define PL_scopestack_ix       (aTHX->Tscopestack_ix)
+#define PL_scopestack_max      (aTHX->Tscopestack_max)
+#define PL_screamfirst         (aTHX->Tscreamfirst)
+#define PL_screamnext          (aTHX->Tscreamnext)
+#define PL_secondgv            (aTHX->Tsecondgv)
+#define PL_seen_evals          (aTHX->Tseen_evals)
+#define PL_seen_zerolen                (aTHX->Tseen_zerolen)
+#define PL_sortcop             (aTHX->Tsortcop)
+#define PL_sortcxix            (aTHX->Tsortcxix)
+#define PL_sortstash           (aTHX->Tsortstash)
+#define PL_stack_base          (aTHX->Tstack_base)
+#define PL_stack_max           (aTHX->Tstack_max)
+#define PL_stack_sp            (aTHX->Tstack_sp)
+#define PL_start_env           (aTHX->Tstart_env)
+#define PL_statbuf             (aTHX->Tstatbuf)
+#define PL_statcache           (aTHX->Tstatcache)
+#define PL_statgv              (aTHX->Tstatgv)
+#define PL_statname            (aTHX->Tstatname)
+#define PL_tainted             (aTHX->Ttainted)
+#define PL_timesbuf            (aTHX->Ttimesbuf)
+#define PL_tmps_floor          (aTHX->Ttmps_floor)
+#define PL_tmps_ix             (aTHX->Ttmps_ix)
+#define PL_tmps_max            (aTHX->Ttmps_max)
+#define PL_tmps_stack          (aTHX->Ttmps_stack)
+#define PL_top_env             (aTHX->Ttop_env)
+#define PL_toptarget           (aTHX->Ttoptarget)
+#define PL_watchaddr           (aTHX->Twatchaddr)
+#define PL_watchok             (aTHX->Twatchok)
+
+#  else                /* !USE_THREADS */
+/* cases 1 and 6 above */
 
 #define PL_TSv                 PL_Sv
 #define PL_TXpv                        PL_Xpv
 #define PL_Twatchaddr          PL_watchaddr
 #define PL_Twatchok            PL_watchok
 
-#endif /* USE_THREADS */
-
-/* Hide what would have been interpreter-specific symbols? */
+#  endif       /* USE_THREADS */
+#endif /* MULTIPLICITY */
 
-
-#ifndef USE_THREADS
-
-
-#endif /* USE_THREADS */
-#endif /* MULTIPLICITY */
-
-/* Now same trickey for per-thread variables */
-
-#ifdef USE_THREADS
-
-#define PL_Sv                  (thr->TSv)
-#define PL_Xpv                 (thr->TXpv)
-#define PL_av_fetch_sv         (thr->Tav_fetch_sv)
-#define PL_bodytarget          (thr->Tbodytarget)
-#define PL_bostr               (thr->Tbostr)
-#define PL_chopset             (thr->Tchopset)
-#define PL_colors              (thr->Tcolors)
-#define PL_colorset            (thr->Tcolorset)
-#define PL_curcop              (thr->Tcurcop)
-#define PL_curpad              (thr->Tcurpad)
-#define PL_curpm               (thr->Tcurpm)
-#define PL_curstack            (thr->Tcurstack)
-#define PL_curstackinfo                (thr->Tcurstackinfo)
-#define PL_curstash            (thr->Tcurstash)
-#define PL_defoutgv            (thr->Tdefoutgv)
-#define PL_defstash            (thr->Tdefstash)
-#define PL_delaymagic          (thr->Tdelaymagic)
-#define PL_dirty               (thr->Tdirty)
-#define PL_dumpindent          (thr->Tdumpindent)
-#define PL_extralen            (thr->Textralen)
-#define PL_firstgv             (thr->Tfirstgv)
-#define PL_formtarget          (thr->Tformtarget)
-#define PL_hv_fetch_ent_mh     (thr->Thv_fetch_ent_mh)
-#define PL_hv_fetch_sv         (thr->Thv_fetch_sv)
-#define PL_in_eval             (thr->Tin_eval)
-#define PL_last_in_gv          (thr->Tlast_in_gv)
-#define PL_lastgotoprobe       (thr->Tlastgotoprobe)
-#define PL_lastscream          (thr->Tlastscream)
-#define PL_localizing          (thr->Tlocalizing)
-#define PL_mainstack           (thr->Tmainstack)
-#define PL_markstack           (thr->Tmarkstack)
-#define PL_markstack_max       (thr->Tmarkstack_max)
-#define PL_markstack_ptr       (thr->Tmarkstack_ptr)
-#define PL_maxscream           (thr->Tmaxscream)
-#define PL_modcount            (thr->Tmodcount)
-#define PL_na                  (thr->Tna)
-#define PL_nrs                 (thr->Tnrs)
-#define PL_ofs                 (thr->Tofs)
-#define PL_ofslen              (thr->Tofslen)
-#define PL_op                  (thr->Top)
-#define PL_opsave              (thr->Topsave)
-#define PL_protect             (thr->Tprotect)
-#define PL_reg_call_cc         (thr->Treg_call_cc)
-#define PL_reg_curpm           (thr->Treg_curpm)
-#define PL_reg_eval_set                (thr->Treg_eval_set)
-#define PL_reg_flags           (thr->Treg_flags)
-#define PL_reg_ganch           (thr->Treg_ganch)
-#define PL_reg_leftiter                (thr->Treg_leftiter)
-#define PL_reg_magic           (thr->Treg_magic)
-#define PL_reg_maxiter         (thr->Treg_maxiter)
-#define PL_reg_oldcurpm                (thr->Treg_oldcurpm)
-#define PL_reg_oldpos          (thr->Treg_oldpos)
-#define PL_reg_oldsaved                (thr->Treg_oldsaved)
-#define PL_reg_oldsavedlen     (thr->Treg_oldsavedlen)
-#define PL_reg_poscache                (thr->Treg_poscache)
-#define PL_reg_poscache_size   (thr->Treg_poscache_size)
-#define PL_reg_re              (thr->Treg_re)
-#define PL_reg_start_tmp       (thr->Treg_start_tmp)
-#define PL_reg_start_tmpl      (thr->Treg_start_tmpl)
-#define PL_reg_starttry                (thr->Treg_starttry)
-#define PL_reg_sv              (thr->Treg_sv)
-#define PL_reg_whilem_seen     (thr->Treg_whilem_seen)
-#define PL_regbol              (thr->Tregbol)
-#define PL_regcc               (thr->Tregcc)
-#define PL_regcode             (thr->Tregcode)
-#define PL_regcomp_parse       (thr->Tregcomp_parse)
-#define PL_regcomp_rx          (thr->Tregcomp_rx)
-#define PL_regcompp            (thr->Tregcompp)
-#define PL_regdata             (thr->Tregdata)
-#define PL_regdummy            (thr->Tregdummy)
-#define PL_regendp             (thr->Tregendp)
-#define PL_regeol              (thr->Tregeol)
-#define PL_regexecp            (thr->Tregexecp)
-#define PL_regflags            (thr->Tregflags)
-#define PL_regfree             (thr->Tregfree)
-#define PL_regindent           (thr->Tregindent)
-#define PL_reginput            (thr->Treginput)
-#define PL_regint_start                (thr->Tregint_start)
-#define PL_regint_string       (thr->Tregint_string)
-#define PL_reginterp_cnt       (thr->Treginterp_cnt)
-#define PL_reglastparen                (thr->Treglastparen)
-#define PL_regnarrate          (thr->Tregnarrate)
-#define PL_regnaughty          (thr->Tregnaughty)
-#define PL_regnpar             (thr->Tregnpar)
-#define PL_regprecomp          (thr->Tregprecomp)
-#define PL_regprev             (thr->Tregprev)
-#define PL_regprogram          (thr->Tregprogram)
-#define PL_regsawback          (thr->Tregsawback)
-#define PL_regseen             (thr->Tregseen)
-#define PL_regsize             (thr->Tregsize)
-#define PL_regstartp           (thr->Tregstartp)
-#define PL_regtill             (thr->Tregtill)
-#define PL_regxend             (thr->Tregxend)
-#define PL_restartop           (thr->Trestartop)
-#define PL_retstack            (thr->Tretstack)
-#define PL_retstack_ix         (thr->Tretstack_ix)
-#define PL_retstack_max                (thr->Tretstack_max)
-#define PL_rs                  (thr->Trs)
-#define PL_savestack           (thr->Tsavestack)
-#define PL_savestack_ix                (thr->Tsavestack_ix)
-#define PL_savestack_max       (thr->Tsavestack_max)
-#define PL_scopestack          (thr->Tscopestack)
-#define PL_scopestack_ix       (thr->Tscopestack_ix)
-#define PL_scopestack_max      (thr->Tscopestack_max)
-#define PL_screamfirst         (thr->Tscreamfirst)
-#define PL_screamnext          (thr->Tscreamnext)
-#define PL_secondgv            (thr->Tsecondgv)
-#define PL_seen_evals          (thr->Tseen_evals)
-#define PL_seen_zerolen                (thr->Tseen_zerolen)
-#define PL_sortcop             (thr->Tsortcop)
-#define PL_sortcxix            (thr->Tsortcxix)
-#define PL_sortstash           (thr->Tsortstash)
-#define PL_stack_base          (thr->Tstack_base)
-#define PL_stack_max           (thr->Tstack_max)
-#define PL_stack_sp            (thr->Tstack_sp)
-#define PL_start_env           (thr->Tstart_env)
-#define PL_statbuf             (thr->Tstatbuf)
-#define PL_statcache           (thr->Tstatcache)
-#define PL_statgv              (thr->Tstatgv)
-#define PL_statname            (thr->Tstatname)
-#define PL_tainted             (thr->Ttainted)
-#define PL_timesbuf            (thr->Ttimesbuf)
-#define PL_tmps_floor          (thr->Ttmps_floor)
-#define PL_tmps_ix             (thr->Ttmps_ix)
-#define PL_tmps_max            (thr->Ttmps_max)
-#define PL_tmps_stack          (thr->Ttmps_stack)
-#define PL_top_env             (thr->Ttop_env)
-#define PL_toptarget           (thr->Ttoptarget)
-#define PL_watchaddr           (thr->Twatchaddr)
-#define PL_watchok             (thr->Twatchok)
-
-#endif /* USE_THREADS */
-
-#ifdef PERL_GLOBAL_STRUCT
+#if defined(PERL_GLOBAL_STRUCT)
 
 #define PL_No                  (PL_Vars.GNo)
 #define PL_Yes                 (PL_Vars.GYes)
 #define PL_Ghexdigit           PL_hexdigit
 #define PL_Gpatleave           PL_patleave
 
-
 #endif /* PERL_GLOBAL_STRUCT */
 
-
 #ifdef PERL_POLLUTE            /* disabled by default in 5.006 */
 
 #define DBsingle               PL_DBsingle
diff --git a/perl.c b/perl.c
index 8c8b84c..46fd2c3 100644 (file)
--- a/perl.c
+++ b/perl.c
@@ -61,7 +61,8 @@ perl_alloc(void)
 {
     PerlInterpreter *my_perl;
 
-    New(53, my_perl, 1, PerlInterpreter);
+    /* New() needs interpreter, so call malloc() instead */
+    my_perl = PerlMem_malloc(sizeof(PerlInterpreter));
     PERL_SET_INTERP(my_perl);
     return my_perl;
 }
@@ -81,6 +82,14 @@ perl_construct(pTHXx)
     Zero(my_perl, 1, PerlInterpreter);
 #endif
 
+#ifdef MULTIPLICITY
+    init_interp();
+    PL_perl_destruct_level = 1; 
+#else
+   if (PL_perl_destruct_level > 0)
+       init_interp();
+#endif
+
    /* Init the real globals (and main thread)? */
     if (!PL_linestr) {
 #ifdef USE_THREADS
@@ -158,13 +167,6 @@ perl_construct(pTHXx)
     PL_rs = SvREFCNT_inc(PL_nrs);
 
     init_stacks();
-#ifdef MULTIPLICITY
-    init_interp();
-    PL_perl_destruct_level = 1; 
-#else
-   if (PL_perl_destruct_level > 0)
-       init_interp();
-#endif
 
     init_ids();
     PL_lex_state = LEX_NOTPARSING;
@@ -1885,8 +1887,13 @@ S_init_interp(pTHX)
 #    define PERLVAR(var,type)
 #    define PERLVARA(var,n,type)
 #    if defined(PERL_IMPLICIT_CONTEXT)
-#      define PERLVARI(var,type,init)  my_perl->var = init;
-#      define PERLVARIC(var,type,init) my_perl->var = init;
+#      if defined(USE_THREADS)
+#        define PERLVARI(var,type,init)                PERL_GET_INTERP->var = init;
+#        define PERLVARIC(var,type,init)       PERL_GET_INTERP->var = init;
+#      else /* !USE_THREADS */
+#        define PERLVARI(var,type,init)                aTHX->var = init;
+#        define PERLVARIC(var,type,init)       aTHX->var = init;
+#      endif /* USE_THREADS */
 #    else
 #      define PERLVARI(var,type,init)  PERL_GET_INTERP->var = init;
 #      define PERLVARIC(var,type,init) PERL_GET_INTERP->var = init;
diff --git a/perl.h b/perl.h
index a05c726..8e4e452 100644 (file)
--- a/perl.h
+++ b/perl.h
@@ -155,8 +155,8 @@ class CPerlObj;
 #define PERL_OBJECT_THIS       aTHXo
 #define PERL_OBJECT_THIS_      aTHXo_
 #define _PERL_OBJECT_THIS      _aTHXo
-#define dTHXoa(a)              pTHXo = (CPerlObj *)a
-#define dTHXo                  dTHXoa(PERL_GET_INTERP)
+#define dTHXoa(a)              pTHXo = a
+#define dTHXo                  dTHXoa(PERL_GET_THX)
 
 #define pTHXx          void
 #define pTHXx_
@@ -172,8 +172,6 @@ class CPerlObj;
 struct perl_thread;
 #    define pTHX       register struct perl_thread *thr
 #    define aTHX       thr
-#    define dTHXa(a)   pTHX = (struct perl_thread *)a
-#    define dTHX       dTHXa(THR)
 #    define dTHR       dNOOP
 #  else
 #    ifndef MULTIPLICITY
@@ -181,9 +179,9 @@ struct perl_thread;
 #    endif
 #    define pTHX       register PerlInterpreter *my_perl
 #    define aTHX       my_perl
-#    define dTHXa(a)   pTHX = (PerlInterpreter *)a
-#    define dTHX       dTHXa(PERL_GET_INTERP)
 #  endif
+#  define dTHXa(a)     pTHX = a
+#  define dTHX         dTHXa(PERL_GET_THX)
 #  define pTHX_                pTHX,
 #  define _pTHX                ,pTHX
 #  define aTHX_                aTHX,
@@ -1645,6 +1643,22 @@ typedef pthread_key_t    perl_key;
 #  define PERL_GET_INTERP              (PL_curinterp)
 #endif
 
+#if defined(PERL_IMPLICIT_CONTEXT) && !defined(PERL_GET_THX)
+#  ifdef USE_THREADS
+#    define PERL_GET_THX               THR
+#  else
+#  ifdef MULTIPLICITY
+#    define PERL_GET_THX               PERL_GET_INTERP
+#  else
+#  ifdef PERL_OBJECT
+#    define PERL_GET_THX               ((CPerlObj*)PERL_GET_INTERP)
+#  else
+#    define PERL_GET_THX               ((void*)0)
+#  endif
+#  endif
+#  endif
+#endif
+
 /* Some unistd.h's give a prototype for pause() even though
    HAS_PAUSE ends up undefined.  This causes the #define
    below to be rejected by the compmiler.  Sigh.
@@ -2507,7 +2521,9 @@ struct perl_vars *PL_VarsPtr;
 */
 
 struct interpreter {
-#include "thrdvar.h"
+#ifndef USE_THREADS
+#  include "thrdvar.h"
+#endif
 #include "intrpvar.h"
 };
 
index 74b5ff9..4081570 100644 (file)
@@ -1522,27 +1522,28 @@ a C structure, or inside a thread.  The thread, the C structure, or
 the C++ object will contain all the context, the state of that
 interpreter.
 
-Four macros control the way Perl is built: PERL_IMPLICIT_CONTEXT
-(build for multiple interpreters?), MULTIPLICITY (we pass around an
-C interpreter structure as the first argument), USE_THREADS (we pass
-around a thread as the first argument), and PERL_OBJECT (we build a
-C++ class for the interpreter so the Perl API implementation has a
-C<this> object).  If PERL_IMPLICIT_CONTEXT is not defined, then
-subroutines take no first argument.
-
-This obviously requires a way for the Perl internal functions to be
+Three macros control the major Perl build flavors: MULTIPLICITY,
+USE_THREADS and PERL_OBJECT.  The MULTIPLICITY build has a C structure
+that packages all the interpreter state, there is a similar thread-specific
+data structure under USE_THREADS, and the PERL_OBJECT build has a C++
+class to maintain interpreter state.  In all three cases,
+PERL_IMPLICIT_CONTEXT is also normally defined, and enables the
+support for passing in a "hidden" first argument that represents all three
+data structures.  (The traditional MULTIPLICITY and USE_THREADS builds
+built without PERL_IMPLICIT_CONTEXT may also be supported, but this is
+currently somewhat broken.)
+
+All this obviously requires a way for the Perl internal functions to be
 C++ methods, subroutines taking some kind of structure as the first
 argument, or subroutines taking nothing as the first argument.  To
 enable these three very different ways of building the interpreter,
 the Perl source (as it does in so many other situations) makes heavy
 use of macros and subroutine naming conventions.
 
-First problem: deciding which functions will be C++ public methods and
+First problem: deciding which functions will be public API functions and
 which will be private.  Those functions whose names begin C<Perl_> are
-public, and those whose names begin C<S_> are protected (think "S" for
-"Secret").  You can't call them from C++, and should not call them
-from C.  If you find yourself calling an C<S_> function, consider your
-code broken (even though it works, it may not do so forever).
+public, and those whose names begin C<S_> are private (think "S" for
+"secret" or "static").
 
 Some functions have no prefix (e.g., restore_rsfp in toke.c).  These
 are not parts of the object or pseudo-structure because you need to
@@ -1575,11 +1576,11 @@ argument containing the interpreter's context.  The trailing underscore
 in the pTHX_ macro indicates that the macro expansion needs a comma
 after the context argument because other arguments follow it.  If
 PERL_IMPLICIT_CONTEXT is not defined, pTHX_ will be ignored, and the
-subroutine is not prototyped to take an argument.  The form of the
-macro without the trailing underscore is used when there are no
+subroutine is not prototyped to take the extra argument.  The form of the
+macro without the trailing underscore is used when there are no additional
 explicit arguments.
 
-When an core function calls another, it must pass the context.  This
+When a core function calls another, it must pass the context.  This
 is normally hidden via macros.  Consider C<sv_setsv>.  It expands
 something like this:
 
@@ -1646,11 +1647,12 @@ Thus, something like:
 
         sv_setsv(asv, bsv);
 
-in your extesion will translate to this:
+in your extesion will translate to this when PERL_IMPLICIT_CONTEXT is
+in effect:
 
         Perl_sv_setsv(GetPerlInterpreter(), asv, bsv);
 
-when PERL_IMPLICIT_CONTEXT is in effect, or to this otherwise:
+or to this otherwise:
 
         Perl_sv_setsv(asv, bsv);
 
@@ -1669,7 +1671,7 @@ your Foo.xs:
         static my_private_function(int arg1, int arg2);
 
        static SV *
-       my_private_function(pTHX_ int arg1, int arg2)
+       my_private_function(int arg1, int arg2)
        {
            dTHX;       /* fetch context */
            ... call many Perl API functions ...
diff --git a/util.c b/util.c
index 715a5f1..a36d899 100644 (file)
--- a/util.c
+++ b/util.c
@@ -81,12 +81,13 @@ long lastxycount[MAXXCOUNT][MAXYCOUNT];
 Malloc_t
 Perl_safesysmalloc(MEM_SIZE size)
 {
+    dTHX;
     Malloc_t ptr;
 #ifdef HAS_64K_LIMIT
        if (size > 0xffff) {
            PerlIO_printf(PerlIO_stderr(),
                          "Allocation too large: %lx\n", size) FLUSH;
-           WITH_THX(my_exit(1));
+           my_exit(1);
        }
 #endif /* HAS_64K_LIMIT */
 #ifdef DEBUGGING
@@ -94,18 +95,14 @@ Perl_safesysmalloc(MEM_SIZE size)
        Perl_croak_nocontext("panic: malloc");
 #endif
     ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
-#if !(defined(I286) || defined(atarist))
-    DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%x: (%05d) malloc %ld bytes\n",ptr,PL_an++,(long)size));
-#else
     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) malloc %ld bytes\n",ptr,PL_an++,(long)size));
-#endif
     if (ptr != Nullch)
        return ptr;
     else if (PL_nomemok)
        return Nullch;
     else {
        PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
-       WITH_THX(my_exit(1));
+       my_exit(1);
         return Nullch;
     }
     /*NOTREACHED*/
@@ -116,6 +113,7 @@ Perl_safesysmalloc(MEM_SIZE size)
 Malloc_t
 Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
 {
+    dTHX;
     Malloc_t ptr;
 #if !defined(STANDARD_C) && !defined(HAS_REALLOC_PROTOTYPE)
     Malloc_t PerlMem_realloc();
@@ -125,7 +123,7 @@ Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
     if (size > 0xffff) {
        PerlIO_printf(PerlIO_stderr(),
                      "Reallocation too large: %lx\n", size) FLUSH;
-       WITH_THX(my_exit(1));
+       my_exit(1);
     }
 #endif /* HAS_64K_LIMIT */
     if (!size) {
@@ -141,17 +139,10 @@ Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
 #endif
     ptr = PerlMem_realloc(where,size);
 
-#if !(defined(I286) || defined(atarist))
-    DEBUG_m( {
-       PerlIO_printf(Perl_debug_log, "0x%x: (%05d) rfree\n",where,PL_an++);
-       PerlIO_printf(Perl_debug_log, "0x%x: (%05d) realloc %ld bytes\n",ptr,PL_an++,(long)size);
-    } )
-#else
     DEBUG_m( {
        PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) rfree\n",where,PL_an++);
        PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) realloc %ld bytes\n",ptr,PL_an++,(long)size);
     } )
-#endif
 
     if (ptr != Nullch)
        return ptr;
@@ -159,7 +150,7 @@ Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
        return Nullch;
     else {
        PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
-       WITH_THX(my_exit(1));
+       my_exit(1);
        return Nullch;
     }
     /*NOTREACHED*/
@@ -170,11 +161,8 @@ Perl_safesysrealloc(Malloc_t where,MEM_SIZE size)
 Free_t
 Perl_safesysfree(Malloc_t where)
 {
-#if !(defined(I286) || defined(atarist))
-    DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%x: (%05d) free\n",(char *) where,PL_an++));
-#else
+    dTHX;
     DEBUG_m( PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) free\n",(char *) where,PL_an++));
-#endif
     if (where) {
        /*SUPPRESS 701*/
        PerlMem_free(where);
@@ -186,13 +174,14 @@ Perl_safesysfree(Malloc_t where)
 Malloc_t
 Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
 {
+    dTHX;
     Malloc_t ptr;
 
 #ifdef HAS_64K_LIMIT
     if (size * count > 0xffff) {
        PerlIO_printf(PerlIO_stderr(),
                      "Allocation too large: %lx\n", size * count) FLUSH;
-       WITH_THX(my_exit(1));
+       my_exit(1);
     }
 #endif /* HAS_64K_LIMIT */
 #ifdef DEBUGGING
@@ -201,11 +190,7 @@ Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
 #endif
     size *= count;
     ptr = PerlMem_malloc(size?size:1); /* malloc(0) is NASTY on our system */
-#if !(defined(I286) || defined(atarist))
-    DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%x: (%05d) calloc %ld  x %ld bytes\n",ptr,PL_an++,(long)count,(long)size));
-#else
     DEBUG_m(PerlIO_printf(Perl_debug_log, "0x%lx: (%05d) calloc %ld x %ld bytes\n",ptr,PL_an++,(long)count,(long)size));
-#endif
     if (ptr != Nullch) {
        memset((void*)ptr, 0, size);
        return ptr;
@@ -214,7 +199,7 @@ Perl_safesyscalloc(MEM_SIZE count, MEM_SIZE size)
        return Nullch;
     else {
        PerlIO_puts(PerlIO_stderr(),PL_no_mem) FLUSH;
-       WITH_THX(my_exit(1));
+       my_exit(1);
        return Nullch;
     }
     /*NOTREACHED*/